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

package/dist/home-connect/addon.js

@@ -0,0 +1,1624 @@
+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");
+let node_crypto = require("node:crypto");
+//#region src/home-connect/custom-actions.ts
+var homeConnectActions = require_dist.defineCustomActions({
+	beginSignIn: require_dist.customAction(require_dist.object({}), require_dist.object({
+		authorizeUrl: require_dist.string().min(1),
+		verifier: require_dist.string().min(1),
+		state: require_dist.string().min(1),
+		summary: require_dist.string()
+	}), {
+		kind: "mutation",
+		auth: "admin"
+	}),
+	finishSignIn: require_dist.customAction(require_dist.object({
+		verifier: require_dist.string().min(1),
+		callback: require_dist.string().min(1),
+		state: require_dist.string().min(1)
+	}), require_dist.object({
+		token: require_dist.string().min(1),
+		refresh: require_dist.string().optional(),
+		appliances: require_dist.string().min(1),
+		summary: require_dist.string()
+	}), {
+		kind: "mutation",
+		auth: "admin"
+	})
+});
+//#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 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 defaultFetch(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()
+	};
+}
+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) 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) {
+	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
+	}).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((0, node_crypto.randomBytes)(32));
+	const challenge = b64url((0, node_crypto.createHash)("sha256").update(verifier).digest());
+	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("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((0, node_crypto.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 = defaultFetch) {
+	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,
+		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);
+}
+//#endregion
+//#region src/home-connect/home-connect-discovery.ts
+function deviceTypeForApplianceType(type) {
+	if (type.toLowerCase().includes("dishwasher")) return require_dist.DeviceType.Dishwasher;
+	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,
+			status: "online",
+			metadata: {
+				serialNumber: app.haId,
+				model: app.type
+			},
+			alreadyAdopted: adoptedId !== null,
+			adoptedDeviceId: adoptedId,
+			capabilities: camType === require_dist.DeviceType.Dishwasher ? ["dishwasher"] : []
+		});
+	}
+	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: require_dist.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: require_dist.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 = require_dist._enum(["AES", "TLS"]);
+function isPlainObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var homeConnectDeviceDescriptionSchema = require_dist.union([require_dist.string(), require_dist.record(require_dist.string(), require_dist.unknown())]).optional();
+require_dist.object({
+	host: require_dist.string().min(1),
+	psk: require_dist.string().min(1).meta({ secret: true }),
+	mode: HomeConnectModeSchema.default("AES"),
+	iv64: require_dist.string().optional(),
+	deviceDescription: homeConnectDeviceDescriptionSchema
+});
+/** One appliance saved at sign-in, so adopt does not need another cloud call. */
+var homeConnectStoredApplianceSchema = require_dist.object({
+	haId: require_dist.string().min(1),
+	name: require_dist.string(),
+	type: require_dist.string(),
+	host: require_dist.string().min(1),
+	psk: require_dist.string().min(1),
+	mode: HomeConnectModeSchema,
+	iv64: require_dist.string().optional()
+});
+/** The integration is the Home Connect account. Profiles are downloaded once at sign-in. */
+var homeConnectConfigSchema = require_dist.object({
+	token: require_dist.string().min(1).describe("Home Connect access token").meta({ secret: true }),
+	refresh: require_dist.string().optional().describe("Home Connect refresh token").meta({ secret: true }),
+	appliances: require_dist.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 (require_dist.isSecretMarker(token) || require_dist.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: require_dist.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-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 createHomeConnectWsClient(config, deps = {}) {
+	const wsFactory = deps.wsFactory ?? defaultWsFactory;
+	const url = homeConnectWsUrl(config);
+	const appliances = [...parseDeviceDescription(config.deviceDescription).appliances];
+	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 haId = 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
+								});
+							}
+						}
+					} 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 ws = value;
+	return typeof ws["readyState"] === "number" && typeof ws["send"] === "function" && typeof ws["close"] === "function" && typeof ws["addEventListener"] === "function" && typeof ws["removeEventListener"] === "function";
+}
+function defaultWsFactory(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-integration-manager.ts
+function storedAppliance(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: JSON.stringify({ info: {
+				deviceID: row.haId,
+				deviceType: row.type,
+				model: row.name
+			} })
+		}
+	};
+}
+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 ?? ""
+	});
+}
+var HomeConnectIntegrationManager = class {
+	#id;
+	#name;
+	#connection;
+	#logger;
+	#onConnected;
+	#onDisconnected;
+	#surfaceSink;
+	#makeClient;
+	#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;
+	}
+	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 client = this.#makeClient ? this.#makeClient(this.#connection) : await openStoredOrAccount(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 = require_dist.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: require_dist.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;
+	#entries = /* @__PURE__ */ new Map();
+	constructor(logger, deps = {}) {
+		this.#logger = logger;
+		this.#onConnected = deps.onConnected ?? (() => void 0);
+		this.#onDisconnected = deps.onDisconnected ?? (() => void 0);
+		const makeClient = deps.makeClient;
+		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
+		}));
+	}
+	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
+				});
+			} catch (err) {
+				this.#logger.warn("HomeConnectClientRegistry: applyConnection failed", { meta: {
+					integrationId,
+					error: require_dist.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();
+		} catch (err) {
+			this.#logger.warn("HomeConnectClientRegistry: manager start failed", { meta: {
+				integrationId,
+				error: require_dist.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: require_dist.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: require_dist.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 = require_dist.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."
+				};
+			}
+		}
+	};
+}
+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({
+	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([]),
+	system: require_dist.literal("home-connect").optional(),
+	integrationId: require_dist.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,
+	errorCode: null,
+	errorLabel: null,
+	lastFetchedAt: 0
+};
+var HomeConnectDishwasherDevice = class extends require_dist.BaseDevice {
+	features = [];
+	#haId;
+	#brokerId;
+	#availablePrograms;
+	#featureUnsub = null;
+	constructor(ctx) {
+		const persisted = homeConnectDishwasherSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeConnectDishwasherSchema, { type: ctx.deviceMeta.type });
+		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;
+			this.recomputeSlice();
+		});
+	}
+	recomputeSlice() {
+		const client = homeConnectConnections.getClient(this.#brokerId);
+		if (!client) {
+			this.runtimeState.setCapState(DISH_CAP, {
+				...COLD_START,
+				lastFetchedAt: Date.now()
+			});
+			return;
+		}
+		const slice = dishwasherStatusFromFeatures({
+			features: client.getFeatures(this.#haId),
+			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(require_dist.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);
+			},
+			setOption: async ({ key, value }) => {
+				await this.requireClient().setFeature(this.#haId, key, value);
+			}
+		});
+	}
+};
+//#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 };
+	clients = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
+		this.clients = new HomeConnectClientRegistry(this.ctx.logger);
+		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: require_dist.deviceAdoptionCapability,
+					provider: this.buildAdoptionProvider()
+				},
+				{
+					capability: require_dist.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 } : {}
+					}));
+					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: require_dist.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");
+		return `home-connect:${integrationId}:${haId}`;
+	}
+	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: require_dist.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 require_account_integration_offline.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: require_dist.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: require_dist.EventCategory.IntegrationEnabled }, handler);
+		this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.IntegrationDisabled }, handler);
+		this.ctx.eventBus.subscribe({ category: require_dist.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");
+				const config = {
+					haId,
+					brokerId: integrationId,
+					applianceType,
+					availablePrograms: [...availablePrograms],
+					system: "home-connect",
+					integrationId,
+					name
+				};
+				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,
+					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;
+		require_account_integration_offline.setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), "home-connect", integrationId, online);
+	}
+};
+//#endregion
+exports.BoschHomeConnectProviderAddon = BoschHomeConnectProviderAddon;