@camstack/addon-provider-bosch 0.1.1 → 0.1.2

package/dist/home-connect/addon.js

@@ -1,7 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dist = require("../dist-QXDYCZIL.js");
-const require_account_integration_offline = require("../account-integration-offline-Cbixus9v.js");
+const require_dist = require("../dist-DvEvuaoA.js");
+const require_account_integration_offline = require("../account-integration-offline-B_AZ8wAX.js");
 let node_crypto = require("node:crypto");
+let node_tls = require("node:tls");
+let node_zlib = require("node:zlib");
+let node_dns_promises = require("node:dns/promises");
 //#region src/home-connect/custom-actions.ts
 var homeConnectActions = require_dist.defineCustomActions({
 	beginSignIn: require_dist.customAction(require_dist.object({}), require_dist.object({
@@ -28,9 +31,331 @@ var homeConnectActions = require_dist.defineCustomActions({
 	})
 });
 //#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 (0, node_zlib.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 = "9B75AC9EC512F36C84256AC47D813E2C1DD0D6520DF774B020E1E6E2EB29B1F3";
+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";
@@ -57,7 +382,7 @@ var CookieJar = class {
 function headerList(value) {
 	return value ? [value] : [];
 }
-async function defaultFetch(url, init) {
+async function homeConnectLoginFetch(url, init) {
 	const response = await fetch(url, {
 		method: init.method,
 		headers: { ...init.headers },
@@ -67,7 +392,8 @@ async function defaultFetch(url, init) {
 	return {
 		status: response.status,
 		headers: response.headers,
-		text: () => response.text()
+		text: () => response.text(),
+		arrayBuffer: () => response.arrayBuffer()
 	};
 }
 function b64url(bytes) {
@@ -197,12 +523,34 @@ async function appliancesForToken(token, fetchImpl, jar) {
 		}
 		if (!isRecord(encryption)) continue;
 		const appliance = listedFromPaired(row, encryption);
-		if (appliance) out.push(appliance);
+		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 = defaultFetch) {
+async function fetchHomeConnectAccount(creds, fetchImpl = homeConnectLoginFetch) {
 	const jar = new CookieJar();
 	let token = creds.token;
 	let refresh = creds.refresh ?? "";
@@ -220,7 +568,7 @@ async function fetchHomeConnectAccount(creds, fetchImpl = defaultFetch) {
 	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
+		client_id: APP_ID$1
 	}).toString());
 	if (refreshed.status >= 400) throw new Error("Home Connect sign-in was rejected");
 	const next = tokensFromBody(refreshed.body);
@@ -241,7 +589,7 @@ function beginHomeConnectSignIn() {
 	const state = b64url((0, node_crypto.randomBytes)(16));
 	const authorize = new URL("authorize", OAUTH_BASE);
 	authorize.searchParams.set("redirect_url", REDIRECT_URI);
-	authorize.searchParams.set("client_id", APP_ID);
+	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");
@@ -272,13 +620,13 @@ function callbackParams(callback) {
 	};
 }
 /** Exchange the pasted redirect for the account token and each appliance profile. */
-async function completeHomeConnectSignIn(input, fetchImpl = defaultFetch) {
+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,
+		client_id: APP_ID$1,
 		code,
 		code_verifier: input.verifier,
 		redirect_uri: REDIRECT_URI
@@ -286,31 +634,359 @@ async function completeHomeConnectSignIn(input, fetchImpl = defaultFetch) {
 	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: require_dist.DeviceRole.EnergySensor
+	},
+	{
+		stableIdSuffix: "water-forecast",
+		kind: "water-forecast",
+		featureKeys: [HC_FEATURE_WATER_FORECAST],
+		cap: "numeric-sensor",
+		defaultUnit: "%",
+		nameSuffix: "Water forecast",
+		role: require_dist.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: require_dist.DeviceRole.EnergySensor
+	},
+	{
+		stableIdSuffix: "water-consumed",
+		kind: "water-consumed",
+		featureKeys: [HC_FEATURE_WATER_CONSUMPTION],
+		cap: "numeric-sensor",
+		defaultUnit: "l",
+		nameSuffix: "Water consumed",
+		role: require_dist.DeviceRole.NumericSensor
+	},
+	{
+		stableIdSuffix: "remote-control-level",
+		kind: "remote-control-level",
+		featureKeys: [HC_FEATURE_REMOTE_CONTROL_LEVEL],
+		cap: "enum-sensor",
+		nameSuffix: "Remote control level",
+		role: require_dist.DeviceRole.EnumSensor
+	},
+	{
+		stableIdSuffix: "delayed-start",
+		kind: "delayed-start",
+		featureKeys: [HC_FEATURE_START_IN_RELATIVE],
+		cap: "numeric-sensor",
+		defaultUnit: "min",
+		nameSuffix: "Delayed start",
+		role: require_dist.DeviceRole.NumericSensor
+	},
+	{
+		stableIdSuffix: "interior-light",
+		kind: "interior-light",
+		featureKeys: [HC_FEATURE_AMBIENT_LIGHT, HC_FEATURE_INTERIOR_LIGHT],
+		cap: "binary",
+		nameSuffix: "Interior light",
+		role: require_dist.DeviceRole.BinaryHelper
+	},
+	{
+		stableIdSuffix: "connectivity",
+		kind: "connectivity",
+		featureKeys: [HC_FEATURE_BACKEND_CONNECTED, HC_FEATURE_CLOUD_CONNECTED],
+		cap: "binary",
+		nameSuffix: "Connectivity",
+		role: require_dist.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: require_dist.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 require_dist.DeviceType.Dishwasher;
+	if (type.toLowerCase().includes("dishwasher")) return require_dist.DeviceType.Container;
 	return null;
 }
-function buildHomeConnectCandidates(input) {
-	const out = [];
-	for (const app of input.appliances) {
-		const camType = deviceTypeForApplianceType(app.type);
-		if (camType === null) continue;
-		const adoptedId = input.adopted.get(app.haId) ?? null;
-		out.push({
-			childNativeId: app.haId,
-			name: app.name.length > 0 ? app.name : app.haId,
-			type: camType,
+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: require_dist.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: require_dist.DeviceType.Dishwasher,
 			status: "online",
 			metadata: {
 				serialNumber: app.haId,
 				model: app.type
 			},
-			alreadyAdopted: adoptedId !== null,
-			adoptedDeviceId: adoptedId,
-			capabilities: camType === require_dist.DeviceType.Dishwasher ? ["dishwasher"] : []
-		});
+			alreadyAdopted: false,
+			adoptedDeviceId: null,
+			capabilities: ["dishwasher"]
+		};
+		return sensorDiscoveryChild(app.haId, spec);
+	});
+	return {
+		childNativeId: app.haId,
+		name,
+		type: require_dist.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;
 }
@@ -466,7 +1142,8 @@ var homeConnectStoredApplianceSchema = require_dist.object({
 	host: require_dist.string().min(1),
 	psk: require_dist.string().min(1),
 	mode: HomeConnectModeSchema,
-	iv64: require_dist.string().optional()
+	iv64: require_dist.string().optional(),
+	deviceDescription: homeConnectDeviceDescriptionSchema
 });
 /** The integration is the Home Connect account. Profiles are downloaded once at sign-in. */
 var homeConnectConfigSchema = require_dist.object({
@@ -679,6 +1356,428 @@ var HomeConnectConnectionResolver = class {
 };
 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 = (0, node_crypto.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 = (0, node_tls.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 = (0, node_crypto.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) {
@@ -754,10 +1853,110 @@ function parseDeviceDescription(input) {
 		return { appliances: [] };
 	}
 }
-function createHomeConnectWsClient(config, deps = {}) {
-	const wsFactory = deps.wsFactory ?? defaultWsFactory;
+function usesProtocolStack(config, deps) {
+	if (deps.wireFactory) return true;
+	return config.mode === "TLS";
+}
+async function resolveConnectAddress(host) {
+	try {
+		const result = await (0, node_dns_promises.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 appliances = [...parseDeviceDescription(config.deviceDescription).appliances];
 	const featureStore = /* @__PURE__ */ new Map();
 	const listeners = /* @__PURE__ */ new Set();
 	let ws = null;
@@ -802,27 +2001,9 @@ function createHomeConnectWsClient(config, deps = {}) {
 						if (typeof msg !== "object" || msg === null) return;
 						const row = msg;
 						if (row["type"] === "feature") {
-							const haId = row["haId"];
+							const msgHaId = row["haId"];
 							const key = row["key"];
-							if (typeof haId === "string" && typeof key === "string") applyFeature(haId, key, row["value"]);
-						}
-						if (row["type"] === "appliance") {
-							const haId = row["haId"];
-							const name = row["name"];
-							const type = row["type"];
-							const programs = row["programs"];
-							if (typeof haId === "string") {
-								const programList = [];
-								if (Array.isArray(programs)) {
-									for (const p of programs) if (typeof p === "string") programList.push(p);
-								}
-								appliances.push({
-									haId,
-									name: typeof name === "string" ? name : haId,
-									type: typeof type === "string" ? type : "Dishwasher",
-									availablePrograms: programList
-								});
-							}
+							if (typeof msgHaId === "string" && typeof key === "string") applyFeature(msgHaId, key, row["value"]);
 						}
 					} catch {}
 				});
@@ -857,10 +2038,10 @@ function createHomeConnectWsClient(config, deps = {}) {
 }
 function isWsLike(value) {
 	if (typeof value !== "object" || value === null) return false;
-	const ws = value;
-	return typeof ws["readyState"] === "number" && typeof ws["send"] === "function" && typeof ws["close"] === "function" && typeof ws["addEventListener"] === "function" && typeof ws["removeEventListener"] === "function";
+	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 defaultWsFactory(url) {
+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);
@@ -921,8 +2102,115 @@ function accountClient(appliances, makeGateway) {
 	};
 }
 //#endregion
-//#region src/home-connect/home-connect-integration-manager.ts
-function storedAppliance(row) {
+//#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 (require_dist.isSecretMarker(token) || require_dist.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,
@@ -932,21 +2220,48 @@ function storedAppliance(row) {
 			psk: row.psk,
 			mode: row.mode,
 			iv64: row.iv64 ?? "",
-			deviceDescription: JSON.stringify({ info: {
-				deviceID: row.haId,
-				deviceType: row.type,
-				model: row.name
-			} })
+			deviceDescription: serializedDeviceDescription(row)
 		}
 	};
 }
-async function openStoredOrAccount(connection) {
-	const stored = connection.appliances ?? [];
-	if (stored.length > 0) return accountClient(stored.map(storedAppliance), defaultHomeConnectWsClientFactory);
-	return openHomeConnectAccount({
-		token: connection.token,
-		refresh: connection.refresh ?? ""
-	});
+//#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 (require_dist.isSecretMarker(token) || require_dist.isSecretMarkerLike(token)) deps.logger?.warn("Home Connect skipping IDDF enrich — access token not resolved yet", { meta: { tokenIsSecretMarker: require_dist.isSecretMarker(token) } });
+		const enriched = require_dist.isSecretMarker(token) || require_dist.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;
@@ -957,6 +2272,8 @@ var HomeConnectIntegrationManager = class {
 	#onDisconnected;
 	#surfaceSink;
 	#makeClient;
+	#fetchImpl;
+	#onConnectionUpdated;
 	#client = null;
 	#status = "disconnected";
 	#lastCheckedAt = null;
@@ -970,6 +2287,8 @@ var HomeConnectIntegrationManager = class {
 		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;
@@ -990,7 +2309,18 @@ var HomeConnectIntegrationManager = class {
 		if (this.#client !== null) return;
 		this.#status = "connecting";
 		this.#error = null;
-		const client = this.#makeClient ? this.#makeClient(this.#connection) : await openStoredOrAccount(this.#connection);
+		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, {
@@ -1057,12 +2387,15 @@ var HomeConnectClientRegistry = class {
 	#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,
@@ -1071,7 +2404,9 @@ var HomeConnectClientRegistry = class {
 			onConnected: opts.onConnected,
 			onDisconnected: opts.onDisconnected,
 			surfaceSink: homeConnectConnections,
-			makeClient
+			makeClient,
+			fetchImpl,
+			onConnectionUpdated: this.#onConnectionUpdated
 		}));
 	}
 	setOnConnected(cb) {
@@ -1088,7 +2423,7 @@ var HomeConnectClientRegistry = class {
 				await existing.manager.applyConnection(connection);
 				this.#entries.set(integrationId, {
 					manager: existing.manager,
-					connection
+					connection: existing.manager.getConnection()
 				});
 			} catch (err) {
 				this.#logger.warn("HomeConnectClientRegistry: applyConnection failed", { meta: {
@@ -1112,6 +2447,10 @@ var HomeConnectClientRegistry = class {
 		});
 		try {
 			await manager.start();
+			this.#entries.set(integrationId, {
+				manager,
+				connection: manager.getConnection()
+			});
 		} catch (err) {
 			this.#logger.warn("HomeConnectClientRegistry: manager start failed", { meta: {
 				integrationId,
@@ -1213,83 +2552,6 @@ function buildHomeConnectConnectionTestProvider(deps) {
 		}
 	};
 }
-var HC_FEATURE_ACTIVE_PROGRAM = "BSH.Common.Setting.Program.Active";
-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 OPERATION_TO_STATE = {
-	Ready: "idle",
-	Inactive: "idle",
-	Run: "running",
-	Pause: "paused",
-	Finished: "finished",
-	Error: "error"
-};
-function mapConsumable(raw) {
-	if (raw === "Full" || raw === "OK" || raw === "Ok") return "ok";
-	if (raw === "Low" || raw === "NearlyEmpty") return "low";
-	if (raw === "Empty") return "empty";
-	return null;
-}
-function readBool(raw) {
-	return raw === true || raw === "On" || raw === "Open" || raw === "Connected";
-}
-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;
-}
-/**
-* 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(features.get(HC_FEATURE_ACTIVE_PROGRAM));
-	let remainingMinutes = readNumber(features.get(HC_FEATURE_REMAINING));
-	if (remainingMinutes !== null && remainingMinutes > 600) remainingMinutes = Math.round(remainingMinutes / 60);
-	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 = features.get(HC_FEATURE_POWER) !== "Off";
-	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)),
-		errorCode: state === "error" ? 1 : null,
-		errorLabel: state === "error" ? op : null,
-		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/devices/home-connect-dishwasher-device.ts
 var homeConnectDishwasherSchema = require_dist.object({
@@ -1314,6 +2576,10 @@ var COLD_START = {
 	rinseAidLevel: null,
 	halfLoad: false,
 	hygienePlus: false,
+	extraDry: false,
+	intensiveZone: false,
+	varioSpeedPlus: false,
+	childLock: false,
 	errorCode: null,
 	errorLabel: null,
 	lastFetchedAt: 0
@@ -1324,9 +2590,10 @@ var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
 	#brokerId;
 	#availablePrograms;
 	#featureUnsub = null;
+	#intensiveZoneWriteKey = HC_FEATURE_INTENSIVE_ZONE;
 	constructor(ctx) {
 		const persisted = homeConnectDishwasherSchema.parse(ctx.persistedConfig ?? {});
-		super(ctx, homeConnectDishwasherSchema, { type: ctx.deviceMeta.type });
+		super(ctx, homeConnectDishwasherSchema, { type: require_dist.DeviceType.Dishwasher });
 		this.#haId = persisted.haId;
 		this.#brokerId = persisted.brokerId;
 		this.#availablePrograms = persisted.availablePrograms;
@@ -1351,8 +2618,9 @@ var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
 	attachFeatureListener() {
 		const client = homeConnectConnections.getClient(this.#brokerId);
 		if (!client) return;
-		this.#featureUnsub = client.onFeatureChange((haId, _key, _value) => {
+		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();
 		});
 	}
@@ -1365,8 +2633,10 @@ var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
 			});
 			return;
 		}
+		const features = client.getFeatures(this.#haId);
+		this.#intensiveZoneWriteKey = intensiveZoneFeatureKeyFromFeatures(features);
 		const slice = dishwasherStatusFromFeatures({
-			features: client.getFeatures(this.#haId),
+			features,
 			availablePrograms: this.#availablePrograms,
 			nowMs: Date.now()
 		});
@@ -1401,6 +2671,18 @@ var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
 			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);
 			}
@@ -1408,18 +2690,256 @@ var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
 	}
 };
 //#endregion
+//#region src/home-connect/devices/home-connect-sensor-device.ts
+var homeConnectSensorSchema = require_dist.object({
+	haId: require_dist.string().min(1),
+	brokerId: require_dist.string().min(1),
+	sensorKind: require_dist.string().min(1),
+	system: require_dist.literal("home-connect").optional(),
+	integrationId: require_dist.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 require_dist.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(require_dist.numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState("numeric-sensor") ?? NUMERIC_COLD });
+			return;
+		}
+		if (this.#capName === "power-meter") {
+			this.ctx.registerNativeCap(require_dist.powerMeterCapability, { getStatus: async () => this.runtimeState.getCapState("power-meter") ?? POWER_COLD });
+			return;
+		}
+		if (this.#capName === "enum-sensor") {
+			this.ctx.registerNativeCap(require_dist.enumSensorCapability, { getStatus: async () => this.runtimeState.getCapState("enum-sensor") ?? ENUM_COLD });
+			return;
+		}
+		this.ctx.registerNativeCap(require_dist.binaryCapability, { getStatus: async () => this.runtimeState.getCapState("binary") ?? BINARY_COLD });
+	}
+};
+//#endregion
+//#region src/home-connect/devices/home-connect-appliance-device.ts
+var homeConnectApplianceChildSchema = require_dist.object({
+	role: require_dist.string().min(1),
+	stableIdSuffix: require_dist.string().min(1),
+	name: require_dist.string()
+});
+var homeConnectApplianceSchema = require_dist.object({
+	haId: require_dist.string().min(1),
+	brokerId: require_dist.string().min(1),
+	applianceType: require_dist.string().optional(),
+	availablePrograms: require_dist.array(require_dist.string()).default([]),
+	children: require_dist.array(homeConnectApplianceChildSchema).min(1),
+	system: require_dist.literal("home-connect").optional(),
+	integrationId: require_dist.string().optional()
+});
+/** One Home Connect appliance as a container with dishwasher + metric sensor children. */
+var HomeConnectApplianceDevice = class extends require_dist.BaseDevice {
+	features = [];
+	integrationId;
+	brokerId;
+	haId;
+	applianceType;
+	availablePrograms;
+	constructor(ctx) {
+		const cfg = homeConnectApplianceSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeConnectApplianceSchema, { type: require_dist.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: require_dist.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: require_dist.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 require_dist.BaseDeviceProvider {
 	addonId = "bosch-home-connect";
 	providerName = "Bosch Home Connect";
-	deviceClasses = { [require_dist.DeviceType.Dishwasher]: HomeConnectDishwasherDevice };
+	deviceClasses = {
+		[require_dist.DeviceType.Container]: HomeConnectApplianceDevice,
+		[require_dist.DeviceType.Dishwasher]: HomeConnectDishwasherDevice,
+		[require_dist.DeviceType.Sensor]: HomeConnectSensorDevice
+	};
 	clients = null;
 	constructor() {
 		super({});
 	}
 	async onInitialize() {
 		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
-		this.clients = new HomeConnectClientRegistry(this.ctx.logger);
+		this.clients = new HomeConnectClientRegistry(this.ctx.logger, { onConnectionUpdated: (integrationId, connection) => {
+			this.persistIntegrationAppliances(integrationId, connection);
+		} });
 		this.clients.setOnConnected((integrationId) => {
 			this.setIntegrationDevicesOnline(integrationId, true);
 		});
@@ -1464,7 +2984,8 @@ var BoschHomeConnectProviderAddon = class extends require_dist.BaseDeviceProvide
 						host: app.connection.host,
 						psk: app.connection.psk,
 						mode: app.connection.mode,
-						...app.connection.iv64.length > 0 ? { iv64: app.connection.iv64 } : {}
+						...app.connection.iv64.length > 0 ? { iv64: app.connection.iv64 } : {},
+						...parseLoginDeviceDescription(app.connection.deviceDescription)
 					}));
 					return {
 						token: account.token,
@@ -1489,13 +3010,32 @@ var BoschHomeConnectProviderAddon = class extends require_dist.BaseDeviceProvide
 		if (!this.clients) throw new Error("Home Connect provider not initialised");
 		return this.clients;
 	}
-	generateStableId(_type, config) {
+	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 === require_dist.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: require_dist.errMsg(err)
+			} });
+		}
+	}
 	async reconcileIntegrations() {
 		const reg = this.requireClients();
 		try {
@@ -1573,20 +3113,24 @@ var BoschHomeConnectProviderAddon = class extends require_dist.BaseDeviceProvide
 			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 !== require_dist.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,
-					name
+					integrationId
 				};
 				const stableId = this.generateStableId(type, config);
-				const DeviceClass = this.deviceClasses[type];
-				if (!DeviceClass) throw new Error(`home-connect adopt: unsupported type ${type}`);
-				return { deviceId: (await devices.create(stableId, DeviceClass, config, null, {
-					type,
+				return { deviceId: (await devices.create(stableId, HomeConnectApplianceDevice, config, null, {
+					type: require_dist.DeviceType.Container,
 					name,
 					integrationId
 				})).id };