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

package/dist/homecom/addon.js

@@ -0,0 +1,1117 @@
+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");
+//#region src/homecom/homecom-discovery.ts
+function buildHomeComCandidates(input) {
+	const out = [];
+	for (const dev of input.devices) {
+		const type = dev.kind === "heating-circuit" ? require_dist.DeviceType.Climate : require_dist.DeviceType.WaterHeater;
+		const caps = dev.kind === "heating-circuit" ? ["climate-control"] : ["water-heater"];
+		const adoptedId = input.adopted.get(dev.nativeId) ?? null;
+		out.push({
+			childNativeId: dev.nativeId,
+			name: dev.name,
+			type,
+			status: "online",
+			metadata: { serialNumber: dev.nativeId },
+			alreadyAdopted: adoptedId !== null,
+			adoptedDeviceId: adoptedId,
+			capabilities: caps
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/homecom/homecom-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"] === "homecom" && device.config["brokerId"] === integrationId) {
+		const nativeId = device.config["nativeId"];
+		if (typeof nativeId === "string") map.set(nativeId, device.id);
+	}
+	return map;
+}
+function buildHomeComAdoptionProvider(deps) {
+	const { registry, hasIntegration, listIntegrations, listAdopted, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
+	async function allCandidatesForIntegration(integrationId) {
+		return buildHomeComCandidates({
+			devices: registry.discoverables(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"] === "homecom").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(`homecom adopt: integration ${integrationId} not connected`);
+			const devices = registry.discoverables(integrationId);
+			const adopted = [];
+			let failures = 0;
+			for (const nativeId of childNativeIds) try {
+				const dev = devices.find((d) => d.nativeId === nativeId);
+				if (!dev) {
+					failures++;
+					continue;
+				}
+				const candidate = buildHomeComCandidates({
+					devices: [dev],
+					adopted: /* @__PURE__ */ new Map()
+				})[0];
+				if (!candidate) {
+					failures++;
+					continue;
+				}
+				const name = perCandidate?.[nativeId]?.name ?? dev.name;
+				const { deviceId } = await adoptDevice({
+					nativeId,
+					integrationId,
+					type: candidate.type,
+					name,
+					kind: dev.kind,
+					circuitId: dev.circuitId
+				});
+				adopted.push({
+					childNativeId: nativeId,
+					parentDeviceId: deviceId
+				});
+			} catch (err) {
+				logger.warn("homecom adopt failed", { meta: {
+					nativeId,
+					integrationId,
+					error: require_dist.errMsg(err)
+				} });
+				failures++;
+			}
+			if (adopted.length === 0 && failures > 0) throw new Error(`homecom adopt: all ${failures} adopt(s) failed`);
+			return { adopted: adopted.map((a) => ({
+				...a,
+				accessoryDeviceIds: []
+			})) };
+		},
+		release: async ({ camDeviceId }) => {
+			await removeDevice(camDeviceId);
+		},
+		resync: async ({ camDeviceId }) => {
+			const cfg = await findDeviceConfig(camDeviceId);
+			if (!cfg || cfg["system"] !== "homecom") throw new Error(`homecom resync: device ${camDeviceId} not found`);
+			const integrationId = String(cfg["brokerId"]);
+			const nativeId = String(cfg["nativeId"]);
+			if (!hasIntegration(integrationId)) throw new Error(`homecom resync: integration ${integrationId} not connected`);
+			if (!registry.discoverables(integrationId).some((d) => d.nativeId === nativeId)) throw new Error(`homecom resync: device ${nativeId} no longer present`);
+			return {
+				changed: false,
+				rebuiltChildren: 0
+			};
+		}
+	};
+}
+//#endregion
+//#region src/homecom/config.ts
+var HOMECOM_BRANDS = ["bosch", "buderus"];
+var HomeComBrandSchema = require_dist._enum(HOMECOM_BRANDS);
+var HOMECOM_REGIONS = ["eu", "us"];
+var HomeComRegionSchema = require_dist._enum(HOMECOM_REGIONS);
+var homeComConfigSchema = require_dist.object({
+	username: require_dist.string().min(1).describe("HomeCom / PointT account email").meta({ secret: true }),
+	token: require_dist.string().min(1).describe("OAuth access token").meta({ secret: true }),
+	refresh: require_dist.string().min(1).describe("OAuth refresh token").meta({ secret: true }),
+	brand: HomeComBrandSchema.default("bosch"),
+	region: HomeComRegionSchema.default("eu")
+});
+function connectionFromSettings(settings) {
+	const parsed = homeComConfigSchema.safeParse(settings);
+	return parsed.success ? parsed.data : null;
+}
+function sameHomeComConnection(a, b) {
+	if (a === null || b === null) return false;
+	return a.username === b.username && a.token === b.token && a.refresh === b.refresh && a.brand === b.brand && a.region === b.region;
+}
+/**
+* PointT REST origin (matches homecom_alt / HomeCom Easy). US and EU accounts use
+* the same host; `region` is retained for Bacon MQTT (`euc1` / `use1`) when wired.
+*/
+var HOMECOM_POINTT_API_ORIGIN = "https://pointt-api.bosch-thermotechnology.com";
+function homeComApiBase(_region) {
+	return HOMECOM_POINTT_API_ORIGIN;
+}
+function buildHomeComFormSchema() {
+	return { sections: [{
+		id: "account",
+		title: "HomeCom account",
+		columns: 1,
+		fields: [
+			{
+				type: "text",
+				key: "username",
+				label: "Username",
+				required: true
+			},
+			{
+				type: "password",
+				key: "token",
+				label: "Access token",
+				required: true,
+				showToggle: true
+			},
+			{
+				type: "password",
+				key: "refresh",
+				label: "Refresh token",
+				required: true,
+				showToggle: true
+			},
+			{
+				type: "select",
+				key: "brand",
+				label: "Brand",
+				default: "bosch",
+				options: HOMECOM_BRANDS.map((b) => ({
+					value: b,
+					label: b
+				}))
+			},
+			{
+				type: "select",
+				key: "region",
+				label: "Region",
+				default: "eu",
+				options: HOMECOM_REGIONS.map((r) => ({
+					value: r,
+					label: r.toUpperCase()
+				}))
+			}
+		]
+	}] };
+}
+//#endregion
+//#region src/homecom/homecom-gateway.ts
+var HomeComConnectionResolver = class {
+	#surfaces = /* @__PURE__ */ new Map();
+	set(integrationId, surface) {
+		if (surface === null) {
+			this.#surfaces.delete(integrationId);
+			return;
+		}
+		this.#surfaces.set(integrationId, surface);
+	}
+	has(integrationId) {
+		return this.#surfaces.has(integrationId);
+	}
+	list() {
+		return Array.from(this.#surfaces.keys()).map((id) => ({ id }));
+	}
+	discoverables(integrationId) {
+		return this.#surfaces.get(integrationId)?.discoverables ?? [];
+	}
+	getClient(integrationId) {
+		return this.#surfaces.get(integrationId)?.client ?? null;
+	}
+	getSnapshot(integrationId) {
+		return this.#surfaces.get(integrationId)?.snapshot ?? null;
+	}
+	updateSnapshot(integrationId, snapshot) {
+		const existing = this.#surfaces.get(integrationId);
+		if (!existing) return;
+		this.#surfaces.set(integrationId, {
+			...existing,
+			snapshot,
+			discoverables: buildDiscoverables(snapshot)
+		});
+	}
+	clear() {
+		this.#surfaces.clear();
+	}
+};
+function buildDiscoverables(snapshot) {
+	const out = [];
+	for (const circuit of snapshot.circuits) out.push({
+		nativeId: `hc:${circuit.id}`,
+		name: circuit.name,
+		kind: "heating-circuit",
+		circuitId: circuit.id
+	});
+	if (snapshot.dhw) out.push({
+		nativeId: "dhw:0",
+		name: "Domestic hot water",
+		kind: "dhw"
+	});
+	return out;
+}
+var homeComConnections = new HomeComConnectionResolver();
+//#endregion
+//#region src/homecom/homecom-domain-mapping.ts
+var MODE_MAP = {
+	Off: "off",
+	off: "off",
+	Heat: "heat",
+	heat: "heat",
+	Cool: "cool",
+	cool: "cool",
+	Auto: "auto",
+	auto: "auto"
+};
+function mapHvacMode(raw) {
+	return MODE_MAP[raw] ?? "off";
+}
+function climateSliceFromCircuit(circuit, nowMs) {
+	return {
+		mode: mapHvacMode(circuit.operationMode),
+		availableModes: [
+			"off",
+			"heat",
+			"auto"
+		],
+		fanMode: "",
+		availableFanModes: [],
+		preset: "",
+		availablePresets: [],
+		target: circuit.setpoint,
+		targetHigh: null,
+		targetLow: null,
+		targetHumidity: null,
+		currentTemp: circuit.currentRoomTemp,
+		currentHumidity: null,
+		swingVertical: null,
+		swingHorizontal: null,
+		minTemp: circuit.minTemp,
+		maxTemp: circuit.maxTemp,
+		tempStep: .5,
+		lastFetchedAt: nowMs
+	};
+}
+function waterHeaterSliceFromDhw(dhw, nowMs) {
+	return {
+		currentTemp: dhw.currentTemp,
+		targetTemp: dhw.targetTemp,
+		operationMode: dhw.operationMode,
+		availableModes: [...dhw.availableModes],
+		away: null,
+		minTemp: dhw.minTemp,
+		maxTemp: dhw.maxTemp,
+		lastChangedAt: nowMs
+	};
+}
+/** Parse K40-style gateway JSON into heating circuits + DHW. Pure. */
+function parseHomeComSystemPayload(payload) {
+	if (typeof payload !== "object" || payload === null) return {
+		circuits: [],
+		dhw: null
+	};
+	const root = payload;
+	const circuits = [];
+	const rawCircuits = root["heatingCircuits"];
+	if (Array.isArray(rawCircuits)) for (const item of rawCircuits) {
+		if (typeof item !== "object" || item === null) continue;
+		const row = item;
+		const id = row["id"];
+		if (typeof id !== "string") continue;
+		circuits.push({
+			id,
+			name: typeof row["name"] === "string" ? row["name"] : id,
+			operationMode: typeof row["operationMode"] === "string" ? row["operationMode"] : "off",
+			setpoint: readNum(row["setpoint"]),
+			currentRoomTemp: readNum(row["currentRoomTemperature"]),
+			minTemp: readNum(row["minTemp"]),
+			maxTemp: readNum(row["maxTemp"])
+		});
+	}
+	let dhw = null;
+	const rawDhw = root["domesticHotWater"];
+	if (typeof rawDhw === "object" && rawDhw !== null) {
+		const row = rawDhw;
+		const modes = [];
+		if (Array.isArray(row["operationModes"])) {
+			for (const m of row["operationModes"]) if (typeof m === "string") modes.push(m);
+		}
+		dhw = {
+			currentTemp: readNum(row["currentTemperature"]),
+			targetTemp: readNum(row["setpoint"]),
+			operationMode: typeof row["operationMode"] === "string" ? row["operationMode"] : null,
+			availableModes: modes.length > 0 ? modes : [
+				"off",
+				"eco",
+				"performance"
+			],
+			minTemp: readNum(row["minTemp"]),
+			maxTemp: readNum(row["maxTemp"])
+		};
+	}
+	return {
+		circuits,
+		dhw
+	};
+}
+function readNum(raw) {
+	if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+	return null;
+}
+//#endregion
+//#region src/homecom/homecom-api-client.ts
+var HomeComAuthError = class extends Error {
+	name = "HomeComAuthError";
+};
+function createHomeComApiClient(config, gatewayId, deps = {}) {
+	const fetchFn = deps.fetchFn ?? globalThis.fetch.bind(globalThis);
+	let token = config.token;
+	let refresh = config.refresh;
+	const base = homeComApiBase(config.region);
+	async function authHeaders() {
+		return {
+			Authorization: `Bearer ${token}`,
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		};
+	}
+	async function request(path, init = {}) {
+		const res = await fetchFn(`${base}${path}`, {
+			method: init.method ?? "GET",
+			headers: await authHeaders(),
+			body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+		});
+		if (res.status === 401) throw new HomeComAuthError("token expired");
+		if (!res.ok) throw new Error(`HomeCom API ${path} failed: HTTP ${res.status}`);
+		return res.json();
+	}
+	return {
+		async refreshTokens() {
+			const res = await fetchFn(`${base}/token/oauth2`, {
+				method: "POST",
+				headers: { "Content-Type": "application/x-www-form-urlencoded" },
+				body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(refresh)}&client_id=homecom`
+			});
+			if (!res.ok) {
+				if (res.status === 401 || res.status === 403) throw new HomeComAuthError("refresh refused");
+				throw new Error(`HomeCom token refresh failed: HTTP ${res.status}`);
+			}
+			const body = await res.json();
+			if (typeof body !== "object" || body === null) throw new Error("HomeCom token refresh: bad body");
+			const row = body;
+			const newToken = row["access_token"];
+			const newRefresh = row["refresh_token"];
+			if (typeof newToken !== "string" || typeof newRefresh !== "string") throw new Error("HomeCom token refresh: missing tokens");
+			token = newToken;
+			refresh = newRefresh;
+			return {
+				token,
+				refresh
+			};
+		},
+		async fetchSystem() {
+			const parsed = parseHomeComSystemPayload(await request(`/v2/gateways/${gatewayId}/system`));
+			return {
+				gateway: {
+					gatewayId,
+					name: "HomeCom heat pump",
+					model: "K40"
+				},
+				circuits: parsed.circuits,
+				dhw: parsed.dhw
+			};
+		},
+		async setCircuitSetpoint(circuitId, temp) {
+			await request(`/v2/gateways/${gatewayId}/heatingCircuits/${circuitId}/setpoint`, {
+				method: "PUT",
+				body: { value: temp }
+			});
+		},
+		async setCircuitMode(circuitId, mode) {
+			await request(`/v2/gateways/${gatewayId}/heatingCircuits/${circuitId}/operationMode`, {
+				method: "PUT",
+				body: { value: mode }
+			});
+		},
+		async setDhwTarget(temp) {
+			await request(`/v2/gateways/${gatewayId}/domesticHotWater/setpoint`, {
+				method: "PUT",
+				body: { value: temp }
+			});
+		},
+		async setDhwMode(mode) {
+			await request(`/v2/gateways/${gatewayId}/domesticHotWater/operationMode`, {
+				method: "PUT",
+				body: { value: mode }
+			});
+		}
+	};
+}
+//#endregion
+//#region src/homecom/homecom-integration-manager.ts
+var HomeComIntegrationManager = class {
+	#id;
+	#name;
+	#connection;
+	#logger;
+	#onConnected;
+	#onDisconnected;
+	#surfaceSink;
+	#makeClient;
+	#pollIntervalMs;
+	#client = null;
+	#gatewayId = null;
+	#pollTimer = null;
+	#status = "disconnected";
+	#error = null;
+	#lastCheckedAt = 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;
+		const fetchFn = options.fetchFn;
+		this.#makeClient = options.makeClient ?? ((config, gatewayId) => createHomeComApiClient(config, gatewayId, { fetchFn }));
+		this.#pollIntervalMs = options.pollIntervalMs ?? 6e4;
+	}
+	getConnection() {
+		return this.#connection;
+	}
+	getInfo() {
+		return {
+			id: this.#id,
+			name: this.#name,
+			kind: "homecom",
+			status: this.#status,
+			info: {
+				username: this.#connection.username,
+				gatewayId: this.#gatewayId
+			},
+			lastCheckedAt: this.#lastCheckedAt,
+			error: this.#error
+		};
+	}
+	async start() {
+		if (this.#client !== null) return;
+		this.#status = "connecting";
+		this.#error = null;
+		const gatewayId = await this.resolveGatewayId(this.#connection);
+		this.#gatewayId = gatewayId;
+		const client = this.#makeClient(this.#connection, gatewayId);
+		this.#client = client;
+		try {
+			const snapshot = await this.fetchWithTokenRefresh(client);
+			const surface = {
+				gatewayId,
+				client,
+				snapshot,
+				discoverables: buildDiscoverables(snapshot)
+			};
+			this.#surfaceSink.set(this.#id, surface);
+			this.#status = "connected";
+			this.#lastCheckedAt = Date.now();
+			this.#onConnected(this.#id);
+			this.#pollTimer = setInterval(() => {
+				this.pollOnce();
+			}, this.#pollIntervalMs);
+		} catch (err) {
+			this.#status = "error";
+			this.#error = err instanceof HomeComAuthError ? "authentication failed — check tokens" : require_dist.errMsg(err);
+			this.#surfaceSink.set(this.#id, null);
+			this.#onDisconnected(this.#id);
+			throw err;
+		}
+	}
+	async stop() {
+		if (this.#pollTimer) {
+			clearInterval(this.#pollTimer);
+			this.#pollTimer = null;
+		}
+		this.#client = null;
+		this.#gatewayId = null;
+		this.#status = "disconnected";
+		this.#surfaceSink.set(this.#id, null);
+		this.#onDisconnected(this.#id);
+	}
+	async applyConnection(conn) {
+		await this.stop();
+		this.#connection = conn;
+		await this.start();
+	}
+	async pollOnce() {
+		const client = this.#client;
+		if (!client) return;
+		try {
+			const snapshot = await this.fetchWithTokenRefresh(client);
+			this.#surfaceSink.updateSnapshot(this.#id, snapshot);
+			this.#lastCheckedAt = Date.now();
+		} catch (err) {
+			this.#logger.warn("HomeCom poll failed", { meta: {
+				integrationId: this.#id,
+				error: require_dist.errMsg(err)
+			} });
+		}
+	}
+	async fetchWithTokenRefresh(client) {
+		try {
+			return await client.fetchSystem();
+		} catch (err) {
+			if (!(err instanceof HomeComAuthError)) throw err;
+			await client.refreshTokens();
+			return client.fetchSystem();
+		}
+	}
+	/** Discover K40 gateway id via account listing (simplified: username hash stub). */
+	async resolveGatewayId(config) {
+		return "gateway-k40";
+	}
+};
+//#endregion
+//#region src/homecom/homecom-client-registry.ts
+var HomeComClientRegistry = 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 fetchFn = deps.fetchFn;
+		const makeClient = deps.makeClient;
+		this.#makeManager = deps.makeManager ?? ((opts) => new HomeComIntegrationManager({
+			id: opts.integrationId,
+			name: opts.name,
+			connection: opts.connection,
+			logger: opts.logger,
+			onConnected: opts.onConnected,
+			onDisconnected: opts.onDisconnected,
+			surfaceSink: homeComConnections,
+			fetchFn,
+			makeClient,
+			pollIntervalMs: 6e4
+		}));
+	}
+	setOnConnected(cb) {
+		this.#onConnected = cb;
+	}
+	setOnDisconnected(cb) {
+		this.#onDisconnected = cb;
+	}
+	async upsert(integrationId, name, connection) {
+		const existing = this.#entries.get(integrationId);
+		if (existing) {
+			if (sameHomeComConnection(existing.connection, connection)) return;
+			try {
+				await existing.manager.applyConnection(connection);
+				this.#entries.set(integrationId, {
+					manager: existing.manager,
+					connection
+				});
+			} catch (err) {
+				this.#logger.warn("HomeComClientRegistry: 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("HomeComClientRegistry: 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("HomeComClientRegistry: remove stop failed", { meta: {
+				integrationId,
+				error: require_dist.errMsg(err)
+			} });
+		}
+	}
+	async retain(keep) {
+		for (const id of [...this.#entries.keys()].filter((k) => !keep.has(k))) await this.remove(id);
+	}
+	async shutdown() {
+		for (const id of [...this.#entries.keys()]) try {
+			await this.#entries.get(id)?.manager.stop();
+		} catch (err) {
+			this.#logger.warn("HomeComClientRegistry: shutdown stop failed", { meta: {
+				integrationId: id,
+				error: require_dist.errMsg(err)
+			} });
+		}
+		this.#entries.clear();
+		homeComConnections.clear();
+	}
+	has(integrationId) {
+		return this.#entries.has(integrationId);
+	}
+	list() {
+		return [...this.#entries.keys()];
+	}
+	getInfo(integrationId) {
+		return this.#entries.get(integrationId)?.manager.getInfo() ?? null;
+	}
+	size() {
+		return this.#entries.size;
+	}
+};
+//#endregion
+//#region src/homecom/homecom-connection-test.ts
+async function defaultResolveGatewayId(_config) {
+	return "gateway-k40";
+}
+var TEST_LABEL = "Refreshes HomeCom OAuth tokens and reads the heat-pump system snapshot";
+function buildHomeComConnectionTestProvider(deps) {
+	const { logger } = deps;
+	const makeClient = deps.makeClient ?? ((config, gatewayId) => createHomeComApiClient(config, gatewayId));
+	const resolveGatewayId = deps.resolveGatewayId ?? defaultResolveGatewayId;
+	return {
+		describeTest: async () => ({ label: TEST_LABEL }),
+		testSettings: async ({ settings }) => {
+			const parsed = homeComConfigSchema.safeParse(settings);
+			if (!parsed.success) return {
+				outcome: "rejected",
+				error: `HomeCom settings incomplete: ${parsed.error.issues.map((i) => i.path.join(".") || "(root)").join(", ")}`
+			};
+			const startedAt = Date.now();
+			const gatewayId = await resolveGatewayId(parsed.data);
+			const client = makeClient(parsed.data, gatewayId);
+			try {
+				await client.refreshTokens();
+				await client.fetchSystem();
+				return {
+					outcome: "validated",
+					latencyMs: Date.now() - startedAt
+				};
+			} catch (err) {
+				if (err instanceof HomeComAuthError) return {
+					outcome: "rejected",
+					error: "HomeCom refused these tokens — re-authenticate the PointT account."
+				};
+				logger.warn("HomeCom connection test inconclusive", { meta: {
+					username: parsed.data.username,
+					error: require_dist.errMsg(err)
+				} });
+				return {
+					outcome: "inconclusive",
+					error: "Could not reach the HomeCom cloud API."
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/homecom/devices/homecom-climate-device.ts
+var homeComClimateSchema = require_dist.object({
+	nativeId: require_dist.string().min(1),
+	brokerId: require_dist.string().min(1),
+	circuitId: require_dist.string().min(1),
+	system: require_dist.literal("homecom").optional(),
+	integrationId: require_dist.string().optional()
+});
+var CLIMATE_CAP = "climate-control";
+var COLD_START$1 = {
+	mode: "off",
+	availableModes: [],
+	fanMode: "",
+	availableFanModes: [],
+	preset: "",
+	availablePresets: [],
+	target: null,
+	targetHigh: null,
+	targetLow: null,
+	targetHumidity: null,
+	currentTemp: null,
+	currentHumidity: null,
+	swingVertical: null,
+	swingHorizontal: null,
+	lastFetchedAt: 0
+};
+var HomeComClimateDevice = class extends require_dist.BaseDevice {
+	features = [];
+	#brokerId;
+	#circuitId;
+	constructor(ctx) {
+		const persisted = homeComClimateSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeComClimateSchema, { type: ctx.deviceMeta.type });
+		this.#brokerId = persisted.brokerId;
+		this.#circuitId = persisted.circuitId;
+		this.online = true;
+		this.updateSourceInfo({
+			id: persisted.nativeId,
+			system: "homecom"
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerClimateCap();
+		this.runtimeState.setCapState(CLIMATE_CAP, COLD_START$1);
+		this.refreshFromSnapshot();
+	}
+	refreshFromSnapshot() {
+		const circuit = homeComConnections.getSnapshot(this.#brokerId)?.circuits.find((c) => c.id === this.#circuitId);
+		if (!circuit) {
+			this.runtimeState.setCapState(CLIMATE_CAP, {
+				...COLD_START$1,
+				lastFetchedAt: Date.now()
+			});
+			return;
+		}
+		this.runtimeState.setCapState(CLIMATE_CAP, climateSliceFromCircuit(circuit, Date.now()));
+	}
+	requireClient() {
+		const client = homeComConnections.getClient(this.#brokerId);
+		if (!client) throw new Error(`HomeCom client unavailable (circuit=${this.#circuitId})`);
+		return client;
+	}
+	registerClimateCap() {
+		this.ctx.registerNativeCap(require_dist.climateControlCapability, {
+			getStatus: async () => {
+				this.refreshFromSnapshot();
+				return this.runtimeState.getCapState(CLIMATE_CAP) ?? COLD_START$1;
+			},
+			setMode: async ({ mode }) => {
+				const apiMode = hvacModeToHomeCom(mode);
+				await this.requireClient().setCircuitMode(this.#circuitId, apiMode);
+				this.refreshFromSnapshot();
+			},
+			setFanMode: async () => {
+				throw new Error("HomeCom climate: fan mode not supported");
+			},
+			setPreset: async () => {
+				throw new Error("HomeCom climate: presets not supported");
+			},
+			setTarget: async ({ target }) => {
+				await this.requireClient().setCircuitSetpoint(this.#circuitId, target);
+				this.refreshFromSnapshot();
+			},
+			setTargetRange: async () => {
+				throw new Error("HomeCom climate: dual setpoint not supported");
+			},
+			setTargetHumidity: async () => {
+				throw new Error("HomeCom climate: humidity not supported");
+			},
+			setSwingVertical: async () => {
+				throw new Error("HomeCom climate: swing not supported");
+			},
+			setSwingHorizontal: async () => {
+				throw new Error("HomeCom climate: swing not supported");
+			}
+		});
+	}
+};
+function hvacModeToHomeCom(mode) {
+	switch (mode) {
+		case "heat": return "Heat";
+		case "cool": return "Cool";
+		case "auto": return "Auto";
+		default: return "Off";
+	}
+}
+//#endregion
+//#region src/homecom/devices/homecom-water-heater-device.ts
+var homeComWaterHeaterSchema = require_dist.object({
+	nativeId: require_dist.string().min(1),
+	brokerId: require_dist.string().min(1),
+	system: require_dist.literal("homecom").optional(),
+	integrationId: require_dist.string().optional()
+});
+var WH_CAP = "water-heater";
+var COLD_START = {
+	currentTemp: null,
+	targetTemp: null,
+	operationMode: null,
+	availableModes: [],
+	away: null,
+	minTemp: null,
+	maxTemp: null,
+	lastChangedAt: 0
+};
+var HomeComWaterHeaterDevice = class extends require_dist.BaseDevice {
+	features = [];
+	#brokerId;
+	constructor(ctx) {
+		const persisted = homeComWaterHeaterSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, homeComWaterHeaterSchema, { type: ctx.deviceMeta.type });
+		this.#brokerId = persisted.brokerId;
+		this.online = true;
+		this.updateSourceInfo({
+			id: persisted.nativeId,
+			system: "homecom"
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerWaterHeaterCap();
+		this.runtimeState.setCapState(WH_CAP, COLD_START);
+		this.refreshFromSnapshot();
+	}
+	refreshFromSnapshot() {
+		const dhw = homeComConnections.getSnapshot(this.#brokerId)?.dhw;
+		if (!dhw) {
+			this.runtimeState.setCapState(WH_CAP, {
+				...COLD_START,
+				lastChangedAt: Date.now()
+			});
+			return;
+		}
+		this.runtimeState.setCapState(WH_CAP, waterHeaterSliceFromDhw(dhw, Date.now()));
+	}
+	requireClient() {
+		const client = homeComConnections.getClient(this.#brokerId);
+		if (!client) throw new Error("HomeCom client unavailable (DHW)");
+		return client;
+	}
+	registerWaterHeaterCap() {
+		this.ctx.registerNativeCap(require_dist.waterHeaterCapability, {
+			getStatus: async () => {
+				this.refreshFromSnapshot();
+				return this.runtimeState.getCapState(WH_CAP) ?? COLD_START;
+			},
+			setTargetTemp: async ({ temp }) => {
+				await this.requireClient().setDhwTarget(temp);
+				this.refreshFromSnapshot();
+			},
+			setOperationMode: async ({ mode }) => {
+				await this.requireClient().setDhwMode(mode);
+				this.refreshFromSnapshot();
+			},
+			setAway: async () => {
+				throw new Error("HomeCom DHW: away mode not supported");
+			}
+		});
+	}
+};
+//#endregion
+//#region src/homecom/addon.ts
+var BoschHomeComProviderAddon = class extends require_dist.BaseDeviceProvider {
+	addonId = "bosch-homecom";
+	providerName = "Bosch HomeCom";
+	deviceClasses = {
+		[require_dist.DeviceType.Climate]: HomeComClimateDevice,
+		[require_dist.DeviceType.WaterHeater]: HomeComWaterHeaterDevice
+	};
+	clients = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
+		this.clients = new HomeComClientRegistry(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 [
+			...regs,
+			{
+				capability: require_dist.deviceAdoptionCapability,
+				provider: this.buildAdoptionProvider()
+			},
+			{
+				capability: require_dist.connectionTestCapability,
+				provider: this.buildConnectionTestProvider()
+			}
+		];
+	}
+	async onShutdown() {
+		try {
+			await this.clients?.shutdown();
+		} catch (err) {
+			this.ctx.logger.warn("HomeCom shutdown error", { meta: { error: require_dist.errMsg(err) } });
+		}
+		this.clients = null;
+		await super.onShutdown();
+	}
+	requireClients() {
+		if (!this.clients) throw new Error("HomeCom provider not initialised");
+		return this.clients;
+	}
+	generateStableId(_type, config) {
+		const integrationId = config?.["brokerId"];
+		if (typeof integrationId !== "string" || integrationId.length === 0) throw new Error("homecom generateStableId: brokerId required");
+		const nativeId = config?.["nativeId"];
+		if (typeof nativeId !== "string" || nativeId.length === 0) throw new Error("homecom generateStableId: nativeId required");
+		return `homecom:${integrationId}:${nativeId}`;
+	}
+	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 connection = connectionFromSettings(await this.ctx.api.integrations.getSettings.query({ id: integration.id }));
+				if (!connection) continue;
+				await reg.upsert(integration.id, integration.name, connection);
+				surviving.add(integration.id);
+			} catch (err) {
+				this.ctx.logger.warn("HomeCom 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: "homecom",
+				integrationId,
+				logger: this.ctx.logger
+			});
+		} catch (err) {
+			this.ctx.logger.warn("HomeCom 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 buildHomeComConnectionTestProvider({ logger: this.ctx.logger });
+	}
+	buildAdoptionProvider() {
+		return buildHomeComAdoptionProvider({
+			registry: homeComConnections,
+			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 ({ nativeId, integrationId, type, name, kind, circuitId }) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) throw new Error("homecom adopt: devices unavailable");
+				const config = {
+					nativeId,
+					brokerId: integrationId,
+					system: "homecom",
+					integrationId,
+					name
+				};
+				if (kind === "heating-circuit" && circuitId) config["circuitId"] = circuitId;
+				const stableId = this.generateStableId(type, config);
+				const DeviceClass = this.deviceClasses[type];
+				if (!DeviceClass) throw new Error(`homecom adopt: unsupported type ${type}`);
+				return { deviceId: (await devices.create(stableId, DeviceClass, config, null, {
+					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 buildHomeComFormSchema();
+	}
+	async supportsManualCreation() {
+		return false;
+	}
+	async onGetCreationSchema(_type) {
+		return null;
+	}
+	async onCreateDevice(_type, _config) {
+		throw new Error("HomeCom devices are adopted from the cloud");
+	}
+	setIntegrationDevicesOnline(integrationId, online) {
+		const reg = this.ctx.kernel.deviceRegistry;
+		if (!reg) return;
+		require_account_integration_offline.setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), "homecom", integrationId, online);
+	}
+};
+//#endregion
+exports.BoschHomeComProviderAddon = BoschHomeComProviderAddon;