@camstack/addon-provider-bosch 0.1.44 → 0.1.46

package/dist/{bosch-instances-C8FRjQzC.mjs → bosch-instances-DkUo6BfT.mjs}

@@ -802,7 +802,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/device-type-CbDhVwFP.mjs
+//#region ../types/dist/device-type-DTTZKB2I.mjs
 /**
 import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
@@ -928,6 +928,10 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	*  (`reboot`, `device-admin-link`). Products are NOT its children — they are
 	*  adopted beside it — and its connection settings stay on the integration. */
 	DeviceType["Gateway"] = "gateway";
+	/** A heat pump (any vendor): the compressor unit with its circuits (heating, hot
+	*  water, cooling, solar), its system modes and its power. One main read-only
+	*  `heat-pump-status` cap carries all of it; `heat-pump-control` sets it (D1026). */
+	DeviceType["HeatPump"] = "heat-pump";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -6012,7 +6016,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CS5Xp1iQ.mjs
+//#region ../types/dist/sleep-DnVqHJc4.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8759,16 +8763,6 @@ var BaseAddon = class {
 		return null;
 	}
 	/**
-	* The form schema of ONE integration instance, or `null` to use the scoped form.
-	*
-	* Override it only when an `instanceMode: multiple` addon's instances differ: an NVR integration
-	* needs its connection fields, the default integration the addon's own sections. It is the
-	* SHAPE of the form only — the values live on the instance record.
-	*/
-	async integrationFormSchema(_instance) {
-		return null;
-	}
-	/**
 	* D986 scoped settings: the form shape of the CLUSTER-wide settings one capability this addon
 	* provides owns, or `null` when it has none. `cap` is a capability name the addon's manifest
 	* declares. Stored as `addon-settings` rows `<addonId>.<field>`. The keys of this schema, of
@@ -8796,8 +8790,7 @@ var BaseAddon = class {
 	}
 	/**
 	* The host's read of the scoped declarations: the schema one capability declares for `scope`,
-	* or `null`. Beside {@link getIntegrationFormSchema}, the same shape: the hook is protected, the
-	* host asks this method.
+	* or `null`. The hook is protected, the host asks this method.
 	*/
 	async getScopedSettingsSchema(scope, cap) {
 		switch (scope) {
@@ -8965,22 +8958,6 @@ var BaseAddon = class {
 		return Object.fromEntries([...collectHydratedFieldValues(form)].filter(([, value]) => value !== void 0));
 	}
 	/**
-	* What the create wizard and the integration edit page render for one instance: the addon's
-	* per-instance schema when it declares one, else its global schema (what they always showed).
-	*/
-	async getIntegrationFormSchema(instance, nodeId) {
-		const scoped = await this.integrationFormSchema(instance);
-		if (scoped === null) return this.scopedForm(nodeId);
-		return hydrateSchema(scoped, {}, { inlineSecretsAsViews: true });
-	}
-	/** The form of the scoped schemas this addon declared, hydrated from its store. */
-	async scopedForm(nodeId) {
-		await this.loadScopedSchemas();
-		const schema = this.scopedFormSchema();
-		if (!schema) return { sections: [] };
-		return hydrateSchema(schema, await this.readRawProjectedStore(nodeId), { inlineSecretsAsViews: true });
-	}
-	/**
 	* The raw addon store PROJECTED onto the target node's bare per-node keys:
 	* every `perNode: true` field carries THAT node's scoped value on its bare
 	* key (absent scoped key ⇒ key absent, so the schema `default` wins — no
@@ -9167,12 +9144,6 @@ var BaseAddon = class {
 		this._nodeKeysByCap = /* @__PURE__ */ new Map();
 		this._addonSecretTree = null;
 	}
-	/** The form of an addon's scoped schemas: their sections, each shown once. */
-	scopedFormSchema(cap) {
-		const byId = /* @__PURE__ */ new Map();
-		for (const entry of this.loadedScopedSchemas(cap)) for (const section of entry.schema.sections) if (!byId.has(section.id)) byId.set(section.id, section);
-		return byId.size === 0 ? null : { sections: [...byId.values()] };
-	}
 	/** Every loaded scoped schema of `cap`, or of every loaded capability. */
 	loadedScopedSchemas(cap) {
 		if (cap !== void 0) return this._scopedByCap.get(cap) ?? [];
@@ -9762,6 +9733,10 @@ function normalizeAddonInitResult(result) {
 	if (Array.isArray(result)) return { providers: result };
 	return result;
 }
+object({
+	code: string().regex(/^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/),
+	params: record(string(), union([string(), number$1()])).optional()
+});
 object({
 	field: string().min(1),
 	on: literal("advance")
@@ -9838,12 +9813,6 @@ function systemMethod(input, output, options) {
 		systemOnly: true
 	};
 }
-/**
-* A method a SOURCE of a collection cap may legitimately not serve — OPTIONAL
-* on `InferProvider`. The `providerOptional: true` literal is what
-* `InferProvider` keys on; see {@link CapabilityMethodSchema.providerOptional}
-* for when this is the honest answer and when it is a soft stub.
-*/
 function optionalMethod(input, output, options) {
 	return {
 		...method(input, output, options),
@@ -10653,7 +10622,7 @@ function t(en, it) {
 * Things an operator switches, opens, sets or arms: lights, plugs, sirens,
 * covers, valves, locks, climate, fans, alarm panels.
 */
-var ON = t("On", "Acceso");
+var ON$1 = t("On", "Acceso");
 var PERCENT = t("Percentage", "Percentuale");
 var OPEN_CLOSE_STATES = [
 	{
@@ -10713,7 +10682,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 		state: [{
 			kind: "boolean",
 			field: "on",
-			label: ON,
+			label: ON$1,
 			whenTrue: t("When {device} turns on", "Quando {device} si accende"),
 			whenFalse: t("When {device} turns off", "Quando {device} si spegne"),
 			icon: "power"
@@ -11879,7 +11848,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 		state: [{
 			kind: "boolean",
 			field: "on",
-			label: ON,
+			label: ON$1,
 			whenTrue: t("When {device} turns on", "Quando {device} si accende"),
 			whenFalse: t("When {device} turns off", "Quando {device} si spegne"),
 			icon: "power"
@@ -14291,6 +14260,133 @@ var CAMERA_CAP_VOCABULARY = {
 	}
 };
 /**
+* The heat pump (D1026): its system modes are phrased for automations, each with the
+* values the gateway really accepts; the per-circuit parameters need a circuit and are
+* set from the device page.
+*/
+var OFF = {
+	value: "off",
+	label: t("Off", "Off")
+};
+var AUTO = {
+	value: "auto",
+	label: t("Auto", "Auto")
+};
+var ON = {
+	value: "on",
+	label: t("On", "On")
+};
+var MANUAL = {
+	value: "manual",
+	label: t("Manual", "Manuale")
+};
+var HOLIDAY_PROGRAMMES = [OFF, ...[
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8
+].map((n) => ({
+	value: `hm${n}`,
+	label: t(`Programme ${n}`, `Programma ${n}`)
+}))];
+var PER_CIRCUIT = "Needs a circuit: set from the device page, not offered to automations";
+var HEAT_PUMP_CAP_VOCABULARY = {
+	"heat-pump-status": {
+		scope: "device",
+		noun: t("Heat pump", "Pompa di calore")
+	},
+	"heat-pump-control": {
+		scope: "device",
+		noun: t("Heat pump settings", "Impostazioni pompa di calore"),
+		actions: [
+			{
+				id: "heatPump.silent",
+				method: "setSilentMode",
+				label: t("Set silent mode", "Imposta la modalità silenziosa"),
+				phrase: t("Set silent mode of {device} to {mode}", "Imposta la modalità silenziosa di {device} su {mode}"),
+				icon: "volume-x",
+				openArgs: [{
+					key: "mode",
+					label: t("Silent mode", "Modalità silenziosa"),
+					offer: {
+						kind: "enum",
+						values: [
+							OFF,
+							AUTO,
+							ON
+						]
+					}
+				}]
+			},
+			{
+				id: "heatPump.away",
+				method: "setAwayMode",
+				label: t("Set away mode", "Imposta la modalità assente"),
+				phrase: t("Set away mode of {device} to {mode}", "Imposta la modalità assente di {device} su {mode}"),
+				icon: "plane",
+				openArgs: [{
+					key: "mode",
+					label: t("Away mode", "Modalità assente"),
+					offer: {
+						kind: "enum",
+						values: [OFF, ON]
+					}
+				}]
+			},
+			{
+				id: "heatPump.additionalHeater",
+				method: "setAdditionalHeaterMode",
+				label: t("Set additional heater", "Imposta il riscaldatore aggiuntivo"),
+				phrase: t("Set the additional heater of {device} to {mode}", "Imposta il riscaldatore aggiuntivo di {device} su {mode}"),
+				icon: "flame",
+				openArgs: [{
+					key: "mode",
+					label: t("Additional heater", "Riscaldatore aggiuntivo"),
+					offer: {
+						kind: "enum",
+						values: [
+							OFF,
+							MANUAL,
+							AUTO
+						]
+					}
+				}]
+			},
+			{
+				id: "heatPump.holiday",
+				method: "setHolidayMode",
+				label: t("Set holiday mode", "Imposta la modalità vacanza"),
+				phrase: t("Set holiday mode of {device} to {mode}", "Imposta la modalità vacanza di {device} su {mode}"),
+				icon: "tree-palm",
+				openArgs: [{
+					key: "mode",
+					label: t("Holiday programme", "Programma vacanza"),
+					offer: {
+						kind: "enum",
+						values: HOLIDAY_PROGRAMMES
+					}
+				}]
+			}
+		],
+		notOperatorFacing: {
+			setCircuitOperationMode: PER_CIRCUIT,
+			setCircuitHeatCoolMode: PER_CIRCUIT,
+			setCircuitSummerWinter: PER_CIRCUIT,
+			setCircuitComfortSetpoint: PER_CIRCUIT,
+			setCircuitEcoSetpoint: PER_CIRCUIT,
+			setCircuitMaxFlowTemp: PER_CIRCUIT,
+			setDhwOperationMode: PER_CIRCUIT,
+			setDhwTemperatureLevel: PER_CIRCUIT,
+			setDhwChargeDuration: PER_CIRCUIT,
+			startExtraHotWater: PER_CIRCUIT
+		}
+	}
+};
+/**
 * Things an operator WATCHES: contacts, motion, leaks, smoke, measurements,
 * presence, reachability, batteries, doorbells and event sources.
 */
@@ -15012,6 +15108,7 @@ var CAP_VOCABULARY_BY_NAME = {
 	...ACTUATOR_CAP_VOCABULARY,
 	...APPLIANCE_CAP_VOCABULARY,
 	...CAMERA_CAP_VOCABULARY,
+	...HEAT_PUMP_CAP_VOCABULARY,
 	...SENSOR_CAP_VOCABULARY,
 	...SYSTEM_CAP_VOCABULARY
 };
@@ -15259,6 +15356,8 @@ var CAP_NAMES = Object.freeze([
 	"group-active",
 	"group-commands",
 	"group-status",
+	"heat-pump-control",
+	"heat-pump-status",
 	"heating-valve",
 	"hero-layout",
 	"humidifier",
@@ -16124,6 +16223,48 @@ Object.freeze({
 			"valueType": "number"
 		}
 	],
+	"heat-pump-status": [
+		{
+			"path": "power.thermalW",
+			"valueType": "number"
+		},
+		{
+			"path": "power.electricalW",
+			"valueType": "number"
+		},
+		{
+			"path": "power.compressorPct",
+			"valueType": "number"
+		},
+		{
+			"path": "temperatures.supply",
+			"valueType": "number"
+		},
+		{
+			"path": "temperatures.return",
+			"valueType": "number"
+		},
+		{
+			"path": "temperatures.outdoor",
+			"valueType": "number"
+		},
+		{
+			"path": "energy.thermalKwh",
+			"valueType": "number"
+		},
+		{
+			"path": "energy.electricalKwh",
+			"valueType": "number"
+		},
+		{
+			"path": "waterPressureBar",
+			"valueType": "number"
+		},
+		{
+			"path": "starts",
+			"valueType": "number"
+		}
+	],
 	"heating-valve": [{
 		"path": "position",
 		"valueType": "number"
@@ -17264,12 +17405,8 @@ Object.freeze({
 		"uploadDataset": 72e5
 	}
 });
-object({
-	code: string().regex(/^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/),
-	params: record(string(), union([string(), number$1()])).optional()
-});
 //#endregion
-//#region ../types/dist/composition-CXCX78IR.mjs
+//#region ../types/dist/composition-C6TZGqUb.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -18983,25 +19120,6 @@ var RequiredAddonUpdateSchema = object({
 	installed: string().nullable()
 });
 /**
-* Which integration instance a settings form is for. An addon that serves several instances
-* (`instanceMode: multiple`) can show a different form per instance — an NVR integration
-* needs its connection, the default integration needs the addon's own sections.
-*
-* - `integrationId` is `null` in the create wizard: nothing exists yet, the operator is
-*   setting up a NEW instance.
-* - `mode` is the wizard mode of the integration type (`getAvailableTypes`).
-* - `candidateStableId` is the discovery candidate a wizard was seeded from, if any.
-*/
-var IntegrationInstanceRefSchema = object({
-	integrationId: string().nullable(),
-	mode: _enum([
-		"standalone",
-		"account",
-		"broker"
-	]),
-	candidateStableId: string().optional()
-});
-/**
 * notification-output — canonical, capability-gated notification delivery.
 *
 * Apprise-derived model (see
@@ -44435,21 +44553,44 @@ var AutomationCapStepBaseSchema = object({
 	*/
 	argUnits: record(string(), string().min(1)).optional()
 });
-var AutomationCapStepSchema = AutomationCapStepBaseSchema.refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
+/**
+* The steps an internal Action may contain: cap and wait, and nothing that can
+* call back into an Action — so an Action can never reach itself (no cycles).
+* This is the LEAF shape: no condition of its own.
+*/
+var LeafActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCapStepBaseSchema.refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
 	message: "a cap step needs a target",
 	path: ["target"]
 }).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
 	message: "a domain target needs the vocabulary action it applies to (actionId)",
 	path: ["actionId"]
-});
+})]);
 /**
-* The steps an internal Action may contain: cap and wait, and nothing that can
-* call back into an Action — so an Action can never reach itself (no cycles).
+* The optional guard of a step (#472): `if` is the ONE `when` tree (D980), read
+* on the state mirror when the step is reached; `else` runs when it is false.
+* An `else` holds leaf steps only — the nesting is bounded at ONE level, so a
+* branch can never grow a tree the trace has to draw.
 */
-var ActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCapStepSchema]);
+var stepGuardShape = {
+	if: AutomationWhenSchema.optional(),
+	else: array(LeafActionStepSchema).max(10).optional()
+};
+var elseNeedsIf = {
+	message: "an else list needs the condition it is the other side of (if)",
+	path: ["else"]
+};
+var GuardedWaitStepSchema = AutomationWaitStepSchema.extend(stepGuardShape).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf);
+var GuardedCapStepSchema = AutomationCapStepBaseSchema.extend(stepGuardShape).refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
+	message: "a cap step needs a target",
+	path: ["target"]
+}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
+	message: "a domain target needs the vocabulary action it applies to (actionId)",
+	path: ["actionId"]
+}).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf);
+var ActionStepSchema = discriminatedUnion("kind", [GuardedWaitStepSchema, GuardedCapStepSchema]);
 var AutomationActionSchema = discriminatedUnion("kind", [
-	AutomationWaitStepSchema,
-	AutomationCapStepSchema,
+	GuardedWaitStepSchema,
+	GuardedCapStepSchema,
 	object({
 		kind: literal("action"),
 		/** An entry of the `actions` surface (`internal:<uuid>` or `<addonId>:<localId>`). */
@@ -44829,7 +44970,7 @@ var StepDeviceTraceSchema = object({
 	outcome: _enum(["ok", "error"]),
 	message: string().optional()
 });
-var AutomationStepTraceSchema = object({
+var StepTraceBaseSchema = object({
 	/** `actions.<i>` */
 	path: string().min(1),
 	kind: string().min(1),
@@ -44848,15 +44989,35 @@ var AutomationStepTraceSchema = object({
 	* is shown as {@link REDACTED_ARG}. Absent on traces written before it existed.
 	*/
 	args: record(string(), TraceValueSchema).optional(),
-	/** `empty`: the target resolved to no device, so nothing was done — never silently `ok`. */
+	/**
+	* The device values a templated arg printed as `—`, one `ref: reason` each
+	* (D1021): why a sentence says "—" where a number was expected. Bounded.
+	*/
+	templates: array(string()).max(20).optional(),
+	/**
+	* What the step's own `if` read when the step was reached (#472): `true` the
+	* step ran, `false` its `else` ran (or nothing did), `unknown` a state leaf
+	* could not be read, so NEITHER side ran. Absent on an unguarded step.
+	*/
+	condition: _enum([
+		"true",
+		"false",
+		"unknown"
+	]).optional(),
+	/** Why the condition read what it read, in the evaluator's own words. */
+	conditionReason: string().optional(),
+	/** `empty`: the target resolved to no device, so nothing was done — never silently `ok`. `skipped`: its `if` was false (or unknown) and nothing ran in its place. */
 	outcome: _enum([
 		"ok",
 		"error",
 		"not-run",
-		"empty"
+		"empty",
+		"skipped"
 	]),
 	message: string().optional()
 });
+/** A step trace; the `else` steps that ran are one level of the same shape (the nesting is bounded at one). */
+var AutomationStepTraceSchema = StepTraceBaseSchema.extend({ else: array(StepTraceBaseSchema).optional() });
 var AutomationRunTraceSchema = object({
 	runId: string().min(1),
 	startedAt: number$1(),
@@ -45032,6 +45193,7 @@ _enum([
 	"invalid-variables",
 	"invalid-steps",
 	"not-linked",
+	"template-scope",
 	"busy"
 ]);
 object({
@@ -45356,10 +45518,6 @@ method(object({
 	scope: ScopedSettingsScopeSchema,
 	nodeId: string().optional()
 }), record(string(), unknown()).nullable()), method(object({
-	addonId: string(),
-	nodeId: string().optional(),
-	instance: IntegrationInstanceRefSchema
-}), SettingsSchemaWithValuesSchema.nullable()), method(object({
 	addonId: string(),
 	nodeId: string().optional()
 }), object({ keys: array(string()) }).nullable(), { auth: "admin" }), method(object({
@@ -50599,7 +50757,7 @@ var mediaPlayerCapability = {
 		isMuted: { kind: "boolean" }
 	} }
 };
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway, DeviceType.Camera, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Gateway, DeviceType.Hub, DeviceType.Camera, DeviceType.Sensor, DeviceType.MediaPlayer, DeviceType.Vacuum, DeviceType.Generic, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.PetFountain, DeviceType.Fan, DeviceType.Humidifier, DeviceType.Climate, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.MediaPlayer;
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway, DeviceType.HeatPump, DeviceType.Camera, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Gateway, DeviceType.Hub, DeviceType.Camera, DeviceType.Sensor, DeviceType.MediaPlayer, DeviceType.Vacuum, DeviceType.Generic, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.PetFountain, DeviceType.Fan, DeviceType.Humidifier, DeviceType.Climate, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.MediaPlayer;
 var NUMBER = {
 	kind: "fixed",
 	result: ["number"]
@@ -52618,6 +52776,43 @@ method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(Expor
 	auth: "admin"
 });
 var DeviceAliasSchema = string().max(64).regex(/^[a-z][a-z0-9_]*$/);
+var DeviceTemplateSchema = string().min(1).max(4096);
+var DeviceTemplateRefusalSchema = object({
+	reason: _enum([
+		"too-long",
+		"syntax",
+		"forbidden-syntax",
+		"forbidden-member",
+		"unknown-filter",
+		"ambiguous-field",
+		"busy",
+		"budget-exceeded",
+		"timeout",
+		"output-too-large",
+		"render-failed",
+		"out-of-scope",
+		"unavailable"
+	]),
+	message: string()
+});
+var DeviceTemplateTraceEntrySchema = object({
+	ref: string(),
+	reason: _enum([
+		"unknown-alias",
+		"unknown-field",
+		"no-field",
+		"unavailable"
+	])
+});
+var DeviceTemplateRenderSchema = discriminatedUnion("ok", [object({
+	ok: literal(true),
+	text: string(),
+	trace: array(DeviceTemplateTraceEntrySchema)
+}), object({
+	ok: literal(false),
+	refusal: DeviceTemplateRefusalSchema,
+	trace: array(DeviceTemplateTraceEntrySchema)
+})]);
 /**
 * A SITE ZONE — a named part of the property that several locations belong to.
 *
@@ -53449,6 +53644,22 @@ method(object({
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
+	templates: array(DeviceTemplateSchema).max(64),
+	allowedDeviceIds: array(number$1().int()).optional()
+}), object({ results: array(DeviceTemplateRenderSchema) }), { auth: "admin" }), method(object({
+	templates: array(string()).max(64),
+	allowedDeviceIds: array(number$1().int()).optional()
+}), object({ results: array(discriminatedUnion("ok", [object({
+	ok: literal(true),
+	aliases: array(object({
+		alias: string(),
+		deviceId: number$1().int().nullable(),
+		allowed: boolean()
+	}))
+}), object({
+	ok: literal(false),
+	refusal: DeviceTemplateRefusalSchema
+})])) }), { auth: "admin" }), method(object({
 	deviceId: number$1(),
 	location: string().nullable()
 }), _void(), {
@@ -56639,6 +56850,332 @@ var groupStatusCapability = {
 	durability: "session",
 	history: "none"
 };
+/**
+* Heat pump settable surface (D1026): one typed method per parameter, never a
+* generic `set(key, value)`. The values a mode takes and the limits of a number
+* are the ones `heat-pump-status` carries (`allowed`, `min`, `max`, `step`),
+* read from the gateway; a provider refuses a value outside them. The state is
+* `heat-pump-status` — this cap has none.
+*/
+var deviceId = number$1().int().nonnegative();
+var circuitId = string().min(1);
+var mode = string().min(1);
+var temp = number$1().finite();
+var heatPumpControlCapability = {
+	name: "heat-pump-control",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.HeatPump],
+	methods: {
+		/** off / auto / on. */
+		setSilentMode: method(object({
+			deviceId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** off / on. */
+		setAwayMode: method(object({
+			deviceId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** off / manual / auto. */
+		setAdditionalHeaterMode: method(object({
+			deviceId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** off / hm1 .. hm8 (the programmes the gateway lists). */
+		setHolidayMode: method(object({
+			deviceId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitOperationMode: method(object({
+			deviceId,
+			circuitId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitHeatCoolMode: method(object({
+			deviceId,
+			circuitId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitSummerWinter: method(object({
+			deviceId,
+			circuitId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitComfortSetpoint: method(object({
+			deviceId,
+			circuitId,
+			temp
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitEcoSetpoint: method(object({
+			deviceId,
+			circuitId,
+			temp
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setCircuitMaxFlowTemp: method(object({
+			deviceId,
+			circuitId,
+			temp
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setDhwOperationMode: method(object({
+			deviceId,
+			circuitId,
+			mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setDhwTemperatureLevel: method(object({
+			deviceId,
+			circuitId,
+			level: mode
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		setDhwChargeDuration: method(object({
+			deviceId,
+			circuitId,
+			minutes: number$1().int().positive()
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** Start an extra-hot-water charge now: an action, not a stored mode. */
+		startExtraHotWater: method(object({
+			deviceId,
+			circuitId
+		}), _void(), {
+			kind: "mutation",
+			auth: "protected"
+		})
+	}
+};
+var HeatPumpCircuitKindSchema = _enum([
+	"heating",
+	"dhw",
+	"cooling",
+	"solar"
+]);
+/** A setting that takes one of a list of values the gateway named. */
+var HeatPumpOptionSettingSchema = object({
+	/** The active value. Null when the gateway did not answer. */
+	value: string().nullable(),
+	/** Values the gateway accepts, in its order. Empty = read-only here. */
+	allowed: array(string())
+});
+/** A numeric setting with the limits the gateway named. */
+var HeatPumpRangeSettingSchema = object({
+	value: number$1().nullable(),
+	min: number$1().nullable(),
+	max: number$1().nullable(),
+	step: number$1().nullable()
+});
+var HeatPumpCircuitSchema = object({
+	/** Gateway id of the circuit (`hc1`, `dhw1`): the key of the series. */
+	id: string().min(1),
+	kind: HeatPumpCircuitKindSchema,
+	label: string(),
+	icon: IconKeySchema,
+	/** Measured temperature of the circuit (room, tank, collector). */
+	currentTemp: number$1().nullable().meta(readingMeta("temperature")),
+	/** The setpoint in force now. */
+	targetTemp: number$1().nullable().meta(readingMeta("temperature")),
+	/** The operation mode in force (mirror of `operationMode.value`, for the series). */
+	mode: string().nullable(),
+	/** Whether the circuit is calling for heat right now. Null = unknown. */
+	active: boolean().nullable(),
+	operationMode: HeatPumpOptionSettingSchema.nullable(),
+	/** Heating circuits: heat / cool / heatCool. */
+	heatCoolMode: HeatPumpOptionSettingSchema.nullable(),
+	/** Heating circuits: summer / winter changeover. */
+	summerWinter: HeatPumpOptionSettingSchema.nullable(),
+	comfortSetpoint: HeatPumpRangeSettingSchema.nullable(),
+	ecoSetpoint: HeatPumpRangeSettingSchema.nullable(),
+	maxFlowTemp: HeatPumpRangeSettingSchema.nullable(),
+	/** Hot water: the temperature level (off / low / high / eco). */
+	temperatureLevel: HeatPumpOptionSettingSchema.nullable(),
+	/** Hot water: how long a charge lasts, minutes. */
+	chargeDuration: HeatPumpRangeSettingSchema.nullable(),
+	/** Hot water: whether an extra-hot-water charge is running. Null = no such surface. */
+	extraHotWater: boolean().nullable()
+});
+/** The independent system modes, each with its real values. A null mode = the gateway has none. */
+var HeatPumpSystemSchema = object({
+	silent: HeatPumpOptionSettingSchema.nullable(),
+	away: HeatPumpOptionSettingSchema.nullable(),
+	additionalHeater: HeatPumpOptionSettingSchema.nullable(),
+	holiday: HeatPumpOptionSettingSchema.nullable()
+});
+var HeatPumpPowerSchema = object({
+	thermalW: number$1().nullable().meta(readingMeta("power")),
+	electricalW: number$1().nullable().meta(readingMeta("power")),
+	/** Compressor modulation, percent. */
+	compressorPct: number$1().nullable().meta(readingMeta("percentage"))
+});
+var HeatPumpTemperaturesSchema = object({
+	supply: number$1().nullable().meta(readingMeta("temperature")),
+	return: number$1().nullable().meta(readingMeta("temperature")),
+	outdoor: number$1().nullable().meta(readingMeta("temperature"))
+});
+/** Lifetime meters, kWh: the energy of a period is computed at read time from their difference (D944). */
+var HeatPumpEnergySchema = object({
+	thermalKwh: number$1().nullable().meta(readingMeta("energy")),
+	electricalKwh: number$1().nullable().meta(readingMeta("energy"))
+});
+var HeatPumpStatusSchema = object({
+	circuits: array(HeatPumpCircuitSchema),
+	system: HeatPumpSystemSchema,
+	power: HeatPumpPowerSchema,
+	temperatures: HeatPumpTemperaturesSchema,
+	energy: HeatPumpEnergySchema,
+	/** Water pressure of the heating loop, bar. */
+	waterPressureBar: number$1().nullable(),
+	/** Compressor starts since commissioning. */
+	starts: number$1().nullable(),
+	/** Ms epoch when the slice was last read from the gateway. */
+	lastFetchedAt: number$1()
+});
+/**
+* The instantaneous COP: thermal over electrical power. Null unless BOTH powers
+* are known and the unit draws power — a missing reading is never a 0 or a
+* division by it (D393). Computed on every read; there is no stored value.
+*/
+function heatPumpInstantCop(power) {
+	const { thermalW, electricalW } = power;
+	if (thermalW === null || electricalW === null || electricalW <= 0) return null;
+	return thermalW / electricalW;
+}
+var heatPumpStatusCapability = {
+	name: "heat-pump-status",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.HeatPump],
+	methods: {},
+	status: {
+		schema: HeatPumpStatusSchema,
+		kind: "push"
+	},
+	runtimeState: HeatPumpStatusSchema,
+	/**
+	* Runtime-state durability: **session** — a heat pump's gateway answers on the
+	* next poll, so a restart that clears the slice loses nothing a reader needs
+	* (the series are recorded). See `RuntimeStateDurability`.
+	*/
+	durability: "session",
+	/**
+	* History (D850, D917): `circuits[]` is a keyed array — one series per circuit and
+	* field, named by the circuit's label. The mode is a state (D896); the energy
+	* totals are lifetime counters, the kWh of a period is computed at read time (D944).
+	* The COP is never recorded: it derives from the two powers.
+	*/
+	history: {
+		fields: {
+			"power.thermalW": {
+				kind: "gauge",
+				unit: "W",
+				deadband: 50,
+				displayName: "Thermal power"
+			},
+			"power.electricalW": {
+				kind: "gauge",
+				unit: "W",
+				deadband: 50,
+				displayName: "Electrical power"
+			},
+			"power.compressorPct": {
+				kind: "gauge",
+				unit: "%",
+				deadband: 2,
+				displayName: "Compressor"
+			},
+			"temperatures.supply": {
+				kind: "gauge",
+				unit: "°C",
+				deadband: .5,
+				displayName: "Supply"
+			},
+			"temperatures.return": {
+				kind: "gauge",
+				unit: "°C",
+				deadband: .5,
+				displayName: "Return"
+			},
+			"temperatures.outdoor": {
+				kind: "gauge",
+				unit: "°C",
+				deadband: .5,
+				displayName: "Outdoor"
+			},
+			"energy.thermalKwh": {
+				kind: "counter",
+				unit: "kWh",
+				displayName: "Thermal energy"
+			},
+			"energy.electricalKwh": {
+				kind: "counter",
+				unit: "kWh",
+				displayName: "Electrical energy"
+			}
+		},
+		items: {
+			path: "circuits",
+			key: "id",
+			label: "label",
+			fields: {
+				currentTemp: {
+					kind: "gauge",
+					unit: "°C",
+					deadband: .5,
+					displayName: "Temperature"
+				},
+				targetTemp: {
+					kind: "gauge",
+					unit: "°C",
+					minIntervalMs: 0,
+					displayName: "Setpoint"
+				},
+				mode: {
+					kind: "enum",
+					displayName: "Mode"
+				}
+			}
+		}
+	},
+	volatileStateFields: ["lastFetchedAt"]
+};
 var HeatingValveStatusSchema = object({
 	/** Radiator valve opening 0 (closed) .. 100 (open). Null = not yet known. */
 	position: number$1().min(0).max(100).nullable().meta(readingMeta("percentage")),
@@ -56853,6 +57390,7 @@ var HeroSceneSchema = object({
 		"ac",
 		"thermostat",
 		"heater",
+		"heat-pump",
 		"fan",
 		"washer",
 		"dryer",
@@ -56895,7 +57433,7 @@ var HeroSceneSchema = object({
 	/** 0..1: volume, cover position, cycle progress. */
 	level: number$1().min(0).max(1).nullable()
 });
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
 DeviceRole.Siren, DeviceRole.Floodlight, DeviceRole.Spotlight, DeviceRole.PirSensor, DeviceRole.Chime, DeviceRole.Autotrack, DeviceRole.Nightvision, DeviceRole.PrivacyMask, DeviceRole.Doorbell, DeviceRole.CoverBlind, DeviceRole.CoverShutter, DeviceRole.CoverAwning, DeviceRole.CoverCurtain, DeviceRole.CoverGarage, DeviceRole.CoverGate, DeviceRole.CoverDoor, DeviceRole.CoverWindow, DeviceRole.BinaryHelper, DeviceRole.Outlet, DeviceRole.MotionSensor, DeviceRole.ContactSensor, DeviceRole.LeakSensor, DeviceRole.SmokeSensor, DeviceRole.COSensor, DeviceRole.GasSensor, DeviceRole.TamperSensor, DeviceRole.VibrationSensor, DeviceRole.ConnectivitySensor, DeviceRole.SoundSensor, DeviceRole.BinarySensor, DeviceRole.TemperatureSensor, DeviceRole.HumiditySensor, DeviceRole.AmbientLightSensor, DeviceRole.PressureSensor, DeviceRole.WindSensor, DeviceRole.RainSensor, DeviceRole.UvSensor, DeviceRole.SolarRadiationSensor, DeviceRole.SoilMoistureSensor, DeviceRole.PowerSensor, DeviceRole.EnergySensor, DeviceRole.VoltageSensor, DeviceRole.CurrentSensor, DeviceRole.AirQualitySensor, DeviceRole.BatterySensor, DeviceRole.NumericSensor, DeviceRole.EnumSensor, DeviceRole.DateTimeSensor, DeviceRole.GenericSensor, DeviceRole.NumericControl, DeviceRole.SelectControl, DeviceRole.TextControl, DeviceRole.DateTimeControl, DeviceRole.MobilePushNotifier, DeviceRole.MessagingNotifier, DeviceRole.EmailNotifier, DeviceRole.GenericNotifier, DeviceRole.IrTransmitter;
 /** A string in both languages, as the cap vocabulary writes it (D920): no `t()` in the model. */
 var HeroTextSchema = object({
@@ -56903,6 +57441,7 @@ var HeroTextSchema = object({
 	it: string()
 });
 var HeroRowIdSchema = _enum([
+	"progress",
 	"run-for",
 	"cycle",
 	"program",
@@ -56917,6 +57456,7 @@ var HeroRowIdSchema = _enum([
 	"alarm",
 	"fan",
 	"vacuum",
+	"vacuum-suction",
 	"mower",
 	"feeder",
 	"fountain",
@@ -56935,7 +57475,10 @@ var HeroRowIdSchema = _enum([
 	"climate-fan",
 	"setpoint",
 	"channel",
-	"control"
+	"control",
+	"circuit",
+	"heat-pump-power",
+	"system-mode"
 ]);
 var HeroArgValueSchema = lazy(() => union([
 	string(),
@@ -57000,16 +57543,32 @@ var HeroControlSchema = discriminatedUnion("kind", [
 		label: HeroTextSchema,
 		current: string().nullable(),
 		options: array(string()),
+		/** A readable label per option value; an option without one is drawn as its raw value. */
+		optionLabels: record(string(), HeroTextSchema).optional(),
 		call: HeroCallSchema,
 		valueArg: string()
 	})
 ]);
+/** Declared by its interface: a `z.infer` of one more icon union pushes the cap's inferred type past what the compiler can print. */
+var HeroPillSchema = object({
+	icon: IconKeySchema.nullable(),
+	text: HeroTextSchema,
+	tone: HeroToneSchema
+});
 var HeroRowSchema = object({
 	id: HeroRowIdSchema,
+	/** The row's own name when the kind's label would not tell rows of one kind apart (a circuit's label). */
+	label: HeroTextSchema.optional(),
+	/** A group header drawn above the row when it differs from the previous row's ("System"). */
+	group: HeroTextSchema.optional(),
+	/** Values drawn as pills across the row (a heat pump's powers). */
+	pills: array(HeroPillSchema).optional(),
 	icon: IconKeySchema,
 	/** The row's status, in words. `null` = nothing to say. */
 	status: HeroTextSchema.nullable(),
-	controls: array(HeroControlSchema)
+	controls: array(HeroControlSchema),
+	/** A bar under the row's label, 0..1; `null` / absent = no bar. */
+	progress: number$1().min(0).max(1).nullable().optional()
 });
 var HeroDetailSchema = object({
 	label: HeroTextSchema,
@@ -57017,7 +57576,11 @@ var HeroDetailSchema = object({
 	unit: string().nullable()
 });
 var HeroBadgeSchema = object({
-	id: _enum(["battery", "network-link"]),
+	id: _enum([
+		"battery",
+		"network-link",
+		"integration"
+	]),
 	icon: IconKeySchema,
 	tone: HeroToneSchema,
 	/** Percent for a battery, link quality for a link; `null` = not known. */
@@ -57065,7 +57628,13 @@ var HeroTimedRunSlotSchema = object({
 	activeUntil: number$1().nullable(),
 	quickRun: TimedRunQuickRunSchema,
 	run: HeroActionSchema,
-	cancel: HeroActionSchema
+	cancel: HeroActionSchema,
+	/**
+	* Whole units left (the limit's unit, ceil). `null` while nothing is armed.
+	* A number, not words: the row formats it, and a text here would not fit the
+	* hero-layout declaration.
+	*/
+	remaining: number$1().nullable()
 });
 var HeroPowerSupplySlotSchema = object({
 	/** The plug's state; `null` = unknown, never off. */
@@ -57117,7 +57686,12 @@ var HeroFactSchema = object({
 var HeroSideTileSchema = object({
 	label: HeroTextSchema,
 	value: HeroTextSchema,
-	tone: HeroToneSchema.optional()
+	tone: HeroToneSchema.optional(),
+	/**
+	* Epoch ms when the tile reads a clock time (an appliance's end): a client prints it in
+	* the viewer's own time zone; `value` is the fallback for one that cannot.
+	*/
+	at: number$1().optional()
 });
 var HeroSideTilesSchema = object({
 	left: array(HeroSideTileSchema).max(2),
@@ -57153,8 +57727,12 @@ var HeroModelSchema = object({
 	sideTiles: HeroSideTilesSchema,
 	/** The status line under the main icon. */
 	title: HeroTextSchema,
+	/** The scene's top line when it says more than `title`; absent = draw the title. */
+	caption: HeroTextSchema.optional(),
 	badges: array(HeroBadgeSchema),
 	remote: HeroRemoteSlotSchema.nullable(),
+	/** The foot button that opens the device's history: "History", "Cycles", "Meals", "Access". */
+	historyLabel: HeroTextSchema,
 	consumables: HeroConsumablesSlotSchema.nullable(),
 	consumption: HeroConsumptionSlotSchema.nullable(),
 	ownPower: HeroOwnPowerSlotSchema.nullable(),
@@ -57175,18 +57753,31 @@ var HeroModelSchema = object({
 *   4. a trailing fact (power, else battery, else consumables).
 *
 * Selection rules, all taken from the model:
-*   - ONE control is ever shown: the device's own power; else the FIRST control of
+*   - the primary control is the device's own power; else the FIRST control of
 *     the FIRST row that has any (a later row's control is never promoted). When
 *     the model lists that part in `gated`, the row has no inline control: the
 *     projection never falls through to another control the caller could use.
+*   - a timed run, when the model carries the slot, sits beside that primary:
+*     Run while idle, Stop while armed. Gating the slot hides the control.
 *   - the status line is the head (what plays, else the state) plus at most
-*     {@link ROW_STATUS_FACTS_MAX} facts, the trailing fact excluded;
+*     {@link ROW_STATUS_FACTS_MAX} facts, the trailing fact excluded, then the
+*     time left on an armed timed run;
 *   - the trailing fact is the first of power, battery, consumables.
 *
 * `projectDeviceRow` is pure and computes nothing: it selects from a
 * {@link HeroModel}. A row that needed a value the hero lacks would mean the
 * model is missing it, so the fix goes in the model.
 */
+/**
+* The row's timed-run control. `id` is `timed-run.run` while idle and
+* `timed-run.cancel` while armed; `duration` and `unit` are the one-tap run
+* a Run press starts.
+*/
+var HeroRowTimedRunSchema = object({
+	id: _enum(["timed-run.run", "timed-run.cancel"]),
+	duration: number$1(),
+	unit: _enum(["min", "s"])
+});
 var HeroRowModelSchema = object({
 	deviceId: number$1().int(),
 	name: string(),
@@ -57199,6 +57790,11 @@ var HeroRowModelSchema = object({
 	statusLine: array(HeroTextSchema),
 	/** `null` = the type has no inline control, or the caller may not act on it. */
 	primary: HeroControlSchema.nullable(),
+	/**
+	* Beside `primary` when the device offers a timed run: Run while idle, Stop
+	* while armed. `null` when there is no slot, or the caller may not act.
+	*/
+	timedRun: HeroRowTimedRunSchema.nullable(),
 	trailing: HeroFactSchema.nullable()
 });
 /**
@@ -57612,6 +58208,12 @@ var IntegrationWithStateSchema = object({
 	name: string(),
 	/** A projection of the instance body's switch (`setInstanceEnabled` is the only writer). */
 	enabled: boolean(),
+	/**
+	* True when the addon that holds the switch did not answer (down, failed, or keeps no record for
+	* this row): `enabled` is then the stored registry flag, a stale value, not the state. A reader
+	* must not draw it as on or off (D315).
+	*/
+	switchUnknown: literal(true).optional(),
 	info: record(string(), unknown()).readonly(),
 	/** The discovery candidate this integration was set up from (D984). */
 	originStableId: string().optional(),
@@ -57625,6 +58227,12 @@ var IntegrationLiteSchema = object({
 	name: string(),
 	/** A projection of the instance body's switch (`setInstanceEnabled` is the only writer). */
 	enabled: boolean(),
+	/**
+	* True when the addon that holds the switch did not answer (down, failed, or keeps no record for
+	* this row): `enabled` is then the stored registry flag, a stale value, not the state. A reader
+	* must not draw it as on or off (D315).
+	*/
+	switchUnknown: literal(true).optional(),
 	info: record(string(), unknown()).readonly(),
 	/** The discovery candidate this integration was set up from (D984). */
 	originStableId: string().optional(),
@@ -57723,9 +58331,9 @@ var UpdateIntegrationInputSchema = object({
 	id: string(),
 	name: string().optional(),
 	/**
-	* Accepted for a FIXED builtin only (`info.fixed`: alarm panel, camera grid, core blocks,
-	* terminal), which keeps no instance record: the registry flag is its one store. Any other
-	* integration is switched through `integration-instances.setInstanceEnabled`.
+	* Honoured ONLY for a fixed builtin (`info.fixed`), whose switch is the hub's own registry flag
+	* and works while its addon is down. Any other row is refused (a typed `BAD_REQUEST`): its
+	* switch is `integration-instances.setInstanceEnabled`.
 	*/
 	enabled: boolean().optional(),
 	info: record(string(), unknown()).optional()
@@ -57759,6 +58367,12 @@ method(_void(), array(IntegrationWithStateSchema)), method(object({ id: string()
 * the form as a `SecretFieldView`, never text (D789). A patch value omitted, `''`
 * or the redaction token KEEPS the stored secret; `{ $secretClear: true }`
 * clears it.
+*
+* Who may call (epic #440): every method but `describe` and `instanceFormSchema` is open to any
+* session (`caller: 'scoped'`) and default-denies. An admin passes everywhere. A non-admin passes
+* only on a call pinned to one addon whose `describe().userScoped` is true, and that provider
+* filters every row on the `caller` the router injected (a notification target is somebody's
+* phone: a user sees and changes only their own). An addon that says nothing keeps the admin door.
 */
 var ConfigSchemaPassthrough$2 = custom();
 var IntegrationInstanceIdSchema = string().min(1);
@@ -57872,7 +58486,15 @@ var IntegrationInstanceDescriptionSchema = object({
 	*/
 	mintsId: boolean().optional(),
 	/** The links to other instances the provider's kinds declare; absent means none. */
-	links: array(IntegrationInstanceLinkSchema).optional()
+	links: array(IntegrationInstanceLinkSchema).optional(),
+	/**
+	* The rows belong to individual users (a notification target is somebody's phone). The router
+	* then opens `listInstances`, `getInstance`, `createInstance`, `updateInstance`,
+	* `setInstanceEnabled`, `deleteInstance` and `testInstance` to a NON-admin session on a call
+	* pinned to this addon, and hands the provider the `caller` so it keeps a user to their own rows.
+	* Absent means admin only, as it always was.
+	*/
+	userScoped: boolean().optional()
 });
 var IntegrationInstanceStatusSchema = object({
 	state: _enum([
@@ -57930,8 +58552,14 @@ var integrationInstancesCapability = {
 			/** The discovery candidate the wizard was seeded from (`stableId`), if any. */
 			candidateStableId: string().min(1).optional()
 		}), ConfigSchemaPassthrough$2, { auth: "admin" }),
-		listInstances: method(_void(), array(IntegrationInstanceSchema).readonly(), { auth: "admin" }),
-		getInstance: method(object({ id: IntegrationInstanceIdSchema }), IntegrationInstanceSchema.nullable(), { auth: "admin" }),
+		listInstances: method(looseObject({}), array(IntegrationInstanceSchema).readonly(), {
+			auth: "protected",
+			caller: "scoped"
+		}),
+		getInstance: method(object({ id: IntegrationInstanceIdSchema }), IntegrationInstanceSchema.nullable(), {
+			auth: "protected",
+			caller: "scoped"
+		}),
 		/**
 		* Insert the typed record. With `id` it is stored under that id (a duplicate id is refused);
 		* without one the PROVIDER mints it and answers it. `kind` picks one of `describe().kinds`.
@@ -57964,11 +58592,13 @@ var integrationInstancesCapability = {
 			seed: object({ info: record(string(), unknown()) }).optional()
 		}), object({ id: string() }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected",
+			caller: "scoped"
 		}),
 		updateInstance: method(IntegrationInstancePatchSchema, object({ ok: literal(true) }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected",
+			caller: "scoped"
 		}),
 		/**
 		* Switch ONE instance on or off, for every role; a missing record is created from the addon's
@@ -57980,7 +58610,8 @@ var integrationInstancesCapability = {
 			enabled: boolean()
 		}), object({ ok: literal(true) }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected",
+			caller: "scoped"
 		}),
 		/**
 		* Delete the record and its keychain refs together. For an instance that brings devices the hub
@@ -57989,7 +58620,8 @@ var integrationInstancesCapability = {
 		*/
 		deleteInstance: method(object({ id: IntegrationInstanceIdSchema }), object({ ok: literal(true) }), {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected",
+			caller: "scoped"
 		}),
 		testInstance: optionalMethod(object({
 			id: IntegrationInstanceIdSchema.nullable(),
@@ -57998,7 +58630,8 @@ var integrationInstancesCapability = {
 			kind: string().min(1).optional()
 		}), TestConnectionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected",
+			caller: "scoped"
 		})
 	}
 };
@@ -77465,6 +78098,11 @@ var SendEmailResultSchema = object({
 var SmtpStatusSchema = object({
 	/** True iff the addon has successfully verified the relay. */
 	ready: boolean(),
+	/**
+	* The tri-state behind `ready` (D315): true when the last send worked, false when it failed,
+	* ABSENT when the relay has not sent yet (unknown, never "not verified").
+	*/
+	verified: boolean().optional(),
 	/** Operator-visible host string (no credentials). */
 	host: string(),
 	/** Last error message reported by the relay, when not ready. */
@@ -77476,10 +78114,6 @@ method(SendEmailInputSchema, SendEmailResultSchema, {
 	kind: "mutation",
 	auth: "admin",
 	access: "create"
-}), method(RelayPinSchema, SmtpStatusSchema, {
-	kind: "mutation",
-	auth: "admin",
-	access: "view"
 }), method(RelayPinSchema, SmtpStatusSchema, { auth: "admin" });
 /**
 * A single device snapshot returned as base64 JPEG/PNG.
@@ -82417,6 +83051,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	groupCommands: groupCommandsCapability,
 	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
+	heatPumpStatus: heatPumpStatusCapability,
 	humidifier: humidifierCapability,
 	humiditySensor: humiditySensorCapability,
 	image: imageCapability,
@@ -83700,7 +84335,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
-DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Heater, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Heater, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
 new Set(Object.values(DeviceType));
 /** Parses the raw slice with the cap's own schema; `undefined` when it does not parse. */
 function contribution(cap, schema, build) {
@@ -83836,6 +84471,13 @@ var lockContribution = contribution("lock-control", LockControlStatusSchema, (sl
 		reading: reading("lock-control", words?.state ?? "unknown", false, words?.title),
 		rows: [row$1("lock", state === "locked" || state === "locking" ? "lock" : "lock-open", joinText([title, since]), lockControls(state, ctx.features.includes(DeviceFeature.LockOpen)))],
 		...since === null || words === null ? {} : { facts: [fact("since", "clock", since, "muted")] },
+		...words === null ? {} : { tiles: { left: [{
+			label: t("Door", "Porta"),
+			value: title
+		}, ...since === null ? [] : [{
+			label: t("Since", "Da"),
+			value: since
+		}]] } },
 		...words?.door == null ? {} : { scene: { mode: words.door } }
 	};
 });
@@ -83917,7 +84559,17 @@ var ACCESS_FAMILY_CONTRIBUTIONS = {
 		return {
 			reading: reading("alarm-panel", words?.state ?? "unknown", false, words?.title),
 			rows: [row$1("alarm", state === "triggered" ? "shield-alert" : state === "disarmed" ? "shield-off" : "shield-check", joinText([words?.title ?? t("Unknown", "Sconosciuto"), since]), alarmControls(state, modes, slice?.requiresCode ?? false))],
-			...since === null || words === null ? {} : { facts: [fact("since", "clock", since, state === "triggered" ? "danger" : "muted")] }
+			...since === null || words === null ? {} : { facts: [fact("since", "clock", since, state === "triggered" ? "danger" : "muted")] },
+			...words === null ? {} : { tiles: {
+				left: [{
+					label: t("Mode", "Modalità"),
+					value: words.title
+				}],
+				...since === null ? {} : { right: [{
+					label: t("Since", "Da"),
+					value: since
+				}] }
+			} }
 		};
 	}),
 	"automation-control": contribution("automation-control", AutomationControlStatusSchema, (slice, ctx) => {
@@ -83981,7 +84633,7 @@ var ACCESS_FAMILY_CONTRIBUTIONS = {
 */
 var has$3 = (ctx, f) => ctx.features.includes(f);
 var unknownText = t("Unknown", "Sconosciuto");
-var pct$1 = (n) => t(`${Math.round(n)}%`, `${Math.round(n)}%`);
+var pct$2 = (n) => t(`${Math.round(n)}%`, `${Math.round(n)}%`);
 var unit = (n) => Math.min(1, Math.max(0, n / 100));
 /** Battery as a fact, unless the device is also bound to the `battery` cap (it already says so). */
 function ownBattery(level, ctx) {
@@ -84043,7 +84695,7 @@ var fanContribution = contribution("fan-control", FanControlStatusSchema, (slice
 		},
 		valueArg: "direction"
 	});
-	const speedText = speed === null ? null : pct$1(speed);
+	const speedText = speed === null ? null : pct$2(speed);
 	const preset = slice?.preset ?? "";
 	const status = speed === null ? unknownText : joinText([speed === 0 ? t("Off", "Spento") : t(`Speed ${speed}%`, `Velocità ${speed}%`), preset === "" ? null : t(preset, preset)]);
 	return {
@@ -84056,10 +84708,16 @@ var fanContribution = contribution("fan-control", FanControlStatusSchema, (slice
 		}],
 		...speedText === null ? {} : {
 			facts: [fact("speed", "fan", speedText, speed === 0 ? "muted" : "primary")],
-			tiles: { right: [{
-				label: t("Speed", "Velocità"),
-				value: speedText
-			}] },
+			tiles: {
+				...slice?.oscillating == null ? {} : { left: [{
+					label: t("Oscillation", "Oscilla"),
+					value: slice.oscillating ? t("Yes", "Sì") : t("No", "No")
+				}] },
+				...preset === "" ? {} : { right: [{
+					label: t("Mode", "Modalità"),
+					value: t(preset, preset)
+				}] }
+			},
 			scene: { level: unit(speed ?? 0) }
 		}
 	};
@@ -84123,7 +84781,8 @@ var vacuumContribution = contribution("vacuum-control", VacuumControlStatusSchem
 	const words = state === null ? null : VACUUM_WORDS[state];
 	const title = state === "error" && slice?.errorLabel ? t(slice.errorLabel, slice.errorLabel) : words?.title;
 	const controls = vacuumControls(state);
-	if (slice !== void 0 && slice.availableFanSpeeds.length > 0) controls.push({
+	const suctionControls = [];
+	if (slice !== void 0 && slice.availableFanSpeeds.length > 0) suctionControls.push({
 		kind: "picker",
 		id: "vacuum.suction",
 		label: t("Suction", "Aspirazione"),
@@ -84138,22 +84797,31 @@ var vacuumContribution = contribution("vacuum-control", VacuumControlStatusSchem
 	});
 	if (state !== null) controls.push(vac("locate", "Locate", "Trova", "map-pin", "locate"));
 	const progress = state === "cleaning" ? slice?.progress ?? null : null;
+	const suction = slice?.fanSpeed == null || slice.fanSpeed === "" ? [] : [{
+		label: t("Suction", "Aspirazione"),
+		value: t(slice.fanSpeed, slice.fanSpeed)
+	}];
+	const suctionRows = suctionControls.length === 0 ? [] : [{
+		id: "vacuum-suction",
+		icon: "bot",
+		status: null,
+		controls: suctionControls
+	}];
+	const vacuumRows = [{
+		id: "vacuum",
+		icon: "bot",
+		status: title ?? unknownText,
+		controls
+	}, ...suctionRows];
 	return {
 		reading: reading("vacuum-control", words?.state ?? "unknown", false, title),
-		rows: [{
-			id: "vacuum",
-			icon: "bot",
-			status: title ?? unknownText,
-			controls
-		}],
-		facts: [...ownBattery(slice?.batteryLevel ?? null, ctx), ...progress === null ? [] : [fact("progress", "activity", pct$1(progress), "primary")]],
-		...progress === null ? {} : {
-			tiles: { right: [{
-				label: t("Progress", "Avanzamento"),
-				value: pct$1(progress)
-			}] },
-			scene: { level: unit(progress) }
-		}
+		rows: vacuumRows,
+		facts: [...ownBattery(slice?.batteryLevel ?? null, ctx), ...progress === null ? [] : [fact("progress", "activity", pct$2(progress), "primary")]],
+		...suction.length === 0 && progress === null ? {} : { tiles: { right: [...suction, ...progress === null ? [] : [{
+			label: t("Progress", "Avanzamento"),
+			value: pct$2(progress)
+		}]] } },
+		...progress === null ? {} : { scene: { level: unit(progress) } }
 	};
 });
 var MOWER_WORDS = {
@@ -84209,11 +84877,11 @@ var mowerContribution = contribution("lawn-mower-control", LawnMowerControlStatu
 			status: title ?? unknownText,
 			controls: mowerControls(activity)
 		}],
-		facts: [...ownBattery(slice?.batteryLevel ?? null, ctx), ...progress === null ? [] : [fact("progress", "activity", pct$1(progress), "primary")]],
+		facts: [...ownBattery(slice?.batteryLevel ?? null, ctx), ...progress === null ? [] : [fact("progress", "activity", pct$2(progress), "primary")]],
 		...progress === null ? {} : {
 			tiles: { right: [{
 				label: t("Progress", "Avanzamento"),
-				value: pct$1(progress)
+				value: pct$2(progress)
 			}] },
 			scene: { level: unit(progress) }
 		}
@@ -84284,10 +84952,13 @@ var feederContribution = contribution("pet-feeder", PetFeederStatusSchema, (slic
 			...last === null ? [] : [fact("last-run", "clock", t(`Last ${last} g`, `Ultimo ${last} g`))],
 			...ownBattery(slice?.powerSource === "battery" ? slice.batteryPower : null, ctx)
 		],
-		...last === null ? {} : { tiles: { right: [{
+		tiles: { left: [...slice?.foodLevel == null ? [] : [{
+			label: t("Tank", "Serbatoio"),
+			value: pct$2(slice.foodLevel)
+		}], ...last === null ? [] : [{
 			label: t("Last portion", "Ultima porzione"),
 			value: t(`${last} g`, `${last} g`)
-		}] } }
+		}]] }
 	};
 });
 var fountainContribution = contribution("pet-fountain", PetFountainStatusSchema, (slice) => {
@@ -84315,10 +84986,13 @@ var fountainContribution = contribution("pet-fountain", PetFountainStatusSchema,
 		}],
 		...level === null ? {} : {
 			facts: [fact("level", "droplets", t(`Water ${Math.round(level)}%`, `Acqua ${Math.round(level)}%`), level <= 20 ? "warning" : "primary")],
-			tiles: { right: [{
+			tiles: { left: [{
 				label: t("Water", "Acqua"),
-				value: pct$1(level)
-			}] },
+				value: pct$2(level)
+			}, ...slice?.waterVolume == null ? [] : [{
+				label: t("Volume", "Volume"),
+				value: t(`${Math.round(slice.waterVolume)} ml`, `${Math.round(slice.waterVolume)} ml`)
+			}]] },
 			scene: { level: unit(level) }
 		}
 	};
@@ -84350,14 +85024,18 @@ var DEVICES_FAMILY_CONTRIBUTIONS = {
 * that does not parse reads `unknown`, never closed or off (D315/D393).
 */
 var has$2 = (ctx, f) => ctx.features.includes(f);
-var pct = (n) => t(`${Math.round(n)}%`, `${Math.round(n)}%`);
+var pct$1 = (n) => t(`${Math.round(n)}%`, `${Math.round(n)}%`);
 var brightnessContribution = contribution("brightness", BrightnessStatusSchema, (slice) => {
 	const level = slice?.level ?? null;
 	return {
 		...level === null ? {} : { reading: reading("brightness", level > 0 ? "on" : "off") },
 		...level === null ? {} : {
-			facts: [fact("level", "sun-dim", pct(level), level > 0 ? "primary" : "muted")],
-			scene: { level: level / 100 }
+			facts: [fact("level", "sun-dim", pct$1(level), level > 0 ? "primary" : "muted")],
+			scene: { level: level / 100 },
+			tiles: { left: [{
+				label: t("Brightness", "Luminosità"),
+				value: pct$1(level)
+			}] }
 		},
 		rows: [row$1("brightness", "sun-dim", level === null ? null : t(`Brightness ${Math.round(level)}%`, `Luminosità ${Math.round(level)}%`), [{
 			kind: "slider",
@@ -84566,12 +85244,16 @@ function travelFragment(s, state, position, tilt, ctx) {
 	});
 	return {
 		reading: reading(s.source, words.state, false, words.title),
-		...position === null ? {} : { facts: [fact("level", "arrow-up-down", pct(position))] },
+		...position === null ? {} : { facts: [fact("level", "arrow-up-down", pct$1(position))] },
+		...position === null ? {} : { tiles: { left: [{
+			label: t("Opening", "Apertura"),
+			value: pct$1(position)
+		}] } },
 		scene: {
 			...words.mode === null ? {} : { mode: words.mode },
 			...position === null ? {} : { level: position / 100 }
 		},
-		rows: [row$1(s.rowId, "arrow-up-down", joinText([words.title, position !== null && state !== "open" ? pct(position) : null]), controls)]
+		rows: [row$1(s.rowId, "arrow-up-down", joinText([words.title, position !== null && state !== "open" ? pct$1(position) : null]), controls)]
 	};
 }
 var ACTUATORS_FAMILY_CONTRIBUTIONS = {
@@ -84649,10 +85331,10 @@ var ACTUATORS_FAMILY_CONTRIBUTIONS = {
 		const now = slice.currentHumidity;
 		return {
 			reading: reading("humidifier", state, false, title),
-			...now === null ? {} : { facts: [fact("level", "droplets", pct(now), "info")] },
+			...now === null ? {} : { facts: [fact("level", "droplets", pct$1(now), "info")] },
 			...slice.targetHumidity === null ? {} : { tiles: { right: [{
 				label: t("Target", "Obiettivo"),
-				value: pct(slice.targetHumidity)
+				value: pct$1(slice.targetHumidity)
 			}] } },
 			...now === null ? {} : { scene: { level: now / 100 } },
 			rows: [row$1("humidifier", "droplets", joinText([title, slice.mode === null ? null : t(slice.mode, slice.mode)]), controls)]
@@ -84900,17 +85582,16 @@ var weatherContribution = contribution("weather", WeatherStatusSchema, (slice, c
 });
 var updateContribution = contribution("update", UpdateStatusSchema, (slice) => {
 	if (slice === void 0) return { reading: reading("update", "unknown") };
-	const { currentVersion, availableVersion, inProgress, updatable } = slice;
+	const { currentVersion, availableVersion, inProgress } = slice;
 	const pending = availableVersion !== null && availableVersion !== "" && availableVersion !== currentVersion;
 	if (!pending && currentVersion === null && !inProgress) return { reading: reading("update", "unknown") };
 	const state = inProgress ? "running" : pending ? "standby" : "idle";
 	const title = inProgress ? t("Updating", "Aggiornamento in corso") : pending ? t("Update available", "Aggiornamento disponibile") : t("Up to date", "Aggiornato");
 	const versions = currentVersion === null ? pending ? t(`${availableVersion}`, `${availableVersion}`) : null : pending ? t(`${currentVersion} → ${availableVersion}`, `${currentVersion} → ${availableVersion}`) : t(`Version ${currentVersion}`, `Versione ${currentVersion}`);
-	const install = pending && updatable && !inProgress ? [asAction(action("update.install", t("Install", "Installa"), "download", "update", "installUpdate", {}, "primary", "install"))] : [];
 	return {
 		reading: reading("update", state, false, title),
 		facts: versions === null ? [] : [fact("reading", "download", versions, pending ? "warning" : "muted")],
-		rows: [row$1("update", "download", versions, install)]
+		rows: [row$1("update", "download", versions, [])]
 	};
 });
 var imageContribution = contribution("image", ImageStatusSchema, (slice, ctx) => {
@@ -85018,6 +85699,33 @@ var ON_MODE_PREFERENCE = [
 	"heat",
 	"cool"
 ];
+var FAN_LABEL = {
+	auto: t("Auto", "Auto"),
+	quiet: t("Quiet", "Silenziosa"),
+	low: t("Low", "Bassa"),
+	medium: t("Medium", "Media"),
+	high: t("High", "Alta"),
+	turbo: t("Turbo", "Turbo"),
+	off: t("Off", "Spenta")
+};
+/** A readable label for a fan speed name; an unknown one is shown as the device reported it. */
+function fanLabelOf(fan) {
+	return FAN_LABEL[fan] ?? t(fan, fan);
+}
+/** Short labels for a segmented control: one word each, so the segments stay on a line. */
+var MODE_SEGMENT_LABEL = {
+	off: t("Off", "Spento"),
+	heat: t("Heat", "Caldo"),
+	cool: t("Cool", "Freddo"),
+	auto: t("Auto", "Auto"),
+	heat_cool: t("Heat/Cool", "Caldo/Freddo"),
+	fan_only: t("Fan", "Vent."),
+	dry: t("Dry", "Deum.")
+};
+/** The segment label of every available HVAC mode, keyed by the mode value. */
+function modeLabelsOf(modes) {
+	return Object.fromEntries(modes.map((m) => [m, MODE_SEGMENT_LABEL[m]]));
+}
 /** 22 -> "22", 22.3 -> "22.3": a trailing zero is noise on a thermostat. */
 function formatDegrees(value) {
 	return `${Number(value.toFixed(1))}°`;
@@ -85082,11 +85790,11 @@ function rangeFrom(min, max, step) {
 * contribute, types never do (D14). A slice that is absent or does not parse is
 * "not answered": the state reads unknown, no row is drawn (D315, D393).
 */
-var same = (text) => t(text, text);
-function tile(en, it, value) {
+var same$1 = (text) => t(text, text);
+function tile$1(en, it, value) {
 	return {
 		label: t(en, it),
-		value: same(value)
+		value: same$1(value)
 	};
 }
 function setpointSlider(id, cap, method, valueArg, value, range) {
@@ -85121,18 +85829,19 @@ var climateContribution = contribution("climate-control", ClimateControlStatusSc
 	const status = climateStatusText(view);
 	const facts = [];
 	if (status !== null) facts.push(fact("climate", "thermometer", status));
-	if (view.humidity !== null) facts.push(fact("humidity", "droplets", same(`${Math.round(view.humidity)}%`)));
-	if (view.targetHumidity !== null) facts.push(fact("humidity", "droplets", same(`→ ${Math.round(view.targetHumidity)}%`)));
+	if (view.humidity !== null) facts.push(fact("humidity", "droplets", same$1(`${Math.round(view.humidity)}%`)));
+	if (view.targetHumidity !== null) facts.push(fact("humidity", "droplets", same$1(`→ ${Math.round(view.targetHumidity)}%`)));
 	const left = [];
 	const right = [];
-	if (view.measured !== null) left.push(tile("Indoor", "In casa", formatDegrees(view.measured)));
-	if (view.humidity !== null) left.push(tile("Humidity", "Umidità", `${Math.round(view.humidity)}%`));
+	if (view.measured !== null) left.push(tile$1("Indoor", "In casa", formatDegrees(view.measured)));
+	if (view.humidity !== null) left.push(tile$1("Humidity", "Umidità", `${Math.round(view.humidity)}%`));
 	const modeControls = [{
 		kind: "picker",
 		id: "climate.mode",
 		label: t("Mode", "Modalità"),
 		current: view.mode,
-		options: [...view.availableModes],
+		options: [...view.availableModes.filter((m) => m !== "off"), ...view.availableModes.filter((m) => m === "off")],
+		optionLabels: modeLabelsOf(view.availableModes),
 		call: {
 			cap: "climate-control",
 			method: "setMode",
@@ -85160,6 +85869,7 @@ var climateContribution = contribution("climate-control", ClimateControlStatusSc
 		label: t("Fan", "Ventola"),
 		current: slice.fanMode === "" ? null : slice.fanMode,
 		options: [...slice.availableFanModes],
+		optionLabels: Object.fromEntries(slice.availableFanModes.map((m) => [m, fanLabelOf(m)])),
 		call: {
 			cap: "climate-control",
 			method: "setFanMode",
@@ -85185,14 +85895,15 @@ var climateContribution = contribution("climate-control", ClimateControlStatusSc
 	if (fanControls.length > 0) rows.push({
 		id: "climate-fan",
 		icon: "fan",
-		status: slice.fanMode === "" ? null : same(slice.fanMode),
+		status: slice.fanMode === "" ? null : same$1(slice.fanMode),
 		controls: fanControls
 	});
-	rows.push(...setpointRow(view.target === null ? null : same(formatDegrees(view.target)), view.range === null || view.target === null ? null : setpointSlider("climate.target", "climate-control", "setTarget", "target", view.target, view.range)));
+	rows.push(...setpointRow(view.target === null ? null : same$1(formatDegrees(view.target)), view.range === null || view.target === null ? null : setpointSlider("climate.target", "climate-control", "setTarget", "target", view.target, view.range)));
 	const sceneMode = view.sceneMode;
 	return {
 		reading: reading("climate-control", view.isOff ? "off" : "on"),
 		title: view.modeLabel,
+		...view.isOff || slice.fanMode === "" ? {} : { caption: t(`${view.modeLabel.en} · fan ${fanLabelOf(slice.fanMode).en}`, `${view.modeLabel.it} · ventola ${fanLabelOf(slice.fanMode).it}`) },
 		facts,
 		...left.length === 0 && right.length === 0 ? {} : { tiles: {
 			left,
@@ -85219,7 +85930,7 @@ var WATER_ON_PREFERENCE = [
 	"performance"
 ];
 function capitalised(word) {
-	return same(word.charAt(0).toUpperCase() + word.slice(1).replace(/_/g, " "));
+	return same$1(word.charAt(0).toUpperCase() + word.slice(1).replace(/_/g, " "));
 }
 var waterHeaterContribution = contribution("water-heater", WaterHeaterStatusSchema, (slice) => {
 	if (slice === void 0 || slice.operationMode === null) return { reading: reading("climate-control", "unknown") };
@@ -85256,13 +85967,13 @@ var waterHeaterContribution = contribution("water-heater", WaterHeaterStatusSche
 		icon: "flame",
 		status: label,
 		controls: modeControls
-	}, ...setpointRow(slice.targetTemp === null ? null : same(formatDegrees(slice.targetTemp)), range === null || slice.targetTemp === null ? null : setpointSlider("water-heater.target", "water-heater", "setTargetTemp", "temp", slice.targetTemp, range))];
+	}, ...setpointRow(slice.targetTemp === null ? null : same$1(formatDegrees(slice.targetTemp)), range === null || slice.targetTemp === null ? null : setpointSlider("water-heater.target", "water-heater", "setTargetTemp", "temp", slice.targetTemp, range))];
 	const level = levelWithin(slice.targetTemp, range);
 	return {
 		reading: reading("climate-control", isOff ? "off" : "on"),
 		title: label,
 		facts: status === null ? [] : [fact("climate", "flame", status)],
-		...slice.currentTemp === null ? {} : { tiles: { left: [tile("Water", "Acqua", formatDegrees(slice.currentTemp))] } },
+		...slice.currentTemp === null ? {} : { tiles: { left: [tile$1("Water", "Acqua", formatDegrees(slice.currentTemp))] } },
 		scene: {
 			...isOff ? {} : { mode: "heat" },
 			...level === null ? {} : { level }
@@ -85280,11 +85991,12 @@ var waterHeaterContribution = contribution("water-heater", WaterHeaterStatusSche
 var heatingValveContribution = contribution("heating-valve", HeatingValveStatusSchema, (slice) => {
 	const position = slice?.position ?? null;
 	if (position === null) return { reading: reading("sensor", "unknown") };
-	const text = same(`${Math.round(position)}%`);
+	const text = same$1(`${Math.round(position)}%`);
 	return {
 		reading: reading("sensor", position > 0 ? "running" : "idle"),
 		facts: [fact("valve", "gauge", t(`Valve ${text.en}`, `Valvola ${text.it}`))],
-		tiles: { right: [tile("Valve", "Valvola", text.en)] },
+		tiles: { right: [tile$1("Valve", "Valvola", text.en)] },
+		...position > 0 ? { caption: t(`Heating · valve ${text.en}`, `Riscalda · valvola ${text.it}`) } : {},
 		scene: { level: position / 100 }
 	};
 });
@@ -85293,9 +86005,9 @@ function sensorFragment(value, id, icon, en, it, text) {
 	if (value === null) return { reading: reading("sensor", "unknown") };
 	return {
 		reading: reading("sensor", "on"),
-		title: same(text),
-		facts: [fact(id, icon, same(text))],
-		tiles: { right: [tile(en, it, text)] }
+		title: same$1(text),
+		facts: [fact(id, icon, same$1(text))],
+		tiles: { right: [tile$1(en, it, text)] }
 	};
 }
 var temperatureContribution = contribution("temperature-sensor", TemperatureSensorStatusSchema, (slice) => sensorFragment(slice?.temperature ?? null, "temperature", "thermometer", "Temperature", "Temperatura", formatDegrees(slice?.temperature ?? 0)));
@@ -85350,8 +86062,8 @@ var CLIMATE_FAMILY_CONTRIBUTIONS = {
 		return {
 			reading: reading("sensor", "on"),
 			...slice.aqi === void 0 ? {} : { title: airQualityWord(slice.aqi) },
-			facts: parts.map((p) => fact("air-quality", "wind", same(`${p.label} ${p.value}`))),
-			tiles: { right: parts.slice(0, 2).map((p) => tile(p.label, p.label, p.value)) }
+			facts: parts.map((p) => fact("air-quality", "wind", same$1(`${p.label} ${p.value}`))),
+			tiles: { right: parts.slice(0, 2).map((p) => tile$1(p.label, p.label, p.value)) }
 		};
 	}),
 	"carbon-monoxide": contribution("carbon-monoxide", CarbonMonoxideStatusSchema, (slice) => {
@@ -85366,15 +86078,264 @@ var CLIMATE_FAMILY_CONTRIBUTIONS = {
 	"numeric-sensor": numericContribution,
 	"enum-sensor": enumContribution
 };
+/**
+* The heat pump's contribution to a hero (D1026): the compressor scene, every
+* circuit as a row with its own label and icon, the powers as pills (the
+* instantaneous COP only when both powers are known) and a "System" group with
+* one selector per mode. Values and their limits come from the slice, which the
+* gateway filled: a selector with no allowed value is not drawn, a missing
+* reading is never a 0 (D393).
+*/
+var CAP = "heat-pump-control";
+var same = (text) => t(text, text);
+/** The words of the values the gateway names; a value not listed is drawn as the gateway wrote it. */
+var VALUE_LABELS = {
+	off: t("Off", "Off"),
+	on: t("On", "On"),
+	auto: t("Auto", "Auto"),
+	manual: t("Manual", "Manuale"),
+	low: t("Low", "Bassa"),
+	high: t("High", "Alta"),
+	eco: t("Eco", "Eco"),
+	heat: t("Heat", "Caldo"),
+	cool: t("Cool", "Freddo"),
+	heatCool: t("Heat/cool", "Caldo/freddo"),
+	ownprogram: t("Programme", "Programma")
+};
+function valueLabel(value) {
+	const known = VALUE_LABELS[value];
+	if (known !== void 0) return known;
+	const holiday = /^hm(\d+)$/.exec(value);
+	if (holiday?.[1] !== void 0) return t(`Programme ${holiday[1]}`, `Programma ${holiday[1]}`);
+	return same(value);
+}
+function optionLabels(allowed) {
+	return Object.fromEntries(allowed.map((value) => [value, valueLabel(value)]));
+}
+function picker(id, label, setting, method, args, valueArg = "mode") {
+	return {
+		kind: "picker",
+		id,
+		label,
+		current: setting.value,
+		options: [...setting.allowed],
+		optionLabels: optionLabels(setting.allowed),
+		call: {
+			cap: CAP,
+			method,
+			args: { ...args }
+		},
+		valueArg
+	};
+}
+/** A selector exists only where the gateway named values to choose from. */
+function choosable(setting) {
+	return setting !== null && setting.allowed.length > 0;
+}
+function circuitControl(circuit) {
+	const args = { circuitId: circuit.id };
+	if (circuit.kind === "dhw" && choosable(circuit.temperatureLevel)) return picker(`heat-pump.${circuit.id}.level`, t("Level", "Livello"), circuit.temperatureLevel, "setDhwTemperatureLevel", args, "level");
+	if (!choosable(circuit.operationMode)) return null;
+	const method = circuit.kind === "dhw" ? "setDhwOperationMode" : "setCircuitOperationMode";
+	return picker(`heat-pump.${circuit.id}.mode`, t("Mode", "Modalità"), circuit.operationMode, method, args);
+}
+/** A circuit with no reading is still a row: it shows that nothing is known, not nothing. */
+var UNKNOWN_STATUS = same("—");
+function circuitRow(circuit) {
+	const control = circuitControl(circuit);
+	const status = thermalStatusText(circuit.targetTemp, circuit.currentTemp) ?? UNKNOWN_STATUS;
+	return {
+		id: "circuit",
+		label: same(circuit.label),
+		icon: circuit.icon,
+		status,
+		controls: control === null ? [] : [control]
+	};
+}
+var kilowatts = (watts) => `${Number((watts / 1e3).toFixed(2))} kW`;
+function powerPills(status) {
+	const { thermalW, electricalW } = status.power;
+	const cop = heatPumpInstantCop(status.power);
+	const pills = [];
+	if (thermalW !== null) pills.push({
+		icon: "flame",
+		text: t(`Thermal ${kilowatts(thermalW)}`, `Termica ${kilowatts(thermalW)}`),
+		tone: "muted"
+	});
+	if (electricalW !== null) pills.push({
+		icon: "zap",
+		text: t(`Electrical ${kilowatts(electricalW)}`, `Elettrica ${kilowatts(electricalW)}`),
+		tone: "muted"
+	});
+	if (cop !== null) {
+		const text = String(Number(cop.toFixed(1)));
+		pills.push({
+			icon: "gauge",
+			text: t(`Instantaneous COP ${text}`, `COP istantaneo ${text}`),
+			tone: "success"
+		});
+	}
+	return pills;
+}
+/** The independent system modes, in the order the card draws them. */
+var SYSTEM_MODES = [
+	{
+		key: "silent",
+		label: t("Silent", "Silenzioso"),
+		icon: "volume-x",
+		method: "setSilentMode"
+	},
+	{
+		key: "away",
+		label: t("Away", "Assente"),
+		icon: "plane",
+		method: "setAwayMode"
+	},
+	{
+		key: "additionalHeater",
+		label: t("Additional heater", "Riscaldatore aggiuntivo"),
+		icon: "flame",
+		method: "setAdditionalHeaterMode"
+	},
+	{
+		key: "holiday",
+		label: t("Holiday", "Vacanza"),
+		icon: "tree-palm",
+		method: "setHolidayMode"
+	}
+];
+var SYSTEM_GROUP = t("System", "Sistema");
+var PROGRAMME = /^hm\d+$/;
+/**
+* Holiday is two segments, off / programme. Choosing "programme" keeps the programme
+* that is set, else the first one the gateway allowed, so a write never leaves
+* `allowed`. The full hm1..hm8 pick is not in the hero (D1026). A holiday whose values
+* are not programmes keeps the plain selector.
+*/
+function holidayRow(def, setting) {
+	if (!setting.allowed.includes("off")) return null;
+	const current = setting.value !== null && PROGRAMME.test(setting.value) ? setting.value : null;
+	const programme = current ?? setting.allowed.find((v) => PROGRAMME.test(v));
+	if (programme === void 0) return null;
+	const control = picker("heat-pump.system.holiday", def.label, {
+		value: setting.value,
+		allowed: ["off", programme]
+	}, def.method, {});
+	const number = programme.slice(2);
+	return {
+		id: "system-mode",
+		label: def.label,
+		group: SYSTEM_GROUP,
+		icon: def.icon,
+		status: current === null ? null : t(`Programme ${number}`, `Programma ${number}`),
+		controls: [control.kind === "picker" ? {
+			...control,
+			optionLabels: {
+				off: t("Off", "Off"),
+				[programme]: t("Programme", "Programma")
+			}
+		} : control]
+	};
+}
+function systemRows(status) {
+	const rows = [];
+	for (const def of SYSTEM_MODES) {
+		const setting = status.system[def.key];
+		if (!choosable(setting)) continue;
+		if (def.key === "holiday") {
+			const holiday = holidayRow(def, setting);
+			if (holiday !== null) {
+				rows.push(holiday);
+				continue;
+			}
+		}
+		rows.push({
+			id: "system-mode",
+			label: def.label,
+			group: SYSTEM_GROUP,
+			icon: def.icon,
+			status: null,
+			controls: [picker(`heat-pump.system.${def.key}`, def.label, setting, def.method, {})]
+		});
+	}
+	return rows;
+}
+function tile(en, it, value) {
+	return {
+		label: t(en, it),
+		value: same(value)
+	};
+}
+function tilesOf$1(status) {
+	const { supply, return: back, outdoor } = status.temperatures;
+	const left = [];
+	const right = [];
+	if (supply !== null) left.push(tile("Supply", "Mandata", formatDegrees(supply)));
+	if (back !== null) left.push(tile("Return", "Ritorno", formatDegrees(back)));
+	if (outdoor !== null) right.push(tile("Outdoor", "Esterna", formatDegrees(outdoor)));
+	if (status.waterPressureBar !== null) right.push(tile("Pressure", "Pressione", `${Number(status.waterPressureBar.toFixed(1))} bar`));
+	return {
+		left,
+		right
+	};
+}
+function isRunning(status) {
+	const { compressorPct, electricalW } = status.power;
+	if (compressorPct !== null) return compressorPct > 0;
+	if (electricalW !== null) return electricalW > 0;
+	return null;
+}
+var HEAT_PUMP_FAMILY_CONTRIBUTIONS = { "heat-pump-status": contribution("heat-pump-status", HeatPumpStatusSchema, (slice) => {
+	if (slice === void 0) return { reading: reading("climate-control", "unknown") };
+	const running = isRunning(slice);
+	const facts = [];
+	if (slice.power.electricalW !== null) facts.push(fact("power", "zap", same(`${Math.round(slice.power.electricalW)} W`)));
+	if (slice.power.compressorPct !== null) facts.push(fact("level", "gauge", t(`Compressor ${Math.round(slice.power.compressorPct)} %`, `Compressore ${Math.round(slice.power.compressorPct)} %`)));
+	const charging = slice.circuits.find((c) => c.active === true);
+	const tiles = tilesOf$1(slice);
+	const pills = powerPills(slice);
+	const rows = [
+		...slice.circuits.map(circuitRow),
+		...pills.length === 0 ? [] : [{
+			id: "heat-pump-power",
+			icon: "zap",
+			status: null,
+			controls: [],
+			pills: [...pills]
+		}],
+		...systemRows(slice)
+	];
+	return {
+		reading: reading("climate-control", running === true ? "running" : running === false ? "idle" : "on"),
+		title: t("Heat pump", "Pompa di calore"),
+		...charging === void 0 ? {} : { caption: t(`${charging.label} · heating`.toUpperCase(), `${charging.label} · in riscaldamento`.toUpperCase()) },
+		facts,
+		...tiles.left.length === 0 && tiles.right.length === 0 ? {} : { tiles },
+		...slice.power.electricalW === null ? {} : { consumption: {
+			priority: 1,
+			slot: {
+				kind: "power",
+				watts: slice.power.electricalW,
+				detail: slice.power.thermalW === null ? [] : [{
+					label: t("Thermal", "Termica"),
+					value: Math.round(slice.power.thermalW),
+					unit: "W"
+				}]
+			}
+		} },
+		rows
+	};
+}) };
 [
 	...Object.values(ACCESS_FAMILY_CONTRIBUTIONS),
 	...Object.values(DEVICES_FAMILY_CONTRIBUTIONS),
 	...Object.values(GROUPS_FAMILY_CONTRIBUTIONS),
 	...Object.values(ACTUATORS_FAMILY_CONTRIBUTIONS),
 	...Object.values(SENSORS_FAMILY_CONTRIBUTIONS),
-	...Object.values(CLIMATE_FAMILY_CONTRIBUTIONS)
+	...Object.values(CLIMATE_FAMILY_CONTRIBUTIONS),
+	...Object.values(HEAT_PUMP_FAMILY_CONTRIBUTIONS)
 ];
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
 /**
 * Who looks like what (D1023). One look per {@link DeviceType}, refined by a
 * {@link DeviceRole} where the role changes how the device reads (a leak
@@ -85764,7 +86725,7 @@ lookOf({
 ({ ...lookOf({
 	icon: "shield-check",
 	on: [
-		"success",
+		"danger",
 		"glow",
 		"halo"
 	],
@@ -86002,8 +86963,24 @@ lookOf({
 	idle: INFO,
 	standby: MUTED
 });
+lookOf({
+	icon: "thermometer-sun",
+	on: [
+		"warning",
+		"heat-rise",
+		"rise"
+	],
+	off: MUTED,
+	running: [
+		"warning",
+		"heat-rise",
+		"rise"
+	],
+	idle: INFO,
+	standby: MUTED
+});
 DeviceType.Climate, DeviceType.Thermostat;
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway;
 DeviceRole.Siren, DeviceRole.Floodlight, DeviceRole.Spotlight, DeviceRole.PirSensor, DeviceRole.Chime, DeviceRole.Autotrack, DeviceRole.Nightvision, DeviceRole.PrivacyMask, DeviceRole.Doorbell, DeviceRole.CoverBlind, DeviceRole.CoverShutter, DeviceRole.CoverAwning, DeviceRole.CoverCurtain, DeviceRole.CoverGarage, DeviceRole.CoverGate, DeviceRole.CoverDoor, DeviceRole.CoverWindow, DeviceRole.BinaryHelper, DeviceRole.Outlet, DeviceRole.MotionSensor, DeviceRole.ContactSensor, DeviceRole.LeakSensor, DeviceRole.SmokeSensor, DeviceRole.COSensor, DeviceRole.GasSensor, DeviceRole.TamperSensor, DeviceRole.VibrationSensor, DeviceRole.ConnectivitySensor, DeviceRole.SoundSensor, DeviceRole.BinarySensor, DeviceRole.TemperatureSensor, DeviceRole.HumiditySensor, DeviceRole.AmbientLightSensor, DeviceRole.PressureSensor, DeviceRole.WindSensor, DeviceRole.RainSensor, DeviceRole.UvSensor, DeviceRole.SolarRadiationSensor, DeviceRole.SoilMoistureSensor, DeviceRole.PowerSensor, DeviceRole.EnergySensor, DeviceRole.VoltageSensor, DeviceRole.CurrentSensor, DeviceRole.AirQualitySensor, DeviceRole.BatterySensor, DeviceRole.NumericSensor, DeviceRole.EnumSensor, DeviceRole.DateTimeSensor, DeviceRole.GenericSensor, DeviceRole.NumericControl, DeviceRole.SelectControl, DeviceRole.TextControl, DeviceRole.DateTimeControl, DeviceRole.MobilePushNotifier, DeviceRole.MessagingNotifier, DeviceRole.EmailNotifier, DeviceRole.GenericNotifier, DeviceRole.IrTransmitter;
 Object.freeze({
 	"accessories.getStatus": {
@@ -86384,13 +87361,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"addonSettings.getIntegrationFormSchema": {
-		capName: "addon-settings",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"addonSettings.getScopedSettings": {
 		capName: "addon-settings",
 		capScope: "system",
@@ -88176,6 +89146,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.checkDeviceTemplates": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceManager.cleanupDeletedDevicesData": {
 		capName: "device-manager",
 		capScope: "system",
@@ -88575,6 +89552,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.renderDeviceTemplates": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceManager.reportDiscoveryObservations": {
 		capName: "device-manager",
 		capScope: "system",
@@ -89506,6 +90490,111 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"heatPumpControl.setAdditionalHeaterMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setAwayMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitComfortSetpoint": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitEcoSetpoint": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitHeatCoolMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitMaxFlowTemp": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitOperationMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setCircuitSummerWinter": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setDhwChargeDuration": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setDhwOperationMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setDhwTemperatureLevel": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setHolidayMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.setSilentMode": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpControl.startExtraHotWater": {
+		capName: "heat-pump-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"heatPumpStatus.getStatus": {
+		capName: "heat-pump-status",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"heroLayout.getHeroModel": {
 		capName: "hero-layout",
 		capScope: "system",
@@ -94413,13 +95502,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"smtpProvider.verify": {
-		capName: "smtp-provider",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"snapshot.applyDeviceSettingsPatch": {
 		capName: "snapshot",
 		capScope: "device",
@@ -96352,7 +97434,7 @@ function projectAction(cap, action) {
 	};
 }
 Object.entries(CAP_VOCABULARY_BY_NAME).flatMap(([cap, entry]) => entry.scope === "device" ? (entry.actions ?? []).map((a) => projectAction(cap, a)) : []);
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Heater, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Heater, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
 DeviceFeature.BatteryOperated;
 DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
 var HA_AS = "a power sensor (device_class power). Home Assistant has no laundry domain. running-state stays unexported until a null reading can be published as unavailable.";
@@ -96393,7 +97475,6 @@ function offered(received) {
 	};
 }
 offered(HA_AS), withheld(HOMEKIT_REASON), withheld(ALEXA_REASON), withheld(GOOGLE_REASON), withheld(MATTER_REASON);
-string().min(1).max(4096);
 Object.freeze({
 	"accessories.getStatus": [{
 		name: "deviceId",
@@ -97476,6 +98557,81 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"heatPumpControl.setAdditionalHeaterMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setAwayMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitComfortSetpoint": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitEcoSetpoint": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitHeatCoolMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitMaxFlowTemp": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitOperationMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setCircuitSummerWinter": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setDhwChargeDuration": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setDhwOperationMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setDhwTemperatureLevel": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setHolidayMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.setSilentMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpControl.startExtraHotWater": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"heatPumpStatus.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"heroLayout.getHeroModel": [{
 		name: "deviceId",
 		form: "single",
@@ -100961,4 +102117,4 @@ function keepBodyKeys(provider, keys) {
 	};
 }
 //#endregion
-export { customAction as A, number$1 as B, runningFromDishwasherOperation as C, waterHeaterCapability as D, temperatureSensorCapability as E, isSecretMarkerLike as F, unknown as G, record as H, rowsDepsOver as I, errMsg as J, DeviceRole as K, _enum as L, defineEntryKind as M, entryBody as N, RecordIntegrationInstances as O, isSecretMarker as P, array as R, quantityFromUnit as S, switchCapability as T, string as U, object as V, union as W, EventCategory as Y, heatingValveCapability as _, BaseDevice as a, numericSensorCapability as b, RUNNING_STATE_COLD as c, climateControlCapability as d, consumablesCapability as f, eventEmitterCapability as g, enumSensorCapability as h, testBoschInstance as i, defineCustomActions as j, createEvent as k, batteryCapability as l, dishwasherCapability as m, boschRowsPorts as n, BaseDeviceProvider as o, deviceAdoptionCapability as p, DeviceType as q, keepBodyKeys as r, DishwasherOperationStateSchema as s, boschRowsMigration as t, binaryCapability as u, ingestReading as v, runningStateCapability as w, powerMeterCapability as x, integrationInstancesCapability as y, literal as z };
+export { RecordIntegrationInstances as A, array as B, powerMeterCapability as C, switchCapability as D, runningStateCapability as E, entryBody as F, string as G, number$1 as H, isSecretMarker as I, DeviceRole as J, union as K, isSecretMarkerLike as L, customAction as M, defineCustomActions as N, temperatureSensorCapability as O, defineEntryKind as P, rowsDepsOver as R, numericSensorCapability as S, runningFromDishwasherOperation as T, object as U, literal as V, record as W, errMsg as X, DeviceType as Y, EventCategory as Z, heatPumpControlCapability as _, BaseDevice as a, ingestReading as b, RUNNING_STATE_COLD as c, climateControlCapability as d, consumablesCapability as f, eventEmitterCapability as g, enumSensorCapability as h, testBoschInstance as i, createEvent as j, waterHeaterCapability as k, batteryCapability as l, dishwasherCapability as m, boschRowsPorts as n, BaseDeviceProvider as o, deviceAdoptionCapability as p, unknown as q, keepBodyKeys as r, DishwasherOperationStateSchema as s, boschRowsMigration as t, binaryCapability as u, heatPumpStatusCapability as v, quantityFromUnit as w, integrationInstancesCapability as x, heatingValveCapability as y, _enum as z };