@camstack/addon-provider-enpal 0.1.15 → 0.1.17

package/dist/addon.js

@@ -1,4 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_url = require("node:url");
 //#region ../types/dist/event-category-78tcBemo.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -802,7 +806,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/composed-stable-id-jnvhwGoH.mjs
+//#region ../types/dist/composed-stable-id-CPp3votu.mjs
 /**
 import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
@@ -815,17 +819,18 @@ function errMsg(err) {
 }
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
+	/** Legacy stored value, read only by the hub-to-integration migrations; no live device carries it. */
 	DeviceType["Hub"] = "hub";
 	DeviceType["Light"] = "light";
 	DeviceType["Siren"] = "siren";
 	DeviceType["Switch"] = "switch";
 	DeviceType["Sensor"] = "sensor";
-	DeviceType["Thermostat"] = "thermostat";
-	/** Air-conditioner / heat-pump climate device (HVAC) — shares the
-	*  `climate-control` cap surface with `Thermostat` but renders a
-	*  dedicated AC-appropriate control UI (mode chips, fan speed,
-	*  independent vertical/horizontal swing). Sources: native Gree, and
-	*  reusable by other AC integrations. */
+	/** Every climate device: an air conditioner, a room thermostat, a radiator
+	*  valve, a floor-heating zone, a heat-pump circuit. They share one set of
+	*  controls (`climate-control`), so they are one type; WHICH kind of climate
+	*  device it is is its {@link DeviceRole} (`climate-*`), which the UI and the
+	*  exports branch on. The retired `thermostat` type is read as this one
+	*  (`canonicalStoredDeviceType`). */
 	DeviceType["Climate"] = "climate";
 	DeviceType["Button"] = "button";
 	/** Generic stateless event emitter — carries a device's EXACT declared
@@ -916,10 +921,6 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	/** Washing machine. A plug-built one is running while its power stays
 	*  above a threshold. No program cap — that surface is the dishwasher's. */
 	DeviceType["Washer"] = "washer";
-	/** A dumb plug-in stove or heater: a switch (and, with a meter, a power
-	*  reading) that only runs while the plug is on. Built from a smart plug;
-	*  the `timed-run` cap switches it off again after a chosen time. */
-	DeviceType["Heater"] = "heater";
 	/** Tumble dryer. Same plug-built running surface as {@link Washer}. */
 	DeviceType["Dryer"] = "dryer";
 	/** The physical bridge box of a vendor ecosystem (Velux KLF-200, and later
@@ -1139,6 +1140,27 @@ var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
 	/** A smart plug: a `switch` whose source says it is an outlet (HA
 	*  `device_class: outlet`). The Alexa export shows it as a SMARTPLUG. */
 	DeviceRole["Outlet"] = "outlet";
+	/** A dumb plug-in stove or heater behind a switch: it runs only while the
+	*  switch is on. Offered `timed-run`, which switches it off again after a
+	*  chosen time. */
+	DeviceRole["SwitchHeater"] = "switch-heater";
+	/** A plain fan behind a switch (a smart plug powering it): drawn as a fan,
+	*  with the switch's on/off only. Speed or oscillation appear only when the
+	*  device also has a fan cap (D1033). */
+	DeviceRole["SwitchFan"] = "switch-fan";
+	/** Air conditioner / split unit: cooling, fan speed, louvres. */
+	DeviceRole["ClimateAc"] = "climate-ac";
+	/** Room thermostat: a setpoint and a room temperature. The default. */
+	DeviceRole["ClimateThermostat"] = "climate-thermostat";
+	/** Floor-heating zone actuator. */
+	DeviceRole["ClimateFloor"] = "climate-floor";
+	/** Radiator valve (thermostatic radiator head). */
+	DeviceRole["ClimateRadiator"] = "climate-radiator";
+	/** A heater with its own thermostat (stove, convector). */
+	DeviceRole["ClimateHeater"] = "climate-heater";
+	/** One heating/cooling circuit of a heat pump: a water loop with comfort /
+	*  eco setpoints and a heat/cool mode, no room sensor. */
+	DeviceRole["ClimateHeatPumpCircuit"] = "climate-heat-pump-circuit";
 	/** Generic motion / occupancy / moving event source. Distinct from
 	*  the camera accessory PirSensor role: that one is a camera child;
 	*  this is a standalone HA / 3rd-party motion sensor. */
@@ -6026,7 +6048,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-Dz1P6--1.mjs
+//#region ../types/dist/sleep-D0roI_CZ.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -11803,6 +11825,50 @@ var ACTUATOR_CAP_VOCABULARY = {
 					value: false
 				},
 				args: { oscillating: false }
+			},
+			{
+				id: "fan.horizontalOscillateOn",
+				method: "setOscillationAxis",
+				label: t("Horizontal oscillation on", "Oscillazione orizzontale attiva"),
+				phrase: t("Start the horizontal oscillation of {device}", "Attiva l’oscillazione orizzontale di {device}"),
+				icon: "move-horizontal",
+				args: {
+					axis: "horizontal",
+					oscillating: true
+				}
+			},
+			{
+				id: "fan.horizontalOscillateOff",
+				method: "setOscillationAxis",
+				label: t("Horizontal oscillation off", "Oscillazione orizzontale spenta"),
+				phrase: t("Stop the horizontal oscillation of {device}", "Ferma l’oscillazione orizzontale di {device}"),
+				icon: "move-horizontal",
+				args: {
+					axis: "horizontal",
+					oscillating: false
+				}
+			},
+			{
+				id: "fan.verticalOscillateOn",
+				method: "setOscillationAxis",
+				label: t("Vertical oscillation on", "Oscillazione verticale attiva"),
+				phrase: t("Start the vertical oscillation of {device}", "Attiva l’oscillazione verticale di {device}"),
+				icon: "move-vertical",
+				args: {
+					axis: "vertical",
+					oscillating: true
+				}
+			},
+			{
+				id: "fan.verticalOscillateOff",
+				method: "setOscillationAxis",
+				label: t("Vertical oscillation off", "Oscillazione verticale spenta"),
+				phrase: t("Stop the vertical oscillation of {device}", "Ferma l’oscillazione verticale di {device}"),
+				icon: "move-vertical",
+				args: {
+					axis: "vertical",
+					oscillating: false
+				}
 			}
 		],
 		state: [{
@@ -13892,10 +13958,6 @@ var CAMERA_CAP_VOCABULARY = {
 		scope: "device",
 		noun: t("Admin link", "Link di amministrazione")
 	},
-	"device-discovery": {
-		scope: "device",
-		noun: t("Discovery", "Rilevamento dispositivi")
-	},
 	"device-extension": {
 		scope: "device",
 		noun: t("Device extension", "Estensione del dispositivo")
@@ -15067,6 +15129,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	backup: system("system backups — run and restored from the Backups page"),
 	broker: system("message-broker connections — configured, not actuated"),
 	"calendar-source": system(INTERNAL),
+	"cluster-update": system(CLUSTER),
 	calendars: system("calendars feed schedules and conditions, not device actions"),
 	composer: system("device composition — an authoring tool, not an action"),
 	"core-blocks": system(INTERNAL),
@@ -15334,6 +15397,7 @@ var CAP_NAMES = Object.freeze([
 	"camera-streams",
 	"carbon-monoxide",
 	"climate-control",
+	"cluster-update",
 	"color",
 	"composer",
 	"connectivity",
@@ -15351,7 +15415,6 @@ var CAP_NAMES = Object.freeze([
 	"device-admin-link",
 	"device-adoption",
 	"device-credentials",
-	"device-discovery",
 	"device-export",
 	"device-extension",
 	"device-history",
@@ -15973,13 +16036,6 @@ Object.freeze({
 			"valueType": "string"
 		}
 	],
-	"device-discovery": [{
-		"path": "lastDiscoveryAt",
-		"valueType": "number"
-	}, {
-		"path": "lastError",
-		"valueType": "string"
-	}],
 	"device-export": [
 		{
 			"path": "linkState",
@@ -16168,6 +16224,10 @@ Object.freeze({
 			"path": "lastEvent.eventType",
 			"valueType": "string"
 		},
+		{
+			"path": "lastEvent.sourceId",
+			"valueType": "string"
+		},
 		{
 			"path": "lastEvent.timestamp",
 			"valueType": "number"
@@ -17431,7 +17491,7 @@ Object.freeze({
 	}
 });
 //#endregion
-//#region ../types/dist/implemented-methods-OitwyO1Y.mjs
+//#region ../types/dist/implemented-methods-5YMDeE3f.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -44092,6 +44152,41 @@ function macroOnly(macro) {
 		};
 	}
 }
+var EventVocabularyKindSchema = _enum([
+	"press",
+	"long-press",
+	"long-press-start",
+	"release",
+	"repeat",
+	"double-press",
+	"other"
+]);
+/** The part of the device an event comes from: a button, a channel. */
+var EventVocabularySourceSchema = object({
+	id: string().min(1),
+	label: string().min(1)
+});
+/** One scalar field of an event's `data`, by dotted path. */
+var EventVocabularyFieldSchema = object({
+	path: string().min(1),
+	kind: _enum([
+		"string",
+		"number",
+		"boolean",
+		"enum"
+	]),
+	enumValues: array(string()).optional(),
+	label: string().min(1).optional()
+});
+var EventVocabularyEntrySchema = object({
+	/** The native token, verbatim. */
+	id: string().min(1),
+	source: EventVocabularySourceSchema.optional(),
+	label: string().min(1),
+	description: string().optional(),
+	kind: EventVocabularyKindSchema.optional(),
+	payload: array(EventVocabularyFieldSchema).optional()
+});
 Math.PI / 180;
 /**
 * WHEN something happens, as data (D983) — the one time vocabulary of the
@@ -44144,6 +44239,62 @@ var WeekdayKeySchema = _enum([
 	"sat",
 	"sun"
 ]);
+/**
+* Hold semantics — "for N seconds" on a leaf of the `when` tree (#498).
+*
+* ONE primitive, `for: { ms, mode, tolerance? }`, shared by `device-becomes`,
+* `device-is` and `expression`:
+*
+*  - `held`: the condition stays true for `ms`;
+*  - `stable`: the value does not move by more than `tolerance` (absolute, in
+*    the field's base unit) for `ms` while the condition holds.
+*
+* {@link HoldCore} is the pure state machine (an input observation → a reading).
+* {@link HoldTracker} keys cores by a leaf path for the STATE leaves the tree
+* evaluator judges. {@link BecomesWatch} wraps a core with a timer for the
+* `device-becomes` EVENT leaf: the deadline is armed when the hold starts and
+* cancelled when it breaks, and the leaf fires ONCE per episode.
+*
+* Hold state is memory only. A hold that is already running when the watcher
+* first looks (a restart) is INHERITED: nobody knows when it began, so it never
+* fires for that episode and a state leaf reads it as unknown until the window
+* has elapsed from the moment the watcher started (D49: not-known is not false).
+*/
+var HOLD_MAX_MS = 864e5;
+var HoldModeSchema = _enum(["held", "stable"]);
+var HoldSpecSchema = object({
+	/** How long the condition (or the value) must hold. */
+	ms: number$1().int().min(1).max(HOLD_MAX_MS),
+	mode: HoldModeSchema,
+	/** `stable` only: the largest move of the value that still counts as unchanged (absolute, base unit). */
+	tolerance: number$1().min(0).optional()
+});
+/** What a trace says about a hold. */
+var HoldTraceSchema = object({
+	phase: _enum([
+		"pending",
+		"cancelled",
+		"fired",
+		"reseeded"
+	]),
+	ms: number$1().int(),
+	mode: HoldModeSchema,
+	/** When the hold started (ms epoch). */
+	since: number$1().optional(),
+	/** When it completes (ms epoch), for a pending hold. */
+	deadline: number$1().optional()
+});
+/** The operators a `device-becomes` leaf may carry: a threshold or a range. */
+var BecomesOperatorSchema = _enum([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"between",
+	"outside"
+]);
 /** How a state leaf compares a device field to a value. Derived from the
 *  field's `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
 var AutomationConditionOperatorSchema = _enum([
@@ -44157,6 +44308,13 @@ var AutomationConditionOperatorSchema = _enum([
 	"in"
 ]);
 /**
+* The stable name of an event leaf. A path (`when.0.1`) moves when a row is
+* reordered; the id does not, so a `triggered-by` leaf keeps pointing at the
+* same row. Optional: a leaf nothing refers to needs none.
+*/
+var EVENT_LEAF_ID_RE = /^[A-Za-z0-9_-]{1,40}$/;
+var eventLeafId = { id: string().regex(EVENT_LEAF_ID_RE).optional() };
+/**
 * D8 compliance, and it is the reason a "becomes" leaf is not merely an event
 * subscription: it evaluates against the **state mirror**, which is reconciled,
 * and an event only WAKES the evaluation. A dropped event therefore DELAYS a
@@ -44164,24 +44322,60 @@ var AutomationConditionOperatorSchema = _enum([
 */
 var DeviceBecomesLeafSchema = object({
 	kind: literal("device-becomes"),
+	...eventLeafId,
 	deviceId: number$1().int().nonnegative(),
 	cap: string().min(1),
 	fieldPath: string().min(1),
-	/** Fire when the field takes this value. Omit to fire on any change. */
+	/** Fire when the field takes this value. Omit (with no `operator`) to fire on any change. */
 	becomes: union([
 		string(),
 		number$1(),
 		boolean()
 	]).optional(),
-	/** Only on a CHANGE of value, not on every re-report. */
+	/**
+	* A threshold or a range instead of an equality: "crosses above 3000", "enters
+	* 18..24". The leaf fires on the TRANSITION into the predicate, never on a re-report.
+	* `value` is in the field's base unit; `between` / `outside` take `[low, high]`.
+	*/
+	operator: BecomesOperatorSchema.optional(),
+	value: union([
+		number$1(),
+		string(),
+		boolean(),
+		array(number$1()).length(2)
+	]).optional(),
+	/**
+	* Hold: the transition (or, with no predicate, the new value) must stay for
+	* `for.ms` before the leaf fires, ONCE per episode. See `hold.ts`.
+	*/
+	for: HoldSpecSchema.optional(),
+	/** @deprecated every leaf fires on a transition now; read as always on. */
 	edge: boolean().optional(),
-	/** The new value must hold this long before it counts. */
-	forMs: number$1().int().min(0).max(864e5).optional(),
+	/** @deprecated legacy `held` window — read through `holdOf` as `for: { ms, mode: 'held' }`. */
+	forMs: number$1().int().min(0).max(HOLD_MAX_MS).optional(),
 	/** Collapse a burst into one occurrence. */
 	debounceMs: number$1().int().min(0).max(6e5).optional()
+}).superRefine((leaf, ctx) => {
+	if (leaf.becomes !== void 0 && leaf.operator !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "a leaf names `becomes` or `operator`, not both",
+		path: ["operator"]
+	});
+	if (leaf.operator !== void 0 && leaf.value === void 0) ctx.addIssue({
+		code: "custom",
+		message: "an operator needs the value to compare to",
+		path: ["value"]
+	});
+	const range = leaf.operator === "between" || leaf.operator === "outside";
+	if (leaf.operator !== void 0 && range !== Array.isArray(leaf.value)) ctx.addIssue({
+		code: "custom",
+		message: range ? "a range takes [low, high]" : "only a range takes [low, high]",
+		path: ["value"]
+	});
 });
 var DeviceEventLeafSchema = object({
 	kind: literal("device-event"),
+	...eventLeafId,
 	/** An `EventCategory` value. */
 	category: string().min(1),
 	deviceId: number$1().int().nonnegative().optional()
@@ -44194,18 +44388,51 @@ var DeviceEventLeafSchema = object({
 */
 var ScheduleLeafSchema = object({
 	kind: literal("schedule"),
+	...eventLeafId,
 	at: TimeSpecSchema.optional(),
 	days: array(WeekdayKeySchema).min(1).max(7).optional(),
 	/** @deprecated legacy cron — new schedules use `at`. */
 	cron: string().min(1).max(120).optional()
 }).refine((leaf) => leaf.at === void 0 !== (leaf.cron === void 0), { message: "a schedule names exactly one of `at` (a time spec) and `cron` (legacy)" }).refine((leaf) => leaf.days === void 0 || leaf.at !== void 0, { message: "`days` goes with `at`; a cron expression carries its own days" });
-var ManualLeafSchema = object({ kind: literal("manual") });
+/**
+* One payload predicate of a `device-fired` row: the value at `path` inside
+* the fire's `data` (dotted) equals `equals`. Compared strictly, no coercion.
+*/
+var DeviceFiredMatchSchema = object({
+	path: string().min(1).max(120),
+	equals: union([
+		string(),
+		number$1(),
+		boolean()
+	])
+});
+/**
+* "fires": one device of the `event-emitter` capability reported an event
+* (D1045). Every list is an OR, the lists together an AND; an absent list does
+* not narrow. `eventIds` are the device's own tokens, `sourceIds` the parts of
+* the device (a button), `kinds` the shared press kinds of its vocabulary.
+*/
+var DeviceFiredLeafSchema = object({
+	kind: literal("device-fired"),
+	...eventLeafId,
+	deviceId: number$1().int().nonnegative(),
+	eventIds: array(string().min(1)).min(1).max(64).optional(),
+	sourceIds: array(string().min(1)).min(1).max(64).optional(),
+	kinds: array(EventVocabularyKindSchema).min(1).optional(),
+	match: array(DeviceFiredMatchSchema).min(1).max(8).optional()
+});
+var ManualLeafSchema = object({
+	kind: literal("manual"),
+	...eventLeafId
+});
 var IntervalLeafSchema = object({
 	kind: literal("interval"),
+	...eventLeafId,
 	minutes: number$1().int().min(1).max(1440)
 });
 var DetectionLeafSchema = object({
 	kind: literal("detection"),
+	...eventLeafId,
 	/** One macro class each, optionally narrowed by a label; a track of any listed subject fires. */
 	subjects: array(DetectionSubjectSchema).min(1),
 	deviceIds: array(number$1().int().nonnegative()).min(1),
@@ -44216,6 +44443,7 @@ var DetectionLeafSchema = object({
 });
 var StationaryLeafSchema = object({
 	kind: literal("stationary"),
+	...eventLeafId,
 	deviceIds: array(number$1().int().nonnegative()).min(1),
 	subjects: array(StationarySubjectSchema).min(1).optional(),
 	zones: array(string().min(1)).min(1).optional(),
@@ -44243,7 +44471,9 @@ var DeviceIsLeafSchema = object({
 		QuantityValueSchema
 	]),
 	/** The unit the person picked for `value` (display only; `value` is in the base unit). */
-	unit: string().min(1).optional()
+	unit: string().min(1).optional(),
+	/** The comparison must hold (`held`) or the value stay put (`stable`) this long. */
+	for: HoldSpecSchema.optional()
 });
 /**
 * True when the camera currently has a PARKED object matching `subjects` in at
@@ -44259,6 +44489,41 @@ var StationaryPresentLeafSchema = object({
 	minCount: number$1().int().positive().optional()
 });
 /**
+* True while the site-local clock is inside a daily window and/or on one of
+* the named days. `days` names the local day a window STARTS on, so
+* 22:00-06:00 on weekdays is still inside at 01:00 Saturday. A one-date spec
+* (`kind: 'date'`) is refused: only a clock time or a sun event makes a window
+* that repeats every day.
+*/
+var TimeIsLeafSchema = object({
+	kind: literal("time-is"),
+	between: object({
+		from: TimeSpecSchema,
+		to: TimeSpecSchema
+	}).optional(),
+	days: array(WeekdayKeySchema).min(1).max(7).optional()
+}).superRefine((leaf, ctx) => {
+	if (leaf.between === void 0 && leaf.days === void 0) ctx.addIssue({
+		code: "custom",
+		message: "a time-is leaf needs a between window, days, or both"
+	});
+	for (const end of ["from", "to"]) if (leaf.between?.[end].kind === "date") ctx.addIssue({
+		code: "custom",
+		message: "a one-date time cannot bound a daily window: use a clock time or a sun event",
+		path: ["between", end]
+	});
+});
+/**
+* True for the run that one of the named event leaves started. It reads the
+* run, not a device: in the tree it is judged against the leaf that fired, in
+* a step guard against the trigger the run carries. A run no event leaf
+* started (a state-only tree becoming true) is false.
+*/
+var TriggeredByLeafSchema = object({
+	kind: literal("triggered-by"),
+	leafIds: array(string().regex(EVENT_LEAF_ID_RE)).min(1).max(20)
+});
+/**
 * The escape hatch: the bounded expression engine over named device bindings.
 * Declared as a plain object so a discriminated union can read `kind`; the
 * author-time validation is the SAME function `ExpressionSourceSchema` runs.
@@ -44266,7 +44531,9 @@ var StationaryPresentLeafSchema = object({
 var ExpressionLeafSchema = object({
 	kind: literal("expression"),
 	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
-	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema),
+	/** The expression must stay true this long. An expression has no single value, so only `held`. */
+	for: HoldSpecSchema.optional()
 }).superRefine((src, ctx) => {
 	const err = validateExpressionSource(src);
 	if (err !== null) ctx.addIssue({
@@ -44274,6 +44541,11 @@ var ExpressionLeafSchema = object({
 		message: err,
 		path: ["expr"]
 	});
+	if (src.for?.mode === "stable") ctx.addIssue({
+		code: "custom",
+		message: "an expression is held, not stable: it has no single value to keep still",
+		path: ["for", "mode"]
+	});
 });
 var AutomationWhenSchema = lazy(() => discriminatedUnion("kind", [
 	object({
@@ -44290,6 +44562,7 @@ var AutomationWhenSchema = lazy(() => discriminatedUnion("kind", [
 	}),
 	DeviceBecomesLeafSchema,
 	DeviceEventLeafSchema,
+	DeviceFiredLeafSchema,
 	ScheduleLeafSchema,
 	ManualLeafSchema,
 	IntervalLeafSchema,
@@ -44297,11 +44570,14 @@ var AutomationWhenSchema = lazy(() => discriminatedUnion("kind", [
 	StationaryLeafSchema,
 	DeviceIsLeafSchema,
 	StationaryPresentLeafSchema,
-	ExpressionLeafSchema
+	ExpressionLeafSchema,
+	TimeIsLeafSchema,
+	TriggeredByLeafSchema
 ]));
 var EVENT_KINDS = new Set([
 	"device-becomes",
 	"device-event",
+	"device-fired",
 	"schedule",
 	"manual",
 	"interval",
@@ -44351,6 +44627,28 @@ function hasEventLeaves(node) {
 	});
 	return found;
 }
+/** The event leaves of the tree that carry an id, in tree order. */
+function identifiedEventLeaves(when) {
+	const found = [];
+	forEachLeaf(when, (leaf, path) => {
+		if (isEventLeaf(leaf) && leaf.id !== void 0) found.push({
+			id: leaf.id,
+			path,
+			leaf
+		});
+	});
+	return found;
+}
+/** Does the tree hold a `triggered-by` leaf? */
+function hasTriggeredByLeaves(when) {
+	let found = false;
+	forEachLeaf(when, (leaf) => {
+		if (leaf.kind === "triggered-by") found = true;
+	});
+	return found;
+}
+/** Why a `triggered-by` leaf is refused outside an automation: there is no trigger row to name. */
+var TRIGGERED_BY_NEEDS_AUTOMATION = "\"triggered by\" reads which trigger started an automation — an action or a scheduler has no trigger rows, so it could never be true here";
 function hasEmptyContainer(node) {
 	if (isLeaf(node)) return false;
 	if (node.kind === "not") return hasEmptyContainer(node.child);
@@ -44360,6 +44658,7 @@ function hasEmptyContainer(node) {
 var LEAF_WORDS = {
 	"device-becomes": "a device value that becomes",
 	"device-event": "a device event",
+	"device-fired": "a device firing an event",
 	schedule: "a schedule",
 	manual: "a manual run",
 	interval: "an interval",
@@ -44409,6 +44708,11 @@ function validateWhenTree(when) {
 	if (depth > 4) return `the rules nest ${depth} levels deep — the limit is 4. "not (any of …)" is the same as "all of (not …)", which is one level shallower`;
 	const leaves = countWhenLeaves(when);
 	if (leaves > 32) return `the rules use ${leaves} rows — the limit is 32`;
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of identifiedEventLeaves(when)) {
+		if (seen.has(entry.id)) return `two trigger rows share the id "${entry.id}" — an id names one row`;
+		seen.add(entry.id);
+	}
 	const need = eventNeed(when, "when", false);
 	if ("error" in need) return need.error;
 	const [first, second] = need.paths;
@@ -44620,9 +44924,12 @@ function convertLegacyWhen(half) {
 * every caller — automations, Actions, and the notification centre, which runs
 * only Actions (planning#473).
 */
+/** The longest one `wait` step lasts. It is cut by a restart of the run and does not survive a hub restart. */
+var WAIT_MAX_SECONDS = 3600;
+var WAIT_TOO_LONG = `a wait is at most one hour (${WAIT_MAX_SECONDS} s)`;
 var AutomationWaitStepSchema = object({
 	kind: literal("wait"),
-	seconds: number$1().min(0).max(300)
+	seconds: number$1().min(0).max(WAIT_MAX_SECONDS, WAIT_TOO_LONG)
 });
 /** The legacy `deviceId` of a cap step: still READ, never written (D983). */
 var LegacyStepDeviceSchema = union([
@@ -44692,28 +44999,227 @@ var elseNeedsIf = {
 	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, {
+/**
+* A step of a STANDALONE list (an action, a scheduler point, a preset): the
+* same two step kinds an automation runs, minus a guard that reads the
+* automation's trigger, which such a list does not have.
+*/
+var ActionStepSchema = discriminatedUnion("kind", [GuardedWaitStepSchema, 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)]).superRefine((step, ctx) => {
+	if (step.if !== void 0 && hasTriggeredByLeaves(step.if)) ctx.addIssue({
+		code: "custom",
+		message: TRIGGERED_BY_NEEDS_AUTOMATION,
+		path: ["if"]
+	});
+});
+/**
+* Flow control of an AUTOMATION's list (#500). A standalone list (an action, a
+* scheduler point, a preset) stays `wait` and `cap`: it has no run of its own
+* to end and no variable bag to write.
+*/
+var continueOnErrorShape = { 
+/** A failure of this step is traced `failed-continued` and the next step runs. */
+continueOnError: literal(true).optional() };
+/** An automation's cap step: the shared guarded cap step, plus `continueOnError`. */
+var AutomationGuardedCapStepSchema = AutomationCapStepBaseSchema.extend({
+	...stepGuardShape,
+	...continueOnErrorShape
+}).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]);
+/** End the run here, on purpose. `reason` may carry `{{vars.x}}` slots. */
+var AutomationStopStepSchema = object({
+	kind: literal("stop"),
+	reason: string().min(1, "a stop needs a reason: it is what the run trace shows").max(200),
+	/** `ok`: the run ends as a success. `failed`: it ends as a failure, with the reason. */
+	outcome: _enum(["ok", "failed"]),
+	/** Stop only when this reads true; false or unknown does not stop. */
+	if: AutomationWhenSchema.optional()
+});
+var SET_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,39}$/;
+/** Names the run itself writes and reads (`leaf` is what `triggered-by` judges): a step may not overwrite them. */
+var RESERVED_RUN_VARS = [
+	"kind",
+	"leaf",
+	"at"
+];
+/**
+* Write variables into the run's bag, for the steps after it. SUBSTITUTION
+* only, never evaluation: a text value may carry `{{vars.x}}` slots.
+*/
+var AutomationSetStepSchema = object({
+	kind: literal("set"),
+	vars: record(string(), union([
+		string().max(500),
+		number$1(),
+		boolean()
+	])).refine((vars) => Object.keys(vars).every((name) => SET_VAR_NAME_RE.test(name)), { message: "a variable name is letters, digits and _, not starting with a digit (max 40)" }).refine((vars) => Object.keys(vars).length >= 1, { message: "set needs at least one variable" }).refine((vars) => Object.keys(vars).length <= 20, { message: `set holds at most 20 variables` }).refine((vars) => Object.keys(vars).every((name) => !RESERVED_RUN_VARS.includes(name)), { message: `the names ${RESERVED_RUN_VARS.join(", ")} belong to the run and cannot be set` }),
+	/** Set only when this reads true; false or unknown leaves the bag as it is. */
+	if: AutomationWhenSchema.optional()
+});
+var AutomationRunActionStepSchema = object({
+	kind: literal("action"),
+	/** An entry of the `actions` surface (`internal:<uuid>` or `<addonId>:<localId>`). */
+	actionId: string().min(1),
+	/** Values for the action's declared variables; the others take their default. */
+	variables: record(string(), union([
+		string(),
+		number$1(),
+		boolean()
+	])).optional(),
+	...continueOnErrorShape
+});
+/**
+* A step INSIDE a branch of a `choose`: a flow step with no condition of its
+* own (the branch is the condition) and no block inside it. Strict, so an `if`
+* written on such a step is refused rather than dropped.
+*/
+/** The longest a `wait-until` may wait: six hours. */
+var WAIT_UNTIL_TIMEOUT_MAX_S = 21600;
+/**
+* Pause the run until a condition is true (#500). The timeout is mandatory: a
+* run never waits without an end. `onTimeout` says what a wait that ran out
+* does: `continue` goes on to the next step, `stop` ends the run as a failure.
+* A condition that cannot be read is not "true": the wait goes on (D49).
+*/
+var AutomationWaitUntilStepSchema = object({
+	kind: literal("wait-until"),
+	when: AutomationWhenSchema,
+	timeoutS: number$1().int().min(1, "a wait needs a timeout of at least one second").max(WAIT_UNTIL_TIMEOUT_MAX_S, `a wait for a condition is at most six hours (${WAIT_UNTIL_TIMEOUT_MAX_S} s)`),
+	onTimeout: _enum(["continue", "stop"])
+}).strict();
+/** The step kinds that hold steps of their own, or pause on a condition: they nest two levels at most. */
+var BLOCK_STEP_KINDS = [
+	"choose",
+	"repeat",
+	"parallel",
+	"wait-until"
+];
+var NEST_TOO_DEEP = `steps nest two levels at most: a step inside a nested choose or repeat can be a plain step only`;
+function kindOf(input) {
+	return typeof input === "object" && input !== null ? Reflect.get(input, "kind") : void 0;
+}
+/** Where the nesting ends, a block step is refused in words rather than as an unknown kind. */
+function nestTooDeep(issue) {
+	const kind = kindOf(issue.input);
+	return typeof kind === "string" && BLOCK_STEP_KINDS.includes(kind) ? NEST_TOO_DEEP : void 0;
+}
+var plainStepSchemas = [
+	AutomationWaitStepSchema.strict(),
+	AutomationCapStepBaseSchema.extend(continueOnErrorShape).strict().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"]
+	}),
+	AutomationStopStepSchema.omit({ if: true }).strict(),
+	AutomationSetStepSchema.omit({ if: true }).strict(),
+	AutomationRunActionStepSchema.strict()
+];
+/**
+* A plain step: a flow step with no condition of its own and no step inside
+* it. The second (last) level of nesting holds these only.
+*/
+var AutomationBranchStepSchema = discriminatedUnion("kind", plainStepSchemas, { error: nestTooDeep });
+/** A step that can run beside others: it writes no variable and does not end the run. */
+var AutomationParallelMemberSchema = AutomationBranchStepSchema.refine((step) => step.kind === "cap" || step.kind === "action" || step.kind === "wait", "a parallel holds device commands, actions and waits only: a set or a stop beside other steps has no order");
+/**
+* Several steps at once (#500): all are started together and all are awaited.
+* A failure fails the run once the others finished, as in a sequence; a member
+* marked "continue if this fails" does not.
+*/
+var AutomationParallelStepSchema = object({
+	kind: literal("parallel"),
+	steps: array(AutomationParallelMemberSchema).min(2, "a parallel needs at least two steps").max(5, `a parallel takes at most 5 steps`)
+}).strict();
+var REPEAT_NEEDS_MAX = "a repeat on a condition needs a maximum number of iterations";
+/** A loop on a condition: the bound is mandatory, so a run never loops without an end. */
+var repeatConditionShape = {
+	when: AutomationWhenSchema,
+	maxIterations: number$1({ error: REPEAT_NEEDS_MAX }).int().min(1, REPEAT_NEEDS_MAX).max(50, `a repeat on a condition runs at most 50 times`),
+	/** A pause between two iterations, never after the last. */
+	waitS: number$1().int().min(1).max(WAIT_MAX_SECONDS, WAIT_TOO_LONG).optional()
+};
+/** What decides how many times a `repeat` runs. */
+var AutomationRepeatLoopSchema = discriminatedUnion("by", [
+	object({
+		by: literal("count"),
+		count: number$1().int().min(1).max(20, `a repeat runs at most 20 times`)
+	}).strict(),
+	object({
+		by: literal("while"),
+		...repeatConditionShape
+	}).strict(),
+	object({
+		by: literal("until"),
+		...repeatConditionShape
+	}).strict(),
+	object({
+		by: literal("forEach"),
+		target: object({
+			kind: literal("devices"),
+			ids: array(number$1().int()).min(1, "a repeat over devices needs at least one device").max(50, `a repeat over devices takes at most 50 devices`)
+		}).strict()
+	}).strict()
+]);
+/**
+* The same steps several times (#500). Every form is bounded at save, so a
+* run cannot loop without an end. A failure or a `stop` in the steps ends the
+* loop and the run, as in a sequence.
+*/
+function repeatSchemaOf(step) {
+	return object({
+		kind: literal("repeat"),
+		loop: AutomationRepeatLoopSchema,
+		steps: array(step).min(1, "a repeat needs at least one step").max(10, `a repeat takes at most 10 steps`)
+	}).strict();
+}
+/**
+* One step, several ways (#500): the branches are read in order and the FIRST
+* whose condition is true runs; `else` runs when every branch is false. A
+* branch that cannot be read ends the choice: nothing runs, not the branches
+* after it and not the else (D49). The #472 `if` / `else` of a wait or cap
+* step is the one-branch case and stays as it is stored.
+*/
+function chooseSchemaOf(step) {
+	const steps = array(step).max(10);
+	return object({
+		kind: literal("choose"),
+		branches: array(object({
+			if: AutomationWhenSchema,
+			steps: steps.min(1, "a branch needs at least one step")
+		})).min(1, "a choose needs at least one branch").max(6, `a choose takes at most 6 branches`),
+		else: steps.optional()
+	});
+}
+var AutomationBodyStepSchema = discriminatedUnion("kind", [
+	...plainStepSchemas,
+	AutomationWaitUntilStepSchema,
+	AutomationParallelStepSchema,
+	chooseSchemaOf(AutomationBranchStepSchema),
+	repeatSchemaOf(AutomationBranchStepSchema)
+]);
+var AutomationRepeatStepSchema = repeatSchemaOf(AutomationBodyStepSchema);
 var AutomationActionSchema = discriminatedUnion("kind", [
 	GuardedWaitStepSchema,
-	GuardedCapStepSchema,
-	object({
-		kind: literal("action"),
-		/** An entry of the `actions` surface (`internal:<uuid>` or `<addonId>:<localId>`). */
-		actionId: string().min(1),
-		/** Values for the action's declared variables; the others take their default. */
-		variables: record(string(), union([
-			string(),
-			number$1(),
-			boolean()
-		])).optional()
-	}),
+	AutomationGuardedCapStepSchema,
+	AutomationStopStepSchema,
+	AutomationSetStepSchema,
+	chooseSchemaOf(AutomationBodyStepSchema),
+	AutomationWaitUntilStepSchema,
+	AutomationParallelStepSchema,
+	AutomationRepeatStepSchema,
+	AutomationRunActionStepSchema,
 	object({
 		kind: literal("code"),
 		/** Compiled into the automation's OWN block by esbuild — not a third
@@ -44776,11 +45282,6 @@ function convertLegacyRecipe(legacy) {
 		...rest
 	};
 }
-/**
-* Where recipes are PARSED (the core-blocks cap, the MCP tool, the literal a
-* saved block carries): the new shape as it is, or the old shape converted to
-* it. The output type is always the new one.
-*/
 var AutomationRecipeSchema = union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
 var DETECTION_DESCRIPTIONS = {
 	deviceId: "the camera that saw it",
@@ -44796,6 +45297,21 @@ var STATIONARY_DESCRIPTIONS = {
 	phase: "appeared or departed",
 	entryId: "the stopped object"
 };
+var BECOMES_DESCRIPTIONS = {
+	deviceId: "the device that changed",
+	from: "the value before the change, empty when it is not known",
+	to: "the value it changed to"
+};
+/**
+* A fire's payload is offered too, as `data.<path>` (`{{vars.data.channel}}`):
+* those names depend on the device, so they are not in this list.
+*/
+var FIRED_DESCRIPTIONS = {
+	deviceId: "the device that fired",
+	eventType: "the event, as the device names it",
+	sourceId: "the part of the device that fired (a button), empty when it names none",
+	eventKind: "the kind of press (press, long-press …), empty when the device declares none"
+};
 function describe$1(descriptions) {
 	return Object.entries(descriptions).map(([name, description]) => ({
 		name,
@@ -44804,8 +45320,74 @@ function describe$1(descriptions) {
 }
 describe$1(DETECTION_DESCRIPTIONS);
 describe$1(STATIONARY_DESCRIPTIONS);
+describe$1(FIRED_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
+	...v,
+	hintKey: "firedDeviceId"
+} : v);
+describe$1(BECOMES_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
+	...v,
+	hintKey: "becomesDeviceId"
+} : v);
 new Set(Object.values(COCO_TO_MACRO.mapping));
 /**
+* Generic stateless event emitter. Installed on a `DeviceType.EventEmitter`
+* device. Carries the device's EXACT declared event vocabulary verbatim
+* (NO normalization). Two shapes:
+*  - structured source (HA `event.*` entity) → `vocabulary` is the fixed
+*    declared set (e.g. press_short, press_long, …).
+*  - generic/legacy source (HA bus events, e.g. zha_event) → `vocabulary`
+*    is [] (open) and `lastEvent.data` carries the complex payload.
+* `vocabulary` (D1044) names each event for a person and types it for a
+* rule; `eventTypes` is its list of native tokens, kept for older readers.
+* A fire names the part of the device it came from in `sourceId` when the
+* vocabulary declares sources (a remote's buttons).
+* `seq` is monotonic so two identical events still produce distinct slice writes.
+*/
+var EventFireSchema = object({
+	deviceId: number$1(),
+	eventType: string(),
+	sourceId: string().optional(),
+	data: record(string(), unknown()).nullable(),
+	timestamp: number$1().meta(readingMeta("none")),
+	seq: number$1().meta(readingMeta("count"))
+});
+var EventEmitterStatusSchema = object({
+	eventTypes: array(string()),
+	/**
+	* Required of a provider by the type. A status written before the field
+	* existed still parses, as an empty vocabulary: read it through
+	* `readEventVocabulary`, which then answers with the plain tokens.
+	*/
+	vocabulary: array(EventVocabularyEntrySchema).default([]),
+	lastEvent: EventFireSchema.nullable(),
+	eventCountSinceStart: number$1().meta(readingMeta("count"))
+});
+var eventEmitterCapability = {
+	name: "event-emitter",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.EventEmitter],
+	methods: {},
+	events: { onEvent: { data: EventFireSchema } },
+	status: {
+		schema: EventEmitterStatusSchema,
+		kind: "push"
+	},
+	runtimeState: EventEmitterStatusSchema,
+	/**
+	* Runtime-state durability: **session** — `eventCountSinceStart` names its own scope.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	/**
+	* History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
+	*/
+	history: "none"
+};
+/**
 * Schedulers (D983) — an entity that performs actions over the day.
 *
 * A scheduler has profiles; a profile has weekdays and a timeline of POINTS.
@@ -44828,6 +45410,13 @@ var SchedulerStateTreeSchema = AutomationWhenSchema.superRefine((when, ctx) => {
 		});
 		return;
 	}
+	if (hasTriggeredByLeaves(when)) {
+		ctx.addIssue({
+			code: "custom",
+			message: TRIGGERED_BY_NEEDS_AUTOMATION
+		});
+		return;
+	}
 	const problem = validateWhenTree(when);
 	if (problem !== null) ctx.addIssue({
 		code: "custom",
@@ -44849,12 +45438,16 @@ var HoldOverrideSchema = discriminatedUnion("mode", [object({ mode: literal("res
 })]);
 /** A missed edge up to this late still runs. */
 var DEFAULT_MAX_LATE_MS = 10 * 6e4;
+var SchedulerStepSchema = ActionStepSchema.refine((step) => step.kind !== "wait" || step.seconds <= 300, {
+	message: `a scheduler point waits at most five minutes (300 s); put a longer wait in an action`,
+	path: ["seconds"]
+});
 var SchedulerPointSchema = object({
 	id: string().min(1).max(64),
 	at: SchedulerTimeSpecSchema,
 	mode: SchedulerPointModeSchema,
 	/** The actions of an `edge` or `hold`; a `release` has none. */
-	steps: array(ActionStepSchema).max(20).default([]),
+	steps: array(SchedulerStepSchema).max(20).default([]),
 	/** Checked when the point runs (an edge) or is applied (a hold). */
 	conditions: SchedulerStateTreeSchema.optional(),
 	/** Hold only; absent means `respect`. */
@@ -45033,7 +45626,9 @@ var AutomationTriggerTraceSchema = object({
 	/** Why an event was rejected ("class person not in [dog]") or what fired. */
 	reason: string(),
 	/** deviceId, className, trackId, score … — only what the trigger exposes. */
-	vars: record(string(), TraceValueSchema)
+	vars: record(string(), TraceValueSchema),
+	/** A hold (`for`) this occurrence went through: pending, cancelled, fired or re-seeded. */
+	hold: HoldTraceSchema.optional()
 });
 var AutomationConditionTraceNodeSchema = object({
 	/** `when` for the root, `when.<i>` for its i-th child, … (`conditions…` on an old trace). */
@@ -45046,8 +45641,11 @@ var AutomationConditionTraceNodeSchema = object({
 		"device-is",
 		"expression",
 		"stationary-present",
+		"time-is",
+		"triggered-by",
 		"device-becomes",
 		"device-event",
+		"device-fired",
 		"schedule",
 		"interval",
 		"manual",
@@ -45118,18 +45716,46 @@ var StepTraceBaseSchema = object({
 	]).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. */
+	/** `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. `failed-continued`: it failed and was marked to be passed over (#500). */
 	outcome: _enum([
 		"ok",
 		"error",
 		"not-run",
 		"empty",
-		"skipped"
+		"skipped",
+		"failed-continued",
+		"timed-out"
 	]),
 	message: string().optional()
 });
+/** What a block step adds to its row: which list ran, what each branch read, how many rounds. */
+var blockTraceShape = {
+	/** A `choose` step (#500): the list that ran, `branches.<n>` or `else`. Absent when none did. */
+	branch: string().optional(),
+	/** A `choose` step: what each branch read, in order, up to the one that decided. */
+	branchChecks: array(object({
+		condition: _enum([
+			"true",
+			"false",
+			"unknown"
+		]),
+		conditionReason: string().optional()
+	})).optional(),
+	/** A `repeat` step (#500): how many times its steps ran. */
+	iterations: number$1().int().optional()
+};
+/** A step one level down: it may be a block step itself, whose own steps are plain rows (the nesting ends there). */
+var NestedStepTraceSchema = StepTraceBaseSchema.extend({
+	...blockTraceShape,
+	steps: array(StepTraceBaseSchema).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 AutomationStepTraceSchema = StepTraceBaseSchema.extend({
+	else: array(StepTraceBaseSchema).optional(),
+	...blockTraceShape,
+	/** A `choose` step: the steps of the list that ran. A `parallel`: its members. A `repeat`: the LAST iteration. */
+	steps: array(NestedStepTraceSchema).optional()
+});
 var AutomationRunTraceSchema = object({
 	runId: string().min(1),
 	startedAt: number$1(),
@@ -45379,7 +46005,7 @@ object({
 	*  is irrelevant; the array is treated as a set by consumers. */
 	hiddenChildIds: array(number$1()).readonly()
 });
-DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Light, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Cover, DeviceType.Lock, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Generic, method(object({
+DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Sensor, DeviceType.Climate, DeviceType.Cover, DeviceType.Lock, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Generic, method(object({
 	deviceId: number$1().int().nonnegative(),
 	childDeviceId: number$1().int().nonnegative(),
 	hidden: boolean()
@@ -45536,7 +46162,9 @@ var AddonHttpRouteSchema = object({
 	]).optional(),
 	description: string().optional(),
 	/** The hub limits this route per client address before the handler runs. */
-	rateLimit: _enum(["auth"]).optional()
+	rateLimit: _enum(["auth"]).optional(),
+	/** Served once per integration instance; the handler reads `instanceId`. */
+	perInstance: boolean().optional()
 });
 /**
 * Cross-process route invocation envelope. The hub captures the
@@ -45553,6 +46181,8 @@ var InvokeRequestSchema = object({
 	query: record(string(), string()),
 	body: unknown(),
 	headers: record(string(), string()),
+	/** The instance the hub resolved for a `perInstance` route. */
+	instanceId: string().optional(),
 	user: object({
 		id: string(),
 		username: string(),
@@ -47677,7 +48307,7 @@ var BATTERY_DEVICE_TYPES = [
 	DeviceType.Switch,
 	DeviceType.PetFeeder,
 	DeviceType.Container,
-	DeviceType.Thermostat,
+	DeviceType.Climate,
 	DeviceType.EventEmitter
 ];
 /** Generic Customize target for the percentage reading (D936). */
@@ -49440,7 +50070,14 @@ var climateControlCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
+	deviceTypes: [DeviceType.Climate],
+	power: {
+		kind: "mode",
+		field: "mode",
+		offValue: "off",
+		set: "setMode",
+		lastField: "lastActiveMode"
+	},
 	methods: {
 		setMode: method(object({
 			deviceId: number$1().int().nonnegative(),
@@ -49550,6 +50187,140 @@ var climateControlCapability = {
 	} }
 };
 /**
+* cluster-update — the ONE flow that brings the whole cluster to a release
+* (planning#493). Hub-provided (`server-provided`), hub-only: the hub runs
+* the sequence itself, so the admin UI, the MCP and the CLI all start the same
+* job and read the same report instead of each driving their own loop.
+*
+*   1. backup (`backup.trigger`) — skipped only when the caller says so
+*   2. the hub's server closure (`applyServerUpdate`); the hub restarts and the
+*      job RESUMES on the new boot, verified against the hub's running version
+*   3. every online agent behind the target, one at a time, verified: runs the
+*      target, settled, online, and its capabilities registered (D848) — an
+*      agent that comes back capless is a FAILED step, never a done one
+*   4. every stale addon on the hub (`addons.updatePackage`); agents follow by
+*      reconciliation, which is verified, never pushed
+*
+* The job stops on the first failed step with a typed reason (D877). Its state
+* is durable on the hub and read by RPC (`getClusterUpdateJob`) — events are
+* telemetry and never carry it (D8, D11).
+*/
+/** The steps, in the order they run. */
+var ClusterUpdateStepKindSchema = _enum([
+	"backup",
+	"hub-server",
+	"agent-server",
+	"addons"
+]);
+/**
+* - `pending`  — not reached yet.
+* - `running`  — in progress (for `hub-server`: possibly across the restart).
+* - `ok`       — done AND verified.
+* - `failed`   — did not land; `reason` + `detail` say why. Stops the job.
+* - `skipped`  — not run: nothing to do, opted out, the node is offline, or a
+*                step before it failed. `detail` says which.
+*/
+var ClusterUpdateStepStatusSchema = _enum([
+	"pending",
+	"running",
+	"ok",
+	"failed",
+	"skipped"
+]);
+/**
+* Why a step (and with it the job) failed. Stable, greppable; `detail` carries
+* the prose.
+*/
+var ClusterUpdateFailureReasonSchema = _enum([
+	"backup-unavailable",
+	"backup-failed",
+	"server-refused",
+	"server-not-on-target",
+	"node-capless",
+	"status-unreadable",
+	"addon-update-failed",
+	"addons-not-converged",
+	"interrupted"
+]);
+var ClusterUpdateStepSchema = object({
+	kind: ClusterUpdateStepKindSchema,
+	/** The node the step acts on; absent for `backup` and `addons`. */
+	nodeId: string().optional(),
+	status: ClusterUpdateStepStatusSchema,
+	/** One line for the operator: what happened, or why not. */
+	detail: string(),
+	reason: ClusterUpdateFailureReasonSchema.optional(),
+	/** `hub-server` / `agent-server`: the version the node ran before. */
+	fromVersion: string().nullable().optional(),
+	/** `addons`: the packages this step updates, `name from -> to`. */
+	packages: array(string()).readonly().optional(),
+	startedAt: number$1().optional(),
+	finishedAt: number$1().optional()
+});
+var ClusterUpdateJobStateSchema = _enum([
+	"running",
+	"succeeded",
+	"failed"
+]);
+var ClusterUpdateJobSchema = object({
+	id: string(),
+	state: ClusterUpdateJobStateSchema,
+	/** The server version every node is brought to. */
+	targetVersion: string(),
+	/** Who started it (the user name, or `system`). */
+	requestedBy: string(),
+	startedAt: number$1(),
+	finishedAt: number$1().optional(),
+	/** Every step, in run order; later steps stay `pending` while it runs. */
+	steps: array(ClusterUpdateStepSchema).readonly(),
+	/** On `failed`: the step that stopped it (`nodeId` or the step kind). */
+	stoppedAt: string().optional(),
+	reason: ClusterUpdateFailureReasonSchema.optional(),
+	/** Agents offline when the plan was read: never touched. */
+	skippedOffline: array(string()).readonly()
+});
+var ClusterUpdateOptionsSchema = object({
+	/** Explicit server target; omitted = the hub's latest registry check. */
+	version: string().optional(),
+	/** Update the addons too (default true). */
+	addons: boolean().optional(),
+	/**
+	* Back up before touching anything (default true). `false` is an explicit
+	* operator opt-out; a missing backup provider is otherwise a failure.
+	*/
+	backup: boolean().optional()
+});
+/** Why a plan cannot start. */
+var ClusterUpdateBlockerSchema = _enum([
+	"no-target",
+	"node-busy",
+	"job-running",
+	"nothing-to-do",
+	"status-unreadable"
+]);
+var ClusterUpdatePlanSchema = object({
+	/** `null` when no target could be resolved (`blocker: 'no-target'`). */
+	targetVersion: string().nullable(),
+	/** The steps the job WOULD run, all `pending` (or `skipped` with a reason). */
+	steps: array(ClusterUpdateStepSchema).readonly(),
+	skippedOffline: array(string()).readonly(),
+	/** `null` = the plan can start. */
+	blocker: ClusterUpdateBlockerSchema.nullable(),
+	/** Prose for `blocker`. */
+	blockerDetail: string().nullable()
+});
+var StartClusterUpdateResultSchema = object({
+	accepted: boolean(),
+	/** The job to follow with `getClusterUpdateJob`; `null` when refused. */
+	jobId: string().nullable(),
+	blocker: ClusterUpdateBlockerSchema.nullable(),
+	message: string()
+});
+method(ClusterUpdateOptionsSchema, ClusterUpdatePlanSchema, { auth: "admin" }), method(ClusterUpdateOptionsSchema, StartClusterUpdateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string().optional() }), ClusterUpdateJobSchema.nullable(), { auth: "admin" });
+/**
 * Color-light cap. Coexists with `switch` (on/off) and `brightness`
 * (level) on the same device — `switch` toggles the bulb, `brightness`
 * sets the dim level, this cap sets the chromaticity.
@@ -49691,6 +50462,7 @@ var CompositionProblemSchema = object({
 		"nested-field",
 		"missing-field",
 		"kind-mismatch",
+		"source-kind-mismatch",
 		"may-be-null",
 		"source-missing",
 		"source-unreadable",
@@ -49712,7 +50484,8 @@ var CompositionProblemSchema = object({
 		"command-method-unknown",
 		"command-source-unknown",
 		"command-input-unknown",
-		"command-input-missing"
+		"command-input-missing",
+		"power-source-is-actuator"
 	]),
 	path: string(),
 	message: string()
@@ -50750,6 +51523,13 @@ var mediaPlayerCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.MediaPlayer],
+	power: {
+		kind: "methods",
+		field: "state",
+		offValues: ["off", "standby"],
+		on: "turnOn",
+		off: "turnOff"
+	},
 	methods: {
 		turnOn: optionalMethod(deviceOnly, _void(), {
 			kind: "mutation",
@@ -50880,8 +51660,8 @@ 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.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 = {
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Climate, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, 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.Dryer, DeviceType.Gateway, DeviceType.HeatPump, DeviceType.Camera, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Gateway, 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.PetFeeder, DeviceType.MediaPlayer;
+var NUMBER$1 = {
 	kind: "fixed",
 	result: ["number"]
 };
@@ -50890,19 +51670,19 @@ var BOOLEAN = {
 	result: ["boolean"]
 };
 Object.freeze({
-	min: NUMBER,
-	max: NUMBER,
-	abs: NUMBER,
-	floor: NUMBER,
-	ceil: NUMBER,
-	sqrt: NUMBER,
-	round: NUMBER,
-	pow: NUMBER,
-	clamp: NUMBER,
-	avg: NUMBER,
-	sum: NUMBER,
-	age: NUMBER,
-	convert: NUMBER,
+	min: NUMBER$1,
+	max: NUMBER$1,
+	abs: NUMBER$1,
+	floor: NUMBER$1,
+	ceil: NUMBER$1,
+	sqrt: NUMBER$1,
+	round: NUMBER$1,
+	pow: NUMBER$1,
+	clamp: NUMBER$1,
+	avg: NUMBER$1,
+	sum: NUMBER$1,
+	age: NUMBER$1,
+	convert: NUMBER$1,
 	coalesce: { kind: "coalesce" },
 	any: BOOLEAN,
 	all: BOOLEAN,
@@ -50919,7 +51699,7 @@ Object.freeze({
 		kind: "fixed",
 		result: ["number", "null"]
 	},
-	count: NUMBER,
+	count: NUMBER$1,
 	dwell: {
 		kind: "fixed",
 		result: ["boolean", "null"]
@@ -50945,7 +51725,7 @@ var CHANGED = {
 	fieldPath: "lastChangedAt",
 	expr: "now"
 };
-function numeric(input) {
+function numeric$1(input) {
 	const { alsoFrom, ...base } = input;
 	return {
 		...base,
@@ -50963,7 +51743,7 @@ function numeric(input) {
 		}, ...alsoFrom === void 0 ? [] : [alsoFrom.accept]]
 	};
 }
-var CLIMATE_DEVICES = [DeviceType.Thermostat, DeviceType.Climate];
+var CLIMATE_DEVICES = [DeviceType.Climate];
 function binary(input) {
 	return {
 		...input,
@@ -50980,7 +51760,7 @@ function binary(input) {
 	};
 }
 var GROUP_TEMPLATES = [
-	numeric({
+	numeric$1({
 		id: "temperature",
 		summary: "Mean, median, min, max or sum of temperatures. Offline and unknown members are left out, never read as 0 °C.",
 		role: DeviceRole.TemperatureSensor,
@@ -50998,7 +51778,7 @@ var GROUP_TEMPLATES = [
 			}
 		}
 	}),
-	numeric({
+	numeric$1({
 		id: "humidity",
 		summary: "Humidity in percent. Offline and unknown members are left out, never read as 0 %.",
 		role: DeviceRole.HumiditySensor,
@@ -51016,7 +51796,7 @@ var GROUP_TEMPLATES = [
 			}
 		}
 	}),
-	numeric({
+	numeric$1({
 		id: "pressure",
 		summary: "Pressure in hectopascals. Offline and unknown members are left out, never read as 0 hPa.",
 		role: DeviceRole.PressureSensor,
@@ -51027,7 +51807,7 @@ var GROUP_TEMPLATES = [
 		empty: "null",
 		companions: [NOW$3]
 	}),
-	numeric({
+	numeric$1({
 		id: "illuminance",
 		summary: "Illuminance in lux. Offline and unknown members are left out, never read as 0 lx.",
 		role: DeviceRole.AmbientLightSensor,
@@ -51038,7 +51818,7 @@ var GROUP_TEMPLATES = [
 		empty: "null",
 		companions: [NOW$3]
 	}),
-	numeric({
+	numeric$1({
 		id: "power",
 		summary: "Power in watts, summed by default. Nobody reporting omits the key rather than writing 0 W.",
 		role: DeviceRole.PowerSensor,
@@ -51049,7 +51829,7 @@ var GROUP_TEMPLATES = [
 		empty: "omit",
 		companions: [NOW$3]
 	}),
-	numeric({
+	numeric$1({
 		id: "energy",
 		summary: "Energy in kilowatt-hours, summed by default. Nobody reporting omits the key rather than writing 0 kWh.",
 		role: DeviceRole.EnergySensor,
@@ -51060,7 +51840,7 @@ var GROUP_TEMPLATES = [
 		empty: "omit",
 		companions: [NOW$3]
 	}),
-	numeric({
+	numeric$1({
 		id: "battery",
 		summary: "Battery charge in percent. Offline and unknown members are left out, never read as 0 %.",
 		role: DeviceRole.BatterySensor,
@@ -51084,7 +51864,7 @@ var GROUP_TEMPLATES = [
 			}
 		]
 	}),
-	numeric({
+	numeric$1({
 		id: "numeric",
 		summary: "A numeric reading in the members’ shared quantity. Mixed quantities are refused. Nobody reporting publishes null, not 0.",
 		role: DeviceRole.NumericSensor,
@@ -51285,8 +52065,8 @@ var GROUP_TEMPLATES = [
 	actuator({
 		id: "climate",
 		summary: "Running when at least one thermostat or air conditioner is not off, or only when all of them are. Target temperature and fan are offered only when every device has them. A device that reports nothing is left out, never read as off.",
-		deviceType: DeviceType.Thermostat,
-		memberDeviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
+		deviceType: DeviceType.Climate,
+		memberDeviceTypes: [DeviceType.Climate],
 		outputCap: "group-active",
 		outputField: "active",
 		member: {
@@ -51329,6 +52109,118 @@ function actuator(input) {
 new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
 DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
 DeviceType.Camera;
+var PowerSourceRefusalReasonSchema = _enum([
+	"no-power-source",
+	"switch-missing",
+	"switch-offline",
+	"switch-unknown",
+	"restart-in-progress",
+	"switch-call-failed",
+	"switch-is-actuator"
+]);
+var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
+	accepted: literal(false),
+	reason: PowerSourceRefusalReasonSchema,
+	/** One line for the operator, naming the switch. */
+	message: string()
+})]);
+var PowerSourceInfoSchema = object({
+	/** False when the device has no power source linked; the rest is then empty. */
+	linked: boolean(),
+	switchDeviceId: number$1().nullable(),
+	switchName: string().nullable(),
+	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
+	switchOn: boolean().nullable(),
+	switchOnline: boolean().nullable(),
+	restartInProgress: boolean(),
+	offSeconds: number$1().int()
+});
+/** The composed slice: the switch state the link mirrors, plus the stored off time. */
+var PowerSourceStateSchema = object({
+	/** Null while the switch has not reported: unknown is never `false` (D393). */
+	switchOn: boolean().nullable(),
+	offSeconds: number$1().int(),
+	lastFetchedAt: number$1()
+});
+var POWER_SOURCE_DEVICE_TYPES = [
+	DeviceType.Gateway,
+	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
+];
+var powerSourceCustomize = {
+	version: 1,
+	targets: [{
+		id: "switch",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-source",
+			stateField: "switchOn"
+		},
+		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+		apply: "add",
+		path: "switchOn",
+		sources: [{
+			kind: "switch",
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "constant",
+			path: "offSeconds",
+			value: 10,
+			when: "add",
+			formerValues: [0]
+		}, {
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" }
+	}]
+};
+var deviceInput$2 = object({ deviceId: number$1().int().nonnegative() });
+var powerSourceCapability = {
+	name: "power-source",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
+	methods: {
+		getStatus: systemMethod(deviceInput$2, PowerSourceInfoSchema, { auth: "protected" }),
+		powerOn: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		powerOff: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		forceRestart: systemMethod(deviceInput$2, PowerSourceActionResultSchema, {
+			kind: "mutation",
+			auth: "protected"
+		})
+	},
+	runtimeState: PowerSourceStateSchema,
+	customize: powerSourceCustomize,
+	/**
+	* Runtime-state durability: **session** — mirrored from the linked switch on
+	* its next report; a restored value would outlive the reading it names.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
 * What a composition may BUILD on a device type (G2, D676): the caps a new
@@ -52373,27 +53265,35 @@ var deviceAdminLinkCapability = {
 getAdminLink: method(object({ deviceId: number$1().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" }) }
 };
 /**
-* device-discovery — device-scoped capability for parents that host /
-* enumerate child devices (Reolink Hub / NVR, ONVIF gateway, future
-* integrations). The parent advertises a list of discoverable children,
-* and the operator promotes a subset to real devices via `adoptDevice`.
-* Child lifecycle (kernel device create/remove, parent reference) is
-* owned by the framework so a single shared `<DiscoveryPanel />` can
-* drive any integration.
-*
-* Boundaries:
-*   - The cap exposes ENUMERATION + ADOPT/RELEASE only. The protocol
-*     used to discover children (CGI poll, mDNS, push from hub, ...)
-*     is the integration's business; results land in `runtimeState`
-*     so the panel can render without a fresh round-trip.
-*   - `childNativeId` is integration-defined and must be stable across
-*     reboots so re-discovery doesn't duplicate adopted children.
-*   - `adoptDevice` returns the new `deviceId` so the UI can navigate
-*     directly to the freshly-created child's settings page.
-*/
-/**
-* Status enum for a discovered device. Mirrors the Reolink simpleEvent
-* lifecycle (`online` / `sleeping` / `offline`) — generic enough for
+* `device-adoption` — generic discovery + adoption surface,
+* system-scoped collection (one provider per integration addon), routed
+* by explicit `{ addonId }` on direct `deviceAdoption.*` calls — the same
+* pin model as `connection-test`. The admin UI keeps using
+* `deviceManager.adoption*` (which already threads `addonId`). The de-HA-ified
+* successor to `ha-discovery`:
+* keyed by `integrationId` (the addon resolves integrationId → broker
+* internally) rather than a connection-specific `brokerId`, and it
+* OWNS the shared `DiscoveredChildDevice` candidate type
+* (declared below) so a single shared adoption modal renders any integration's
+* candidate tree.
+*
+* UI flow (Integrations page → integration detail):
+*   1. `listCandidates({integrationId, page, pageSize, filter})` →
+*      paginated candidate list, each row collapsed.
+*   2. User expands a row → `getCandidate({integrationId,
+*      childNativeId})` returns the single candidate (with its nested
+*      `children`) for the accordion render.
+*   3. User clicks "Adopt" on one or more candidates →
+*      `adopt({integrationId, childNativeIds, perCandidate?})`
+*      materialises one parent CamStack device per candidate plus its
+*      accessory children. `perCandidate[childNativeId]` carries an
+*      optional display-name override + a `hiddenChildIds` pre-hide set
+*      (the parent's `accessories.hiddenChildIds` gates UI visibility).
+*   4. User clicks "Release" → `release({integrationId, camDeviceId})`
+*      removes the parent + every child from the kernel registry.
+*/
+/**
+* Status enum for a discovered device. Generic enough for
 * battery cams, awake cams, and unreachable cams alike.
 */
 var DiscoveredChildStatusSchema = _enum([
@@ -52410,12 +53310,12 @@ var DiscoveredChildDeviceSchema = lazy(() => object({
 	/** DeviceType the child should be created with on adopt. */
 	type: _enum(DeviceType),
 	status: DiscoveredChildStatusSchema,
-	/** Free-form integration-specific metadata surfaced in the panel. */
+	/** Free-form integration-specific metadata surfaced in the adoption modal. */
 	metadata: object({
 		model: string().optional(),
 		serialNumber: string().optional(),
 		uid: string().optional(),
-		/** Reolink: 0-based channel index inside the parent NVR/Hub. */
+		/** Reolink: 0-based channel index inside the parent NVR. */
 		rtspChannel: number$1().int().nonnegative().optional(),
 		isBattery: boolean().optional(),
 		isDoorbell: boolean().optional(),
@@ -52431,137 +53331,24 @@ var DiscoveredChildDeviceSchema = lazy(() => object({
 	}).default({}),
 	/**
 	* `true` when the framework already created a child device for this
-	* `childNativeId` under the current parent. The panel uses it to
+	* `childNativeId` under the current parent. The adoption modal uses it to
 	* gate the Add/Remove button and surface the existing `deviceId`.
 	*/
 	alreadyAdopted: boolean(),
 	/** When `alreadyAdopted=true`, the framework-assigned child device id. */
 	adoptedDeviceId: number$1().int().nonnegative().nullable(),
-	/** Capability names the candidate advertises — integrations populate, Hubs omit. */
+	/** Capability names the candidate advertises — integrations populate, flat enumerations omit. */
 	capabilities: array(string()).readonly().optional(),
-	/** Feature flags the candidate advertises — integrations populate, Hubs omit. */
+	/** Feature flags the candidate advertises — integrations populate, flat enumerations omit. */
 	features: array(string()).readonly().optional(),
 	/** Upstream-system identity + rendering hints for the candidate. */
 	sourceInfo: SourceInfoSchema.optional(),
-	/** Nested entity-children for accordion preview — integrations populate, Hubs omit. */
+	/** Nested entity-children for accordion preview — integrations populate, flat enumerations omit. */
 	children: array(DiscoveredChildDeviceSchema).readonly().optional(),
 	/** `childNativeId` of the gateway candidate in the same list this device sits behind. */
 	parentStableId: string().optional()
 }));
 /**
-* Status block — populated by the integration after each
-* `refreshDiscovery` (or push-driven update). The runtime-state slice
-* is what the panel reads via the per-device proxy; `getStatus`
-* returns the same payload via the codegen'd auto-injection.
-*/
-var DeviceDiscoveryStatusSchema = object({
-	discovered: array(DiscoveredChildDeviceSchema),
-	/** Wall-clock ms of the last successful enumeration. */
-	lastDiscoveryAt: number$1().int().nonnegative().nullable(),
-	/** Last error surfaced from the source (rendered as a banner). */
-	lastError: string().nullable()
-});
-var deviceDiscoveryCapability = {
-	name: "device-discovery",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.Hub],
-	status: {
-		schema: DeviceDiscoveryStatusSchema,
-		kind: "poll"
-	},
-	runtimeState: DeviceDiscoveryStatusSchema.extend({ lastFetchedAt: number$1().int().nonnegative() }),
-	/**
-	* Runtime-state durability: **session** — 5.7 KB of scan output on the largest device, fully re-derivable by re-scanning.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	/**
-	* History (D850): none — inventory.
-	*/
-	history: "none",
-	methods: {
-		/**
-		* Snapshot of the current `discovered` list. Returns the
-		* runtime-state cache — call `refreshDiscovery` first if a
-		* fresh round-trip to the source is required.
-		*/
-		listDiscovered: method(object({ deviceId: number$1().int().nonnegative() }), array(DiscoveredChildDeviceSchema).readonly()),
-		/**
-		* Force the integration to re-enumerate and update the
-		* runtime-state slice. Returns the freshly-enumerated list (also
-		* available via `listDiscovered` post-call).
-		*/
-		refreshDiscovery: method(object({ deviceId: number$1().int().nonnegative() }), array(DiscoveredChildDeviceSchema).readonly(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Promote a discovered entry to a real child device. The framework
-		* creates the child via `kernel.devices.create()` with
-		* `parentDeviceId = parent.id` and seeds the child's config from
-		* `childInitialConfig` (driver-defined; usually carries channel +
-		* uid + parent reference). Returns the kernel-assigned numeric id.
-		*/
-		adoptDevice: method(object({
-			deviceId: number$1().int().nonnegative(),
-			childNativeId: string(),
-			/** Optional override for the child's display name. */
-			name: string().optional()
-		}), object({
-			deviceId: number$1().int().nonnegative(),
-			stableId: string()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Inverse of `adoptDevice`: removes the child device from the
-		* kernel registry. The discovered entry remains in the
-		* enumeration (status updates resume) so the operator can re-adopt
-		* it later without a fresh refresh.
-		*/
-		releaseDevice: method(object({
-			deviceId: number$1().int().nonnegative(),
-			childDeviceId: number$1().int().nonnegative()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	}
-};
-/**
-* `device-adoption` — generic discovery + adoption surface,
-* system-scoped collection (one provider per integration addon), routed
-* by explicit `{ addonId }` on direct `deviceAdoption.*` calls — the same
-* pin model as `connection-test`. The admin UI keeps using
-* `deviceManager.adoption*` (which already threads `addonId`). The de-HA-ified
-* successor to `ha-discovery`:
-* keyed by `integrationId` (the addon resolves integrationId → broker
-* internally) rather than a connection-specific `brokerId`, and it
-* REUSES the shared `DiscoveredChildDevice` candidate type from
-* `device-discovery.cap.ts` so a single shared adoption panel renders
-* any integration's candidate tree.
-*
-* UI flow (Integrations page → integration detail):
-*   1. `listCandidates({integrationId, page, pageSize, filter})` →
-*      paginated candidate list, each row collapsed.
-*   2. User expands a row → `getCandidate({integrationId,
-*      childNativeId})` returns the single candidate (with its nested
-*      `children`) for the accordion render.
-*   3. User clicks "Adopt" on one or more candidates →
-*      `adopt({integrationId, childNativeIds, perCandidate?})`
-*      materialises one parent CamStack device per candidate plus its
-*      accessory children. `perCandidate[childNativeId]` carries an
-*      optional display-name override + a `hiddenChildIds` pre-hide set
-*      (the parent's `accessories.hiddenChildIds` gates UI visibility).
-*   4. User clicks "Release" → `release({integrationId, camDeviceId})`
-*      removes the parent + every child from the kernel registry.
-*/
-/**
 * Provider-declared discovery *granularity* filter (the keystone of the
 * single-entity-import design). A provider advertises which discovery
 * granularities it supports via `listCandidateFilters`; the operator picks
@@ -53022,6 +53809,90 @@ var SiteZoneSchema = object({
 	*  the ones that most want grouping. */
 	locationKeys: array(string())
 });
+var DeviceSearchRequiresSchema = object({
+	/** Capability names the field wants a value of. */
+	caps: array(string()).readonly(),
+	/** `any` (default): a device with one of them is compatible. `all`: it must hold every one. */
+	mode: _enum(["any", "all"]).optional()
+});
+var DeviceSearchFiltersSchema = object({
+	locations: array(string()).readonly().optional(),
+	integrationIds: array(string()).readonly().optional(),
+	types: array(string()).readonly().optional()
+});
+var DeviceSearchInputSchema = object({
+	/** Matches name, location, type, integration (id and label) and id. Case-insensitive. */
+	text: string().optional(),
+	requires: DeviceSearchRequiresSchema.optional(),
+	filters: DeviceSearchFiltersSchema.optional(),
+	/** List the devices that do not provide the required cap too (greyed, not pickable). */
+	includeIncompatible: boolean().optional(),
+	/** The device the field belongs to: its location drives `suggested`. */
+	contextDeviceId: number$1().optional(),
+	/**
+	* Resolve exactly these devices, regardless of every filter, so a picked
+	* value can be rendered. When given, `items` is these devices in the order
+	* asked (no paging, `nextCursor` null) and the ones that do not exist are
+	* listed in `missingIds`.
+	*/
+	ids: array(number$1()).readonly().optional(),
+	cursor: string().nullable().optional(),
+	limit: number$1().int().min(1).max(200).optional()
+});
+var DeviceValueOptionSchema = object({
+	cap: string(),
+	/** Status-schema field path inside the cap (same paths as `getWireableFields`). */
+	path: string(),
+	label: string(),
+	/** The current value as text; `null` when it is unknown or the read FAILED — never `0`. */
+	reading: string().nullable(),
+	unit: string().nullable().optional(),
+	/** The field's measured quantity, when the cap declares one, so a client can format the reading. */
+	quantity: ReadingQuantitySchema.optional()
+});
+var DeviceSearchItemSchema = object({
+	id: number$1(),
+	name: string(),
+	type: _enum(DeviceType),
+	location: string().nullable(),
+	integrationId: string().nullable(),
+	integrationLabel: string().nullable(),
+	online: boolean().nullable(),
+	disabled: boolean(),
+	compatible: boolean(),
+	/** Only the required caps' fields; empty when nothing was required or the device is incompatible. */
+	values: array(DeviceValueOptionSchema).readonly()
+});
+var DeviceSearchFacetValueSchema = object({
+	value: string(),
+	count: number$1()
+});
+var DeviceSearchFacetIntegrationSchema = object({
+	id: string(),
+	label: string(),
+	count: number$1()
+});
+var DeviceSearchFacetsSchema = object({
+	locations: array(DeviceSearchFacetValueSchema).readonly(),
+	integrations: array(DeviceSearchFacetIntegrationSchema).readonly(),
+	types: array(DeviceSearchFacetValueSchema).readonly()
+});
+var DeviceSearchResultSchema = object({
+	items: array(DeviceSearchItemSchema).readonly(),
+	nextCursor: string().nullable(),
+	/** Devices listed by this query across all pages (filters + text applied; incompatible counted only when `includeIncompatible`). */
+	total: number$1(),
+	/** Compatible devices after filters + text. */
+	compatibleTotal: number$1(),
+	/** Every device the caller's fleet holds, before anything is applied. */
+	fleetTotal: number$1(),
+	/** Incompatible devices after filters + text — the K of "show the K that don't". */
+	hiddenIncompatible: number$1(),
+	facets: DeviceSearchFacetsSchema,
+	/** Same location as `contextDeviceId`; first page only. */
+	suggested: array(DeviceSearchItemSchema).readonly(),
+	missingIds: array(number$1()).readonly()
+});
 var ProviderStatusSchema = object({
 	connected: boolean(),
 	deviceCount: number$1(),
@@ -53507,6 +54378,9 @@ var DeviceInfoSchema = object({
 	*  named accordion sections (with optional intra-section order). See
 	*  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
 	childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+	/** The children a container stands for, most preferred first, by accessory
+	*  `childKey`. Provider-declared. See `DeviceMeta.primaryChildPreference`. */
+	primaryChildPreference: array(string()).readonly().optional(),
 	/** Operator-authored per-device display override. See `DeviceMeta.display`. */
 	display: DeviceDisplayOverrideSchema.optional()
 });
@@ -53655,6 +54529,9 @@ var DeviceMetaSchema = object({
 	*  accordion sections (with optional intra-section order). See
 	*  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
 	childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+	/** The children a container stands for, most preferred first, by accessory
+	*  `childKey`. Provider-declared. See `DeviceMeta.primaryChildPreference`. */
+	primaryChildPreference: array(string()).readonly().optional(),
 	/** Semantic role string (`DeviceRole`) — propagated from the spawn pre-seed.
 	*  Optional: only present for accessory children that carry a known role. */
 	role: string().nullable().optional(),
@@ -53870,6 +54747,12 @@ method(object({
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	primaryChildPreference: array(string()).readonly()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	deviceId: number$1(),
 	display: DeviceDisplayOverrideSchema.nullable()
@@ -53893,8 +54776,14 @@ method(object({
 			"string",
 			"number",
 			"boolean",
-			"enum"
+			"enum",
+			"union"
 		]),
+		unionMembers: array(_enum([
+			"string",
+			"number",
+			"boolean"
+		])).optional(),
 		enumValues: array(string()).optional(),
 		item: boolean().optional(),
 		quantity: ReadingQuantitySchema.optional()
@@ -54007,7 +54896,7 @@ method(object({
 	* it answers today and the caller filters as it already does.
 	*/
 	deviceIds: array(number$1()).optional()
-}), array(DeviceInfoSchema), { role: "viewer" }), method(object({ deviceId: number$1() }), DeviceInfoSchema.nullable()), method(object({ parentDeviceId: number$1() }), array(DeviceInfoSchema), { role: "viewer" }), method(object({ parentDeviceIds: array(number$1()).max(256) }), record(string(), array(DeviceInfoSchema))), method(object({ deviceId: number$1() }), object({
+}), array(DeviceInfoSchema), { role: "viewer" }), method(DeviceSearchInputSchema, DeviceSearchResultSchema, { role: "viewer" }), method(object({ deviceId: number$1() }), DeviceInfoSchema.nullable()), method(object({ parentDeviceId: number$1() }), array(DeviceInfoSchema), { role: "viewer" }), method(object({ parentDeviceIds: array(number$1()).max(256) }), record(string(), array(DeviceInfoSchema))), method(object({ deviceId: number$1() }), object({
 	mode: LinkedDevicesModeSchema,
 	devices: array(LinkedDeviceSchema)
 }), { role: "viewer" }), method(object({ deviceIds: array(number$1()) }), array(LinkedDevicesForDeviceSchema), { role: "viewer" }), method(object({ deviceId: number$1() }), array(StreamSourceEntrySchema$1)), method(object({ deviceId: number$1() }), array(ConfigEntrySchema)), method(object({ deviceId: number$1() }), ConfigUISchemaOutput), method(object({
@@ -55986,53 +56875,6 @@ var enumSensorCapability = {
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt", "timestamp"]
 };
-/**
-* Generic stateless event emitter. Installed on a `DeviceType.EventEmitter`
-* device. Carries the device's EXACT declared event vocabulary verbatim
-* (NO normalization). Two shapes:
-*  - structured source (HA `event.*` entity) → `eventTypes` is the fixed
-*    declared vocabulary (e.g. ['press_short','press_long',...]).
-*  - generic/legacy source (HA bus events, e.g. zha_event) → `eventTypes`
-*    is [] (open) and `lastEvent.data` carries the complex payload.
-* `seq` is monotonic so two identical events still produce distinct slice writes.
-*/
-var EventFireSchema = object({
-	deviceId: number$1(),
-	eventType: string(),
-	data: record(string(), unknown()).nullable(),
-	timestamp: number$1().meta(readingMeta("none")),
-	seq: number$1().meta(readingMeta("count"))
-});
-var EventEmitterStatusSchema = object({
-	eventTypes: array(string()),
-	lastEvent: EventFireSchema.nullable(),
-	eventCountSinceStart: number$1().meta(readingMeta("count"))
-});
-var eventEmitterCapability = {
-	name: "event-emitter",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.EventEmitter],
-	methods: {},
-	events: { onEvent: { data: EventFireSchema } },
-	status: {
-		schema: EventEmitterStatusSchema,
-		kind: "push"
-	},
-	runtimeState: EventEmitterStatusSchema,
-	/**
-	* Runtime-state durability: **session** — `eventCountSinceStart` names its own scope.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	/**
-	* History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
-	*/
-	history: "none"
-};
 var IdentitySchema = object({
 	id: string(),
 	name: string(),
@@ -56522,8 +57364,85 @@ method(_void(), array(FailureContributionSchema).readonly());
 *   - `FanPreset` — preset selector
 *   - `FanDirection` — direction toggle (ceiling fans)
 *   - `FanOscillating` — oscillation toggle
+*
+* Per-axis oscillation (`oscillationAxes`, `setOscillationAxis`, D1034): an air
+* circulator sweeps horizontally and vertically, each axis with its own
+* switch, fixed angle, sweep bounds and limits. A provider may report them
+* natively; otherwise the OPERATOR links sibling devices to each field in
+* Customize (a `replace` over the fields listed in `overridable` — nothing is
+* linked or inferred by itself), and a write to a linked field is forwarded to
+* its source. `oscillating` stays the single summary flag: when axes exist it
+* means "any axis oscillates" (`anyAxisOscillating`).
 */
 var FanDirectionSchema = _enum(["forward", "reverse"]);
+var FAN_OSCILLATION_AXES = ["horizontal", "vertical"];
+var FanOscillationAxisNameSchema = _enum(FAN_OSCILLATION_AXES);
+var FanOscillationAxisFieldSchema = _enum([
+	"oscillating",
+	"angle",
+	"sweepFrom",
+	"sweepTo"
+]);
+/** The limits of one axis, read from the source that serves its angle. */
+var FAN_OSCILLATION_AXIS_LIMITS = [
+	"min",
+	"max",
+	"step"
+];
+/**
+* One oscillation axis. Every reading the device has not reported is `null`,
+* never `0` (D393): `0°` is a real position. Each leaf defaults to `null`, so
+* a slice that names only the leaves it knows (a Customize link of one field)
+* is still a whole axis.
+*/
+var FanOscillationAxisSchema = object({
+	/** Whether the axis sweeps. */
+	oscillating: boolean().nullable().default(null),
+	/** The fixed position (degrees) the axis holds when it does not sweep. */
+	angle: number$1().nullable().default(null),
+	/** The sweep bounds (degrees): left → right, bottom → top. */
+	sweepFrom: number$1().nullable().default(null),
+	sweepTo: number$1().nullable().default(null),
+	/** The angles the axis accepts. Null when the device states none. */
+	min: number$1().nullable().default(null),
+	max: number$1().nullable().default(null),
+	step: number$1().nullable().default(null)
+});
+/** Both axes; an axis the device does not have is `null`. */
+var FanOscillationAxesSchema = object({
+	horizontal: FanOscillationAxisSchema.nullable().default(null),
+	vertical: FanOscillationAxisSchema.nullable().default(null)
+});
+var FanOscillationAxisRefusalSchema = _enum([
+	"nothing-to-set",
+	"axis-not-linked",
+	"out-of-range",
+	"source-gone",
+	"source-unknown",
+	"source-call-failed"
+]);
+var FanOscillationAxisResultSchema = discriminatedUnion("status", [object({ status: literal("applied") }), object({
+	status: literal("refused"),
+	reason: FanOscillationAxisRefusalSchema,
+	/** The field at fault, when one is. */
+	field: FanOscillationAxisFieldSchema.optional(),
+	/** One line for the operator, naming the axis, the field and the source. */
+	detail: string(),
+	/** Fields that DID land before the refusal (writes run in order, stop at the first failure). */
+	applied: array(FanOscillationAxisFieldSchema)
+})]);
+var SetOscillationAxisInputSchema = object({
+	deviceId: number$1().int().nonnegative(),
+	axis: FanOscillationAxisNameSchema,
+	oscillating: boolean().optional(),
+	angle: number$1().optional(),
+	sweepFrom: number$1().optional(),
+	sweepTo: number$1().optional()
+});
+/** The state path of one axis field: `oscillationAxes.<axis>.<field>`. */
+function fanAxisPath(axis, field) {
+	return `oscillationAxes.${axis}.${field}`;
+}
 var FanControlStatusSchema = object({
 	/** Active speed as 0..100 inclusive. Null when the device has no
 	*  speed surface (single-speed fan). */
@@ -56542,9 +57461,102 @@ var FanControlStatusSchema = object({
 	/** Oscillation toggle. Null when the device has no oscillation
 	*  surface. */
 	oscillating: boolean().nullable(),
+	/**
+	* Per-axis oscillation (air circulators). Absent when the device has no
+	* per-axis surface and nothing is linked in Customize.
+	*/
+	oscillationAxes: FanOscillationAxesSchema.optional(),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: number$1()
 });
+var FAN_CUSTOMIZE_DEVICE_TYPES = [DeviceType.Fan];
+/** The Customize section the axis targets are listed under. */
+var AXES_SECTION = "oscillation-axes";
+function axisOscillatingTarget(axis) {
+	return {
+		id: `${axis}-oscillating`,
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "fan-control",
+			stateField: "oscillating"
+		},
+		deviceTypes: FAN_CUSTOMIZE_DEVICE_TYPES,
+		apply: "replace",
+		section: AXES_SECTION,
+		path: fanAxisPath(axis, "oscillating"),
+		sources: [{
+			kind: "switch",
+			transforms: [{ kind: "identity" }]
+		}],
+		sourceReport: { status: "assignment-status" }
+	};
+}
+/**
+* A numeric axis field. The `angle` link also carries the axis limits, read
+* from the SAME linked control's own range (`min`/`max`/`step`), so the limits
+* are the source's, never guessed.
+*/
+function axisNumericTarget(axis, field) {
+	const base = {
+		id: `${axis}-${field}`,
+		cardinality: "scalar",
+		vocabulary: { cap: "fan-control" },
+		deviceTypes: FAN_CUSTOMIZE_DEVICE_TYPES,
+		apply: "replace",
+		section: AXES_SECTION,
+		path: fanAxisPath(axis, field),
+		sources: [{
+			kind: "numeric",
+			transforms: [{ kind: "identity" }]
+		}],
+		sourceReport: { status: "assignment-status" }
+	};
+	if (field !== "angle") return base;
+	return {
+		...base,
+		companions: FAN_OSCILLATION_AXIS_LIMITS.map((limit) => ({
+			kind: "source-field",
+			path: fanAxisPath(axis, limit),
+			field: limit
+		}))
+	};
+}
+var AXIS_TARGETS = FAN_OSCILLATION_AXES.flatMap((axis) => [
+	axisOscillatingTarget(axis),
+	axisNumericTarget(axis, "angle"),
+	axisNumericTarget(axis, "sweepFrom"),
+	axisNumericTarget(axis, "sweepTo")
+]);
+/** A select (an enum control) the operator links to the fan's `preset`. */
+var PRESET_TARGET = {
+	id: "preset",
+	cardinality: "scalar",
+	vocabulary: { cap: "fan-control" },
+	deviceTypes: FAN_CUSTOMIZE_DEVICE_TYPES,
+	apply: "replace",
+	path: "preset",
+	sources: [{
+		kind: "field",
+		valueKinds: ["string"],
+		transforms: [{ kind: "identity" }]
+	}],
+	sourceReport: { status: "assignment-status" }
+};
+var FAN_CONTROL_TARGETS = [...AXIS_TARGETS, PRESET_TARGET];
+/**
+* Customize (D1034): the fan already serves `fan-control` natively, so every
+* target is a `replace` over a field listed in `overridable` — the axis leaves
+* and `preset`, nothing else. Nothing is pre-linked: the operator picks each
+* source (D356).
+*/
+var fanControlCustomize = {
+	version: 1,
+	overridable: FAN_CONTROL_TARGETS.map((target) => ({
+		path: target.path,
+		by: target.id
+	})),
+	targets: FAN_CONTROL_TARGETS
+};
 var fanControlCapability = {
 	name: "fan-control",
 	scope: "device",
@@ -56579,6 +57591,18 @@ var fanControlCapability = {
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
+		}),
+		/**
+		* Sets one oscillation axis: its switch, fixed angle and/or sweep bounds.
+		* Fields left out are untouched. A field linked in Customize is forwarded
+		* to its linked source (D1034); otherwise the native provider serves it;
+		* neither → `axis-not-linked`. Ranges are checked against the axis limits
+		* before anything is written; writes run in order and stop at the first
+		* failure, which the result names.
+		*/
+		setOscillationAxis: optionalMethod(SetOscillationAxisInputSchema, FanOscillationAxisResultSchema, {
+			kind: "mutation",
+			auth: "protected"
 		})
 	},
 	status: {
@@ -56590,6 +57614,7 @@ var fanControlCapability = {
 	* sliders read `speed` for live updates.
 	*/
 	runtimeState: FanControlStatusSchema,
+	customize: fanControlCustomize,
 	/**
 	* Runtime-state durability: **session** — as `brightness`.
 	*
@@ -56609,16 +57634,33 @@ var fanControlCapability = {
 		oscillating: { kind: "boolean" }
 	} }
 };
+/** One axis as a preset wants it; an absent field is left as it is. */
+var FanPresetAxisSchema = object({
+	oscillating: boolean().optional(),
+	angle: number$1().optional(),
+	sweepFrom: number$1().optional(),
+	sweepTo: number$1().optional()
+});
+/** The fan-control state a preset sets; an absent field is left as it is. */
+var FanPresetStateSchema = object({
+	speed: number$1().min(0).max(100).optional(),
+	/** The fan's own preset mode (or the linked select's option). */
+	preset: string().min(1).optional(),
+	direction: FanDirectionSchema.optional(),
+	oscillationAxes: object({
+		horizontal: FanPresetAxisSchema.optional(),
+		vertical: FanPresetAxisSchema.optional()
+	}).optional()
+});
 var FanPresetSchema = object({
 	/** Stable key; never reused after a delete within one device's list. */
 	id: string().min(1).max(64),
 	/** What the operator and a voice assistant call it. */
 	name: string().trim().min(1).max(40),
-	steps: array(ActionStepSchema).min(1).max(20)
+	state: FanPresetStateSchema
 });
 var FanPresetsRefusalSchema = _enum([
-	"not-sibling",
-	"bad-target",
+	"empty-state",
 	"duplicate-name",
 	"duplicate-id",
 	"too-many",
@@ -56630,72 +57672,55 @@ var FanPresetsSetResultSchema = discriminatedUnion("status", [object({
 }), object({
 	status: literal("refused"),
 	reason: FanPresetsRefusalSchema,
-	/** Names the preset and step at fault. */
+	/** Names the preset at fault. */
 	detail: string()
 })]);
-var FanPresetStepResultSchema = object({
-	index: number$1().int().nonnegative(),
+var FanPresetFieldResultSchema = object({
+	/** The state path: `speed`, `preset`, `direction`, `oscillationAxes.horizontal.angle`. */
+	field: string(),
 	outcome: _enum([
 		"applied",
 		"failed",
 		"not-run",
 		"refused"
 	]),
-	deviceId: number$1().int().nonnegative().optional(),
-	cap: string().optional(),
-	method: string().optional(),
 	/** The cause, for every outcome but `applied`. */
 	message: string().optional()
 });
 var FanPresetApplyResultSchema = object({
-	/** `applied`: every step ran. `partial`: some ran, one failed. `refused`: nothing ran. */
+	/** `applied`: every field landed. `partial`: some did, one did not. `refused`: nothing ran. */
 	status: _enum([
 		"applied",
 		"partial",
 		"refused"
 	]),
-	steps: array(FanPresetStepResultSchema)
+	fields: array(FanPresetFieldResultSchema)
 });
 var FanCaptureFieldSchema = _enum([
 	"speed",
-	"oscillating",
 	"direction",
-	"preset"
+	"preset",
+	"oscillationAxes"
 ]);
-var FanCaptureOmissionSchema = object({
-	/** A fan field (`speed`) or `step <n>` for a sibling step. */
-	what: string(),
-	/** Why no value was taken: unknown reading (never stored as 0, D393), or a step that cannot be read. */
-	reason: string()
-});
-var FanCaptureItemSchema = object({
-	group: _enum([
-		"fan",
-		"oscillation",
-		"angles"
-	]),
-	/** What the step sets, in the operator's words (a device name, a fan field). */
-	label: string()
-});
 var FanPresetCaptureResultSchema = object({
-	/** The steps filled from the device's current values; NOT saved. */
-	steps: array(ActionStepSchema),
-	/** One entry per step, same order: its review group and label. */
-	items: array(FanCaptureItemSchema),
-	omitted: array(FanCaptureOmissionSchema)
+	/** The fan's CURRENT fan-control state, as a preset; NOT saved. */
+	state: FanPresetStateSchema,
+	omitted: array(object({
+		/** A state path (`speed`, `oscillationAxes.vertical.angle`). */
+		what: string(),
+		/** Why no value was taken: an unknown reading is never stored as 0 (D393). */
+		reason: string()
+	}))
 });
-var deviceInput$2 = object({ deviceId: number$1().int().nonnegative() });
+var deviceInput$1 = object({ deviceId: number$1().int().nonnegative() });
 DeviceType.Fan;
-method(deviceInput$2, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$2.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
+method(deviceInput$1, array(FanPresetSchema), { auth: "protected" }), method(deviceInput$1.extend({ presets: array(FanPresetSchema).max(12) }), FanPresetsSetResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(deviceInput$2.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
+}), method(deviceInput$1.extend({ presetId: string().min(1) }), FanPresetApplyResultSchema, {
 	kind: "mutation",
 	auth: "protected"
-}), method(deviceInput$2.extend({
-	fields: array(FanCaptureFieldSchema).optional(),
-	steps: array(ActionStepSchema).max(20).default([])
-}), FanPresetCaptureResultSchema, { auth: "protected" });
+}), method(deviceInput$1.extend({ fields: array(FanCaptureFieldSchema).optional() }), FanPresetCaptureResultSchema, { auth: "protected" });
 /**
 * Per-device feature/identity probe slice. Holds the runtime-resolved
 * truth about what a device CAN do — which the kernel uses to:
@@ -56907,8 +57932,7 @@ var groupActiveCapability = {
 		DeviceType.Valve,
 		DeviceType.Lock,
 		DeviceType.MediaPlayer,
-		DeviceType.Climate,
-		DeviceType.Thermostat
+		DeviceType.Climate
 	],
 	methods: {},
 	status: {
@@ -56950,7 +57974,6 @@ var groupCommandsCapability = {
 		DeviceType.Valve,
 		DeviceType.Lock,
 		DeviceType.MediaPlayer,
-		DeviceType.Thermostat,
 		DeviceType.Climate
 	],
 	methods: {},
@@ -57006,7 +58029,6 @@ var groupStatusCapability = {
 		DeviceType.Valve,
 		DeviceType.Lock,
 		DeviceType.MediaPlayer,
-		DeviceType.Thermostat,
 		DeviceType.Climate
 	],
 	methods: {},
@@ -57335,7 +58357,7 @@ var heatingValveCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Thermostat],
+	deviceTypes: [DeviceType.Climate],
 	methods: {},
 	status: {
 		schema: HeatingValveStatusSchema,
@@ -57365,13 +58387,18 @@ var heatingValveCapability = {
 * retried in a loop - D49); a future one is re-armed.
 *
 * What a device may be run for, and for how long at most, is per device type
-* ({@link TIMED_RUN_LIMITS}): the maximum is a safety bound, not a preference,
+* and role ({@link timedRunLimitOf}): the maximum is a safety bound, not a preference,
 * so a request above it is REFUSED with a typed reason, never clamped.
 */
 var TimedRunUnitSchema = _enum(["s", "min"]);
 _enum(["switch", "pet-fountain"]);
-DeviceType.Heater, DeviceType.PetFountain;
-var TIMED_RUN_DEVICE_TYPES = [DeviceType.Heater, DeviceType.PetFountain];
+/**
+* The device types `timed-run` may be offered on. A `switch` is narrowed by
+* role ({@link TIMED_RUN_DEVICE_ROLES}): only a plug-in heater runs on a timer.
+*/
+var TIMED_RUN_DEVICE_TYPES = [DeviceType.Switch, DeviceType.PetFountain];
+/** The roles that make a device of these types timed-run-able (D1033). */
+var TIMED_RUN_DEVICE_ROLES = { [DeviceType.Switch]: [DeviceRole.SwitchHeater] };
 /** One duration, as the one-tap run asks for it. */
 var TimedRunQuickRunSchema = object({
 	duration: number$1().positive().finite(),
@@ -57421,6 +58448,7 @@ var timedRunCapability = {
 	kind: "wrapper",
 	defaultActive: true,
 	deviceTypes: TIMED_RUN_DEVICE_TYPES,
+	deviceRoles: TIMED_RUN_DEVICE_ROLES,
 	deviceConfig: { ui: {
 		kind: "derived-form",
 		builderId: "timed-run",
@@ -57581,8 +58609,8 @@ 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.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;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, 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.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.SwitchHeater, DeviceRole.SwitchFan, DeviceRole.ClimateAc, DeviceRole.ClimateThermostat, DeviceRole.ClimateFloor, DeviceRole.ClimateRadiator, DeviceRole.ClimateHeater, DeviceRole.ClimateHeatPumpCircuit, 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({
 	en: string(),
@@ -57648,13 +58676,11 @@ var HeroConfirmSchema = _enum([
 	"press"
 ]);
 var HeroActionSchema = object({
-	/** Unique within the model; the `gated` list and the specs name it. */
 	id: string(),
 	label: HeroTextSchema,
 	icon: IconKeySchema,
 	call: HeroCallSchema,
 	emphasis: _enum(["primary", "normal"]),
-	/** Ask before running it. */
 	confirm: HeroConfirmSchema.nullable()
 });
 var HeroControlSchema = discriminatedUnion("kind", [
@@ -57705,6 +58731,8 @@ var HeroPillSchema = object({
 });
 var HeroRowSchema = object({
 	id: HeroRowIdSchema,
+	/** `scene`: the row's action and slider controls are drawn on the scene. Absent: an ordinary row. */
+	placement: _enum(["row", "scene"]).optional(),
 	/** 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"). */
@@ -57735,9 +58763,16 @@ var HeroBadgeSchema = object({
 	value: number$1().nullable(),
 	label: HeroTextSchema
 });
-var HeroRemoteSlotSchema = object({ 
-/** Saved commands; `null` = not known yet (the button still shows). */
-commands: number$1().int().nullable() });
+var HeroRemoteSlotSchema = object({
+	/** Saved commands; `null` = not known yet (the button still shows). */
+	commands: number$1().int().nullable(),
+	/**
+	* The control a list row draws as the "open the remote" icon. Recognised by its id
+	* ({@link REMOTE_OPEN_ACTION_ID}); it changes no state, so a client opens the remote
+	* instead of running `call`. Absent on a model from an older server.
+	*/
+	open: HeroActionSchema.optional()
+});
 var HeroConsumablesSlotSchema = object({
 	items: array(object({
 		key: string(),
@@ -57905,6 +58940,8 @@ var HeroModelSchema = object({
 *     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 climate or thermostat row's primary is its `climate.mode` control (no power
+*     toggle: "off" is a mode); when the model gates it the rule above applies as before;
 *   - 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
@@ -57912,6 +58949,13 @@ var HeroModelSchema = object({
 *     time left on an armed timed run;
 *   - the trailing fact is the first of power, battery, consumables.
 *
+*   - `extras` are the further inline controls of the types that carry more than one
+*     ({@link ROW_EXTRAS_BY_TYPE}): climate setpoint, a robot's return to base,
+*     a player's volume and remote. Each is a control the model already has, named by id,
+*     in that order and at most {@link ROW_EXTRAS_MAX}; one the model lacks, or lists in
+*     `gated`, is absent, and the one `primary` already is never repeats. Empty = the
+*     row of an older server: `primary` alone.
+*
 * `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.
@@ -57943,8 +58987,16 @@ var HeroRowModelSchema = object({
 	* while armed. `null` when there is no slot, or the caller may not act.
 	*/
 	timedRun: HeroRowTimedRunSchema.nullable(),
+	/**
+	* The further inline controls after `primary`, in order (see the header). The remote
+	* is an `action` with id `remote.open`: the client opens the remote, it does not run
+	* the call. Absent or empty = `primary` alone.
+	*/
+	extras: array(HeroControlSchema).max(2).optional(),
 	trailing: HeroFactSchema.nullable()
 });
+DeviceType.Climate;
+DeviceType.Climate, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer;
 /**
 * hero-layout — what a device's hero says (D1023). Read-only: the FIXED
 * layouts live in `@camstack/types` and nothing here stores or edits one.
@@ -57976,7 +59028,10 @@ method(heroInput, HeroModelSchema.nullable(), {
 }), method(rowModelsInput, array(HeroRowModelSchema.nullable()), {
 	auth: "protected",
 	role: "viewer"
-}), method(object({ deviceType: string() }), HeroLayoutRowsSchema, {
+}), method(object({
+	deviceType: string(),
+	role: string().nullable().optional()
+}), HeroLayoutRowsSchema, {
 	auth: "protected",
 	role: "viewer"
 });
@@ -58023,6 +59078,11 @@ var humidifierCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Humidifier],
+	power: {
+		kind: "field",
+		field: "on",
+		set: "setOn"
+	},
 	methods: {
 		setOn: method(object({
 			deviceId: number$1().int().nonnegative(),
@@ -58096,7 +59156,7 @@ var humiditySensorCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Sensor, DeviceType.Thermostat],
+	deviceTypes: [DeviceType.Sensor, DeviceType.Climate],
 	methods: {},
 	status: {
 		schema: HumiditySensorStatusSchema,
@@ -58390,6 +59450,12 @@ var IntegrationLiteSchema = object({
 var AvailableIntegrationTypeSchema = object({
 	addonId: string(),
 	name: string(),
+	/**
+	* Product name a new integration is prefilled from (`<label> - Home`).
+	* Absent: the client uses `name`. Set when the catalog title is not the
+	* product (Bosch SHC, MQTT).
+	*/
+	providerLabel: string().optional(),
 	description: string(),
 	iconUrl: string().nullable(),
 	color: string(),
@@ -69494,13 +70560,23 @@ var NcRuleTargetSchema = object({
 	*/
 	params: record(string(), unknown()).optional()
 });
+/** Which picture kind one target receives (#487). */
+var NcTargetAttachmentSchema = _enum([
+	"none",
+	"image",
+	"clip",
+	"gif"
+]);
 var NcTargetOverrideSchema = object({
 	template: object({
 		title: string().max(500).optional(),
 		body: string().max(2e3).optional()
 	}).optional(),
 	schedule: NcScheduleSchema.optional(),
-	priority: number$1().int().min(1).max(5).optional()
+	priority: number$1().int().min(1).max(5).optional(),
+	attachment: NcTargetAttachmentSchema.optional(),
+	/** `false` = no buttons for this target; `true` is the same as absent. */
+	actions: boolean().optional()
 });
 /** Per-target settings keyed by target id (#487). */
 var NcTargetOverridesSchema = record(string(), NcTargetOverrideSchema);
@@ -71268,7 +72344,18 @@ var OauthIntegrationDescriptorSchema = object({
 	* The value is baked into the authorization code at `/authorize` and travels
 	* on the tokens, so editing this field changes FUTURE links only.
 	*/
-	refreshTokenTtlSec: union([number$1().int().positive(), literal("never")]).optional()
+	refreshTokenTtlSec: union([number$1().int().positive(), literal("never")]).optional(),
+	/**
+	* The integration instances an account can be linked to (planning#415),
+	* beside the default one. `/api/oauth2/authorize?instance=<id>` is accepted
+	* only for an id listed here; with no `instance=` the link is made to the
+	* default instance, which is never listed and always accepted — it is the
+	* address third parties already hold. Omit for a single-instance integration.
+	*/
+	instances: array(object({
+		id: string(),
+		displayName: string()
+	})).optional()
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
@@ -71691,9 +72778,13 @@ var petFeederCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): recorded series.
+	* History (D850): recorded series. `feeding` / `eating` are the meals the
+	* device hero's "Meals" button names — change-only booleans, so a dispense
+	* or a pet at the bowl is one span on the history.
 	*/
 	history: { fields: {
+		feeding: { kind: "boolean" },
+		eating: { kind: "boolean" },
 		foodLevel: { kind: "gauge" },
 		bowlFood: { kind: "gauge" },
 		food1: { kind: "gauge" },
@@ -71754,6 +72845,11 @@ var petFountainCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.PetFountain],
+	power: {
+		kind: "field",
+		field: "pumpRunning",
+		set: "setPump"
+	},
 	methods: { 
 	/** Start or stop the pump. */
 setPump: method(object({
@@ -73329,7 +74425,6 @@ var POWER_METER_DEVICE_TYPES = [
 	DeviceType.Light,
 	DeviceType.Fan,
 	DeviceType.Climate,
-	DeviceType.Thermostat,
 	DeviceType.Humidifier,
 	DeviceType.WaterHeater,
 	DeviceType.MediaPlayer,
@@ -73338,8 +74433,7 @@ var POWER_METER_DEVICE_TYPES = [
 	DeviceType.Dishwasher,
 	DeviceType.Vacuum,
 	DeviceType.LawnMower,
-	DeviceType.PetFeeder,
-	DeviceType.Heater
+	DeviceType.PetFeeder
 ];
 /** Everything but a bare `Sensor`: a sensor that takes its reading from another sensor adds nothing. */
 var POWER_METER_CUSTOMIZE_DEVICE_TYPES = POWER_METER_DEVICE_TYPES.filter((type) => type !== DeviceType.Sensor);
@@ -73452,118 +74546,6 @@ var powerMeterCapability = {
 	volatileStateFields: ["lastFetchedAt"],
 	customize: powerMeterCustomize
 };
-var PowerSourceRefusalReasonSchema = _enum([
-	"no-power-source",
-	"switch-missing",
-	"switch-offline",
-	"switch-unknown",
-	"restart-in-progress",
-	"switch-call-failed"
-]);
-var PowerSourceActionResultSchema = discriminatedUnion("accepted", [object({ accepted: literal(true) }), object({
-	accepted: literal(false),
-	reason: PowerSourceRefusalReasonSchema,
-	/** One line for the operator, naming the switch. */
-	message: string()
-})]);
-var PowerSourceInfoSchema = object({
-	/** False when the device has no power source linked; the rest is then empty. */
-	linked: boolean(),
-	switchDeviceId: number$1().nullable(),
-	switchName: string().nullable(),
-	/** The switch's on/off state, or null when it is unknown. Never false for unknown (D393). */
-	switchOn: boolean().nullable(),
-	switchOnline: boolean().nullable(),
-	restartInProgress: boolean(),
-	offSeconds: number$1().int()
-});
-/** The composed slice: the switch state the link mirrors, plus the stored off time. */
-var PowerSourceStateSchema = object({
-	/** Null while the switch has not reported: unknown is never `false` (D393). */
-	switchOn: boolean().nullable(),
-	offSeconds: number$1().int(),
-	lastFetchedAt: number$1()
-});
-var POWER_SOURCE_DEVICE_TYPES = [
-	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
-];
-var powerSourceCustomize = {
-	version: 1,
-	targets: [{
-		id: "switch",
-		cardinality: "scalar",
-		vocabulary: {
-			cap: "power-source",
-			stateField: "switchOn"
-		},
-		deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-		apply: "add",
-		path: "switchOn",
-		sources: [{
-			kind: "switch",
-			transforms: [{ kind: "identity" }]
-		}],
-		companions: [{
-			kind: "constant",
-			path: "offSeconds",
-			value: 10,
-			when: "add",
-			formerValues: [0]
-		}, {
-			kind: "clock",
-			path: "lastFetchedAt",
-			when: "always"
-		}],
-		sourceReport: { status: "assignment-status" }
-	}]
-};
-var deviceInput$1 = object({ deviceId: number$1().int().nonnegative() });
-var powerSourceCapability = {
-	name: "power-source",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
-	methods: {
-		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "admin" }),
-		powerOn: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		powerOff: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		forceRestart: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	runtimeState: PowerSourceStateSchema,
-	customize: powerSourceCustomize,
-	/**
-	* Runtime-state durability: **session** — mirrored from the linked switch on
-	* its next report; a restored value would outlive the reading it names.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	history: "none"
-};
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
 * on `DeviceType.Presence`. Read-only — no setters: presence is
@@ -77030,9 +78012,7 @@ var RUNNING_CUSTOMIZE_DEVICE_TYPES = [
 	DeviceType.Humidifier,
 	DeviceType.Fan,
 	DeviceType.Climate,
-	DeviceType.Thermostat,
-	DeviceType.PetFeeder,
-	DeviceType.Heater
+	DeviceType.PetFeeder
 ];
 var runningStateCapability = {
 	name: "running-state",
@@ -78304,6 +79284,13 @@ var SsoBridgeClaimsSchema = object({
 	/** OAuth authorization-code binding — set only on `oauth-code` tokens. */
 	redirectUri: string().optional(),
 	integrationId: string().optional(),
+	/**
+	* The integration INSTANCE an OAuth link was made for (planning#415). Set on
+	* `oauth-code`, `oauth-access` and `oauth-refresh` tokens of a link made
+	* with `instance=`; absent on a link to the default instance. A cloud relay
+	* reads it off the access token to route; the hub answers from the session.
+	*/
+	instanceId: string().optional(),
 	/** JWT ID — unique per issued code; consumed-set enforces single-use. */
 	jti: string().optional(),
 	/** PKCE S256 challenge — set only on `oauth-code` tokens issued to a public
@@ -79120,8 +80107,7 @@ var switchCapability = {
 		DeviceType.Switch,
 		DeviceType.Siren,
 		DeviceType.Light,
-		DeviceType.Fan,
-		DeviceType.Heater
+		DeviceType.Fan
 	],
 	methods: { setState: method(object({
 		deviceId: number$1(),
@@ -79815,7 +80801,7 @@ var temperatureSensorCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Sensor, DeviceType.Thermostat],
+	deviceTypes: [DeviceType.Sensor, DeviceType.Climate],
 	methods: {},
 	status: {
 		schema: TemperatureSensorStatusSchema,
@@ -80683,6 +81669,8 @@ var OauthSessionSummarySchema = object({
 	userId: string(),
 	username: string(),
 	integrationId: string(),
+	/** The instance the link was made for; `null` = the default instance. */
+	instanceId: string().nullable().optional(),
 	scopes: array(TokenScopeSchema),
 	createdAt: number$1(),
 	lastUsedAt: number$1(),
@@ -80782,6 +81770,9 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(_void(), ob
 	access: "view"
 }), method(object({
 	integrationId: string(),
+	/** The integration instance the link is for. Omit for the default
+	*  instance — never pass the addon id to mean it. */
+	instanceId: string().optional(),
 	userId: string(),
 	username: string(),
 	scopes: array(TokenScopeSchema),
@@ -80820,7 +81811,13 @@ method(_void(), array(UserSummarySchema), { auth: "admin" }), method(_void(), ob
 }), method(object({ token: string() }), object({
 	userId: string(),
 	username: string(),
-	scopes: array(TokenScopeSchema)
+	scopes: array(TokenScopeSchema),
+	/** The instance the link was made for, read from the SESSION.
+	*  Absent = the default instance. `oauthLinkServesInstance` is the
+	*  helper a per-instance route calls to compare it with the instance
+	*  of its path; no route declares `perInstance` yet (the Alexa
+	*  per-instance route, T3, is the first consumer). */
+	instanceId: string().optional()
 }).nullable(), { access: "view" }), method(object({ userId: string() }), array(ExternalIdentitySchema), { auth: "admin" }), method(ExternalIdentityKeySchema, object({
 	userId: string(),
 	issuer: string()
@@ -81462,6 +82459,13 @@ var waterHeaterCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.WaterHeater],
+	power: {
+		kind: "mode",
+		field: "operationMode",
+		offValue: "off",
+		set: "setOperationMode",
+		lastField: "lastActiveMode"
+	},
 	methods: {
 		setTargetTemp: method(object({
 			deviceId: number$1().int().nonnegative(),
@@ -83120,7 +84124,6 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	control: controlCapability,
 	cover: coverCapability,
 	dayNight: dayNightCapability,
-	deviceDiscovery: deviceDiscoveryCapability,
 	deviceStatus: deviceStatusCapability,
 	dishwasher: dishwasherCapability,
 	doNotDisturb: doNotDisturbCapability,
@@ -84215,15 +85218,16 @@ var BaseDeviceProvider = class extends BaseAddon {
 		});
 		const meta = await this.ctx.api.deviceManager.loadMeta.query({ deviceId: id });
 		if (meta === null) throw new Error(`${this.providerName}: no persisted meta for "${stableId}" (id ${id}) — cannot reload`);
-		const deviceType = Object.values(DeviceType).find((t) => t === meta.type);
-		const Class = deviceType !== void 0 ? this.deviceClasses[deviceType] : void 0;
+		const Class = this.deviceClassForRow({
+			type: meta.type,
+			stableId
+		});
 		if (!Class) throw new Error(`${this.providerName}: no device class for type "${meta.type}" — "${stableId}" is an accessory child; reload its parent instead`);
 		await devices.create(stableId, Class, {}, meta.parentDeviceId ?? null);
 		const rows = await this.ctx.api.deviceManager.listPersistedByAddon.query({ addonId: this.addonId });
 		for (const row of rows) {
 			if (row.parentDeviceId !== id) continue;
-			const childType = Object.values(DeviceType).find((t) => t === row.type);
-			const ChildClass = childType !== void 0 ? this.deviceClasses[childType] : void 0;
+			const ChildClass = this.deviceClassForRow(row);
 			if (!ChildClass) continue;
 			try {
 				await devices.create(row.stableId, ChildClass, {}, id);
@@ -84250,6 +85254,16 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return { deviceId: id };
 	}
 	/**
+	* The class a PERSISTED row is rebuilt with. Default: by type, from
+	* `deviceClasses`. A provider whose distinct devices share one type (D1033:
+	* a radiator valve and a room climate are both `climate`) overrides this
+	* and tells them apart by the row's stable id or config.
+	*/
+	deviceClassForRow(row) {
+		const type = Object.values(DeviceType).find((t) => t === row.type);
+		return type !== void 0 ? this.deviceClasses[type] : void 0;
+	}
+	/**
 	* Restore devices from persisted state. Two-pass:
 	*
 	* 1. **Top-level pass** — invokes `kernel.devices.create()` for every
@@ -84310,7 +85324,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 				restored.add(saved.id);
 				return;
 			}
-			const Class = this.deviceClasses[saved.type];
+			const Class = this.deviceClassForRow(saved);
 			if (!Class) throw new Error(`no device class registered for type "${saved.type}"`);
 			if (saved.parentDeviceId !== null && !restored.has(saved.parentDeviceId)) throw new Error(`parent device ${saved.parentDeviceId} not restored`);
 			await this.healSavedConfig(saved, savedDevices);
@@ -84327,7 +85341,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 		};
 		const topLevel = savedDevices.filter((saved) => saved.parentDeviceId === null);
 		const restoreOne = async (saved) => {
-			if (!this.deviceClasses[saved.type]) {
+			if (!this.deviceClassForRow(saved)) {
 				this.ctx.logger.warn("No device class registered for restored type — skipping", {
 					tags: {
 						deviceId: saved.id,
@@ -84366,7 +85380,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 		const failedTopLevelIds = new Set(failures.map((failure) => failure.saved.id));
 		const childRows = savedDevices.filter((s) => s.parentDeviceId !== null);
 		for (const saved of childRows) {
-			if (!this.deviceClasses[saved.type]) continue;
+			if (!this.deviceClassForRow(saved)) continue;
 			if (saved.parentDeviceId === null) continue;
 			if (restored.has(saved.parentDeviceId)) {
 				try {
@@ -84420,7 +85434,9 @@ var BaseDeviceProvider = class extends BaseAddon {
 	}
 };
 DeviceType.HeatPump;
-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;
+DeviceType.Climate;
+DeviceRole.ClimateThermostat, DeviceRole.ClimateAc, DeviceRole.ClimateRadiator, DeviceRole.ClimateFloor, DeviceRole.ClimateHeater, DeviceRole.ClimateHeatPumpCircuit;
+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.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.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) {
@@ -86426,7 +87442,7 @@ var HEAT_PUMP_FAMILY_CONTRIBUTIONS = { "heat-pump-status": contribution("heat-pu
 	...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.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;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, 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.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
@@ -87070,9 +88086,9 @@ lookOf({
 	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.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;
+DeviceType.Climate;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, 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.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.SwitchHeater, DeviceRole.SwitchFan, DeviceRole.ClimateAc, DeviceRole.ClimateThermostat, DeviceRole.ClimateFloor, DeviceRole.ClimateRadiator, DeviceRole.ClimateHeater, DeviceRole.ClimateHeatPumpCircuit, 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": {
 		capName: "accessories",
@@ -88299,6 +89315,27 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"clusterUpdate.getClusterUpdateJob": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"clusterUpdate.previewClusterUpdate": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"clusterUpdate.startClusterUpdate": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"color.getStatus": {
 		capName: "color",
 		capScope: "device",
@@ -88901,41 +89938,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"deviceDiscovery.adoptDevice": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
-	"deviceDiscovery.getStatus": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "view",
-		role: "viewer"
-	},
-	"deviceDiscovery.listDiscovered": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "view",
-		role: "viewer"
-	},
-	"deviceDiscovery.refreshDiscovery": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
-	"deviceDiscovery.releaseDevice": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"deviceExport.applyDeviceSettingsPatch": {
 		capName: "device-export",
 		capScope: "system",
@@ -89671,6 +90673,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.search": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"deviceManager.setAlias": {
 		capName: "device-manager",
 		capScope: "system",
@@ -89762,6 +90771,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.setPrimaryChildPreference": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceManager.setRole": {
 		capName: "device-manager",
 		capScope: "system",
@@ -90469,6 +91485,13 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"fanControl.setOscillationAxis": {
+		capName: "fan-control",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"fanControl.setPercentage": {
 		capName: "fan-control",
 		capScope: "device",
@@ -94401,28 +95424,28 @@ Object.freeze({
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.getStatus": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "view",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.powerOff": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.powerOn": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"presence.getStatus": {
 		capName: "presence",
@@ -97490,7 +98513,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.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;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, 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.Dryer, DeviceType.Gateway;
 DeviceFeature.BatteryOperated;
 function bound(cap, methods = [], authority = "reported") {
 	return {
@@ -97979,35 +99002,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"deviceDiscovery.adoptDevice": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.getStatus": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.listDiscovered": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.refreshDiscovery": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.releaseDevice": [{
-		name: "childDeviceId",
-		form: "single",
-		optional: false
-	}, {
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"deviceExport.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -98286,6 +99280,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceManager.setPrimaryChildPreference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.setRole": [{
 		name: "deviceId",
 		form: "single",
@@ -98566,6 +99565,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"fanControl.setOscillationAxis": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"fanControl.setPercentage": [{
 		name: "deviceId",
 		form: "single",
@@ -101754,7 +102758,9 @@ var TimelapseRuleInputSchema = object({
 	/** Classes the notification counts — see {@link ReportClassesField}. */
 	reportClasses: ReportClassesField.optional(),
 	/** Canonical notification priority ordinal (1..5); per-target overridable. */
-	priority: PriorityField.default(3)
+	priority: PriorityField.default(3),
+	/** Per-target settings keyed by target id (D1032) — absent = every target follows the rule. */
+	targetOverrides: NcTargetOverridesSchema.optional()
 });
 object({
 	name: NameField.optional(),
@@ -101770,7 +102776,9 @@ object({
 	previewText: PreviewTextField.optional(),
 	previewMode: PreviewModeField.optional(),
 	reportClasses: ReportClassesField.optional(),
-	priority: PriorityField.optional()
+	priority: PriorityField.optional(),
+	/** Per-target settings keyed by target id (D1032) — absent = every target follows the rule. */
+	targetOverrides: NcTargetOverridesSchema.optional()
 });
 TimelapseRuleInputSchema.extend({
 	id: string(),
@@ -102036,6 +103044,27 @@ function ingestReading(input) {
 		value: converted
 	};
 }
+function collapse(value) {
+	return value.trim().replace(/\s+/g, " ");
+}
+/** "KLF-200" → "KLF200". A hyphen between words ("Home Hub") stays. */
+function compactModelToken(value) {
+	return value.replace(/([A-Za-z])-(\d)/g, "$1$2");
+}
+/**
+* A Gateway device: "<Brand> <Model>". An unknown model is the brand alone
+* (the caller passes the brand-level fallback it already has, e.g. "Velux KLF-200").
+*/
+function gatewayDeviceName(brand, model) {
+	const brandPart = compactModelToken(collapse(brand));
+	const raw = collapse(model ?? "");
+	if (raw.length === 0) return brandPart;
+	const modelPart = compactModelToken(raw);
+	const prefix = `${brandPart.toLowerCase()} `;
+	if (modelPart.toLowerCase() === brandPart.toLowerCase()) return brandPart;
+	if (modelPart.toLowerCase().startsWith(prefix)) return modelPart;
+	return `${brandPart} ${modelPart}`;
+}
 /**
 * Closes the gap D49 leaves: an integration deleted while its provider was down never emits an
 * event the provider sees. An integration id absent from an ANSWERED list is only a suspect; its
@@ -102136,13 +103165,15 @@ object({
 * settings of the integration itself, not of a device. Every equipment the box reports is
 * adopted as a Container from it.
 *
-* Two sources behind `source`:
+* Sources behind `source`:
+*   - `blazor`: the box's own web-page channel (Blazor Server, firmware 8.51 and later),
+*     read by an embedded Python bridge. No token, nothing written to the box.
 *   - `influx`: the box's InfluxDB 2.x (port 8086, org `enpal`, bucket `solar`).
 *     Needs the access token Enpal support issues; it is a keychain secret.
 *   - `page`: the box's local device page (`/deviceMessages`). No token; fewer
 *     boxes and firmware versions still serve it.
-*   - `auto` (default): InfluxDB when a token is set, the page otherwise or when
-*     InfluxDB cannot be read.
+*   - `auto` (default): `blazor`, then InfluxDB when a token is set, then the page; the first
+*     one that answers wins and the snapshot records why a preferred one was skipped.
 */
 /** Strip a pasted scheme and path: `http://192.0.2.10/deviceMessages` -> `192.0.2.10`. */
 function cleanHost(value) {
@@ -102160,6 +103191,7 @@ var FLUX_NAME = /^[A-Za-z0-9_.-]+$/;
 var ENPAL_SYSTEM = "enpal";
 var ENPAL_SOURCES = [
 	"auto",
+	"blazor",
 	"influx",
 	"page"
 ];
@@ -102220,7 +103252,7 @@ function buildConnectionFormSchema() {
 			id: "source",
 			title: "Data source",
 			titleKey: "provider-enpal:connection.s_source.title",
-			description: "InfluxDB needs the access token Enpal support issues (ask in the Enpal app chat). Without it the box device page is used.",
+			description: "The box's own web-page channel needs no credential and is used first. InfluxDB is used only with the access token Enpal support issues; the device page is the last resort.",
 			descriptionKey: "provider-enpal:connection.s_source.description",
 			columns: 2,
 			fields: [
@@ -102233,9 +103265,14 @@ function buildConnectionFormSchema() {
 					options: [
 						{
 							value: "auto",
-							label: "Automatic (InfluxDB, then device page)",
+							label: "Automatic (box web channel, InfluxDB, then device page)",
 							labelKey: "provider-enpal:connection.s_source.source.o_auto.label"
 						},
+						{
+							value: "blazor",
+							label: "Box web channel only (firmware 8.51 and later)",
+							labelKey: "provider-enpal:connection.s_source.source.o_blazor.label"
+						},
 						{
 							value: "influx",
 							label: "InfluxDB only",
@@ -102351,6 +103388,22 @@ var point = (quantity, ...sources) => ({
 	quantity,
 	sources: sources.map((s) => typeof s === "string" ? { key: s } : s)
 });
+var numeric = (id, name, quantity, key, role = DeviceRole.NumericSensor) => ({
+	kind: "numeric",
+	id,
+	name,
+	role,
+	quantity,
+	value: point(quantity, key)
+});
+var text = (id, name, key, timestamp = false) => ({
+	kind: "text",
+	id,
+	name,
+	role: timestamp ? DeviceRole.DateTimeSensor : DeviceRole.EnumSensor,
+	key,
+	...timestamp ? { timestamp: true } : {}
+});
 /**
 * What an Enpal box can show, by the dotted keys its InfluxDB and device page use (the
 * names follow the Home Assistant component's key table). A device is offered only when the
@@ -102433,7 +103486,7 @@ var ENPAL_SPECS = [
 		id: "house",
 		name: "Consumption",
 		role: DeviceRole.PowerSensor,
-		power: point("power", "Power.Consumption.Total", "Power.Consumption.AC"),
+		power: point("power", "Power.Consumption.Total"),
 		kwh: point("energy", "Energy.Consumption.Total.Lifetime")
 	},
 	{
@@ -102483,7 +103536,87 @@ var ENPAL_SPECS = [
 		role: DeviceRole.NumericSensor,
 		quantity: "percentage",
 		value: point("percentage", "Battery.SOH")
-	}
+	},
+	numeric("pv-string-1-power", "String 1 power", "power", "Power.DC.String.1", DeviceRole.PowerSensor),
+	numeric("pv-string-2-power", "String 2 power", "power", "Power.DC.String.2", DeviceRole.PowerSensor),
+	numeric("pv-energy-day", "Production today", "energy", "Energy.Production.Total.Day", DeviceRole.EnergySensor),
+	numeric("pv-string-1-voltage", "String 1 voltage", "voltage", "Voltage.String.1", DeviceRole.VoltageSensor),
+	numeric("pv-string-2-voltage", "String 2 voltage", "voltage", "Voltage.String.2", DeviceRole.VoltageSensor),
+	numeric("pv-string-1-current", "String 1 current", "current", "Current.String.1", DeviceRole.CurrentSensor),
+	numeric("pv-string-2-current", "String 2 current", "current", "Current.String.2", DeviceRole.CurrentSensor),
+	numeric("battery-stored-energy", "Stored energy", "energy", "Energy.Battery.Charge.Load", DeviceRole.EnergySensor),
+	numeric("battery-charge-day", "Charged today", "energy", "Energy.Battery.Charge.Day", DeviceRole.EnergySensor),
+	numeric("battery-discharge-day", "Discharged today", "energy", "Energy.Battery.Discharge.Day", DeviceRole.EnergySensor),
+	numeric("battery-capacity", "Capacity", "energy", "Energy.Battery.Capacity", DeviceRole.EnergySensor),
+	numeric("battery-power-rating", "Maximum power rating", "power", "Battery.Power.Rating.Maximum", DeviceRole.PowerSensor),
+	numeric("battery-level-max", "Maximum charge level", "percentage", "Battery.ChargeLevel.Max"),
+	numeric("battery-level-min", "Minimum charge level", "percentage", "Battery.ChargeLevel.Min"),
+	numeric("battery-power-set", "Power setpoint", "power", "Power.Battery.Charge.Discharge.Set", DeviceRole.PowerSensor),
+	numeric("battery-charge-power-max", "Maximum charge power", "power", "Power.Battery.Charge.Max", DeviceRole.PowerSensor),
+	numeric("battery-discharge-power-max", "Maximum discharge power", "power", "Power.Battery.Discharge.Max", DeviceRole.PowerSensor),
+	numeric("battery-charge-current-max", "Maximum charge current", "current", "Current.Battery.Charge.Max", DeviceRole.CurrentSensor),
+	numeric("battery-discharge-current-max", "Maximum discharge current", "current", "Current.Battery.Discharge.Max", DeviceRole.CurrentSensor),
+	numeric("grid-phase-a", "Phase A power", "power", "Power.AC.Phase.A", DeviceRole.PowerSensor),
+	numeric("grid-phase-b", "Phase B power", "power", "Power.AC.Phase.B", DeviceRole.PowerSensor),
+	numeric("grid-phase-c", "Phase C power", "power", "Power.AC.Phase.C", DeviceRole.PowerSensor),
+	numeric("grid-import-day", "Imported today", "energy", "Energy.Grid.Import.Day", DeviceRole.EnergySensor),
+	numeric("grid-export-day", "Exported today", "energy", "Energy.Grid.Export.Day", DeviceRole.EnergySensor),
+	numeric("grid-voltage-a", "Phase A voltage", "voltage", "Voltage.Phase.A", DeviceRole.VoltageSensor),
+	numeric("grid-voltage-b", "Phase B voltage", "voltage", "Voltage.Phase.B", DeviceRole.VoltageSensor),
+	numeric("grid-voltage-c", "Phase C voltage", "voltage", "Voltage.Phase.C", DeviceRole.VoltageSensor),
+	{
+		kind: "numeric",
+		id: "grid-frequency",
+		name: "Frequency",
+		role: DeviceRole.NumericSensor,
+		quantity: "index",
+		value: {
+			...point("index", "Frequency.Grid"),
+			ignoreUnit: true
+		}
+	},
+	numeric("grid-feed-max", "Maximum feed-in power", "power", "Power.Grid.Maximum.Feed", DeviceRole.PowerSensor),
+	numeric("house-energy-day", "Consumption today", "energy", "Energy.Consumption.Total.Day", DeviceRole.EnergySensor),
+	text("inverter-state", "System state", "Inverter.System.State"),
+	text("inverter-ems-mode", "EMS mode", "Command.EMS.Mode"),
+	numeric("inverter-ac-power", "AC power", "power", "Power.Inverter.AC.Export", DeviceRole.PowerSensor),
+	text("inverter-start-stop", "Start/stop command", "Command.Start.Stop"),
+	text("inverter-forcible-mode", "Forcible charge/discharge mode", "Mode.Forcible.Charge.Discharge"),
+	numeric("inverter-power-rating", "Maximum power rating", "power", "Inverter.Power.Rating.Maximum", DeviceRole.PowerSensor),
+	text("inverter-phase-type", "Phase type", "Type.Phase.Inverter"),
+	text("inverter-modbus-rtu", "Modbus RTU status", "Inverter.Modbus.Health.Rtu.Status"),
+	text("inverter-modbus-tcp", "Modbus TCP status", "Inverter.Modbus.Health.Tcp.Status"),
+	text("heatpump-hot-water-mode", "Hot water mode", "Heatpump.DomesticHotWater.1.Mode"),
+	text("heatpump-heating-mode", "Heating circuit mode", "Heatpump.HeatingCircuit.1.Mode"),
+	text("heatpump-generator-state", "Generator state", "Heatpump.Generator.State.Running"),
+	text("heatpump-heater-state", "Electric heater state", "Heatpump.ElectricHeater.State.Running"),
+	text("heatpump-energy-management", "Energy management state", "Heatpump.EnergyManagement.State"),
+	text("heatpump-power-desired", "Power requested", "Heatpump.Power.Desired.Enabled"),
+	text("heatpump-pv-optimization", "PV optimisation", "Heatpump.Settings.PvOptimizationStatus"),
+	numeric("heatpump-power-min", "Generator minimum power", "power", "Heatpump.Generator.Power.Min", DeviceRole.PowerSensor),
+	numeric("heatpump-power-max", "Generator maximum power", "power", "Heatpump.Generator.Power.Max", DeviceRole.PowerSensor),
+	text("heatpump-connection", "Local connection", "Heatpump.Local.ConnectionState"),
+	text("box-main-state", "Main state", "IoT.MainState"),
+	numeric("box-cpu-load", "CPU load", "percentage", "Cpu.Load"),
+	numeric("box-memory-usage", "Memory usage", "percentage", "Memory.Usage"),
+	text("box-hardware-check", "Hardware check", "HW.Cronny.Result"),
+	text("eebus-connection", "Connection state", "Eebus.ConnectionState"),
+	text("eebus-discovery", "Discovery state", "Eebus.DiscoveryState"),
+	text("eebus-cert-expiry", "Certificate expiry", "Eebus.CertExpiry", true),
+	text("lte-state", "LTE state", "LTE.State"),
+	text("lte-connection-type", "Connection type", "LTE.Connection.Type"),
+	numeric("lte-quality", "LTE quality", "percentage", "LTE.Quality"),
+	numeric("lte-rsrp", "RSRP", "signal-level", "LTE.RSRP"),
+	numeric("lte-rsrq", "RSRQ", "index", "LTE.RSRQ"),
+	numeric("lte-rssi", "RSSI", "signal-level", "LTE.RSSI"),
+	numeric("lte-snr", "SNR", "index", "LTE.SNR"),
+	text("lte-failover", "Failover result", "LTE.Failover.Result"),
+	text("lte-signal-check", "Signal check", "LTE.Cronny.Result"),
+	text("wifi-state", "Wi-Fi state", "WiFi.State"),
+	numeric("data-lan-down", "LAN download this month", "count", "IoT.Data.Consumption.Lan.Down.Month"),
+	numeric("data-lan-up", "LAN upload this month", "count", "IoT.Data.Consumption.Lan.Up.Month"),
+	numeric("data-lte-down", "LTE download this month", "count", "IoT.Data.Consumption.Lte.Down.Month"),
+	numeric("data-lte-up", "LTE upload this month", "count", "IoT.Data.Consumption.Lte.Up.Month")
 ];
 function findSpec(id) {
 	return ENPAL_SPECS.find((s) => s.id === id);
@@ -102495,6 +103628,7 @@ function capsOfSpec(spec) {
 		case "battery": return ["battery", "power-meter"];
 		case "meter": return ["meter"];
 		case "numeric": return ["numeric-sensor"];
+		case "text": return ["enum-sensor"];
 	}
 }
 function pointsOf(spec) {
@@ -102508,6 +103642,7 @@ function pointsOf(spec) {
 		];
 		case "meter":
 		case "numeric": return [spec.value];
+		case "text": return [];
 	}
 }
 function resolve(target, snapshot) {
@@ -102515,7 +103650,7 @@ function resolve(target, snapshot) {
 	for (const source of target.sources) {
 		const reading = snapshot.readings.get(source.key);
 		if (reading === void 0) continue;
-		const converted = toBase(reading.value, reading.unit, target.quantity);
+		const converted = toBase(reading.value, target.ignoreUnit === true ? void 0 : reading.unit, target.quantity);
 		if (!converted.ok) {
 			refusal = `${source.key}: ${converted.reason} (unit ${reading.unit ?? "none"})`;
 			continue;
@@ -102534,7 +103669,7 @@ function resolve(target, snapshot) {
 }
 /** Specs whose data the box reported: a refused point still counts, the device exists. */
 function availableSpecs(snapshot) {
-	return ENPAL_SPECS.filter((spec) => pointsOf(spec).some((p) => resolve(p, snapshot).state !== "absent"));
+	return ENPAL_SPECS.filter((spec) => spec.kind === "text" ? snapshot.texts.has(spec.key) : pointsOf(spec).some((p) => resolve(p, snapshot).state !== "absent"));
 }
 function numberOf(r) {
 	return r.state === "value" ? r.value : void 0;
@@ -102633,6 +103768,17 @@ function computeSlices(spec, snapshot, options, now) {
 				refusals: refusalOf(value)
 			};
 		}
+		case "text": {
+			const value = snapshot.texts.get(spec.key);
+			return {
+				...value !== void 0 ? { text: {
+					value,
+					...spec.timestamp === true ? { timestamp: true } : {},
+					lastFetchedAt: now
+				} } : {},
+				refusals: []
+			};
+		}
 	}
 }
 //#endregion
@@ -102730,6 +103876,7 @@ var POWER_CAP = powerMeterCapability.name;
 var BATTERY_CAP = batteryCapability.name;
 var METER_CAP = meterCapability.name;
 var NUMERIC_CAP = numericSensorCapability.name;
+var ENUM_CAP = enumSensorCapability.name;
 var POWER_COLD = { lastFetchedAt: 0 };
 var BATTERY_COLD = {
 	level: null,
@@ -102741,6 +103888,11 @@ var VALUE_COLD = {
 	value: null,
 	lastFetchedAt: 0
 };
+/** A text has no null: until the box sends one the slice is empty and never read as a state. */
+var TEXT_COLD = {
+	value: "",
+	lastFetchedAt: 0
+};
 /**
 * Persisted config of an Enpal Sensor. `specId` selects the entry of the catalog;
 * `integrationId` selects the integration whose box feeds it.
@@ -102778,7 +103930,8 @@ var EnpalSensorDevice = class extends BaseDevice {
 		this.updateSourceInfo({
 			id: `${this.integrationId}:${spec.id}`,
 			system: ENPAL_SYSTEM,
-			...spec.kind === "meter" || spec.kind === "numeric" ? { quantity: spec.quantity } : {}
+			...spec.kind === "meter" || spec.kind === "numeric" ? { quantity: spec.quantity } : {},
+			...spec.kind === "text" && spec.timestamp === true ? { dateTimeShape: "date" } : {}
 		});
 	}
 	async onActivate() {
@@ -102836,6 +103989,7 @@ var EnpalSensorDevice = class extends BaseDevice {
 			});
 		}
 		if (slices.numeric !== void 0) this.runtimeState.setCapState(NUMERIC_CAP, slices.numeric);
+		if (slices.text !== void 0) this.runtimeState.setCapState(ENUM_CAP, slices.text);
 	}
 	registerCaps() {
 		switch (this.spec.kind) {
@@ -102850,6 +104004,10 @@ var EnpalSensorDevice = class extends BaseDevice {
 				this.ctx.registerNativeCap(meterCapability, { getStatus: async () => this.runtimeState.getCapState(METER_CAP) ?? VALUE_COLD });
 				this.runtimeState.setCapState(METER_CAP, VALUE_COLD);
 				return;
+			case "text":
+				this.ctx.registerNativeCap(enumSensorCapability, { getStatus: async () => this.runtimeState.getCapState(ENUM_CAP) ?? TEXT_COLD });
+				this.runtimeState.setCapState(ENUM_CAP, TEXT_COLD);
+				return;
 			case "numeric":
 				this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState(NUMERIC_CAP) ?? VALUE_COLD });
 				this.runtimeState.setCapState(NUMERIC_CAP, VALUE_COLD);
@@ -102879,43 +104037,166 @@ function enpalSensorFactory(ctx) {
 }
 //#endregion
 //#region src/enpal-equipment.ts
-/** Order is the order the candidates are listed in. Every catalog entry belongs to one. */
+var live = (section, ...specIds) => specIds.map((specId) => ({
+	specId,
+	...section !== void 0 ? { section } : {},
+	diagnostic: false
+}));
+var diag = (section, ...specIds) => specIds.map((specId) => ({
+	specId,
+	...section !== void 0 ? { section } : {},
+	diagnostic: true
+}));
+function equipment(input) {
+	return {
+		...input,
+		specIds: input.children.map((c) => c.specId)
+	};
+}
+/**
+* Three adoptable pieces: the box (the Gateway, with its connection, firmware and
+* diagnostics), the installation (System: Sungrow inverter, battery, grid, house meter), and
+* the heat pump as the box reads it. Order is the order the candidates are listed in. Every
+* catalog entry belongs to one. The ids of the older catalog entries are unchanged.
+*/
 var ENPAL_EQUIPMENT = [
-	{
-		id: "pv",
-		name: "Photovoltaic",
-		specIds: ["pv", "inverter-temperature"]
-	},
-	{
-		id: "battery",
-		name: "Battery",
-		specIds: [
+	equipment({
+		id: "box",
+		kind: "gateway",
+		name: "Enpal Box",
+		children: [
+			...diag("Box", "box-main-state", "box-cpu-load", "box-memory-usage", "box-hardware-check"),
+			...diag("EEBUS", "eebus-connection", "eebus-discovery", "eebus-cert-expiry"),
+			...diag("Connectivity", "lte-state", "lte-connection-type", "lte-quality", "lte-rsrp", "lte-rsrq", "lte-rssi", "lte-snr", "lte-failover", "lte-signal-check", "wifi-state", "data-lan-down", "data-lan-up", "data-lte-down", "data-lte-up")
+		],
+		metadata: [
+			{
+				attribute: "deviceName",
+				key: "Device.Name"
+			},
+			{
+				attribute: "model",
+				key: "IoTEdgeDevice.Device.Type"
+			},
+			{
+				attribute: "serialNumber",
+				key: "IoTEdgeDevice.SerialNumber"
+			},
+			{
+				attribute: "hardware",
+				key: "Generation.HW"
+			},
+			{
+				attribute: "softwareGeneration",
+				key: "Generation.SW"
+			},
+			{
+				attribute: "eebusSki",
+				key: "Eebus.Ski"
+			},
+			{
+				attribute: "modemModel",
+				key: "LTE.Modem.Type"
+			},
+			{
+				attribute: "modemFirmware",
+				key: "LTE.Modem.Firmware.Version"
+			}
+		],
+		primaryChildPreference: []
+	}),
+	equipment({
+		id: "impianto",
+		kind: "container",
+		name: "System",
+		children: [
+			...live("Photovoltaic", "pv", "pv-string-1-power", "pv-string-2-power", "pv-energy-day"),
+			...diag("Photovoltaic", "pv-string-1-voltage", "pv-string-2-voltage", "pv-string-1-current", "pv-string-2-current"),
+			...live("Battery", "battery", "battery-stored-energy", "battery-temperature", "battery-charge-day", "battery-discharge-day", "battery-charged", "battery-discharged"),
+			...diag("Battery", "battery-health", "battery-capacity", "battery-power-rating", "battery-level-max", "battery-level-min", "battery-power-set", "battery-charge-power-max", "battery-discharge-power-max", "battery-charge-current-max", "battery-discharge-current-max"),
+			...live("Grid", "grid-import", "grid-export", "grid-phase-a", "grid-phase-b", "grid-phase-c", "grid-import-day", "grid-export-day"),
+			...diag("Grid", "grid-voltage-a", "grid-voltage-b", "grid-voltage-c", "grid-frequency", "grid-feed-max"),
+			...live("Home", "house", "house-energy-day"),
+			...live("Inverter", "inverter-state", "inverter-ems-mode", "inverter-ac-power"),
+			...diag("Inverter", "inverter-start-stop", "inverter-forcible-mode", "inverter-temperature", "inverter-power-rating", "inverter-phase-type", "inverter-modbus-rtu", "inverter-modbus-tcp")
+		],
+		metadata: [
+			{
+				attribute: "model",
+				key: "Code.Device.Type"
+			},
+			{
+				attribute: "firmware",
+				key: "SoftwareVersion.Service.1"
+			},
+			{
+				attribute: "communicationFirmware",
+				key: "SoftwareVersion.Service.2"
+			},
+			{
+				attribute: "dongleSerialNumber",
+				key: "Dongle.SerialNumber"
+			},
+			{
+				attribute: "batterySerialNumber",
+				key: "SerialNumber.Battery"
+			},
+			{
+				attribute: "batteryFirmware",
+				key: "SoftwareVersion.Service.Battery.Unit.1"
+			}
+		],
+		primaryChildPreference: [
+			"pv",
 			"battery",
-			"battery-charged",
-			"battery-discharged",
-			"battery-temperature",
-			"battery-health"
+			"house"
 		]
-	},
-	{
-		id: "grid",
-		name: "Grid",
-		specIds: ["grid-import", "grid-export"]
-	},
-	{
-		id: "house",
-		name: "House",
-		specIds: ["house"]
-	},
-	{
+	}),
+	equipment({
 		id: "heatpump",
-		name: "Heat pump",
-		specIds: [
+		kind: "container",
+		name: "Heat pump (Enpal)",
+		children: [...live(void 0, "heatpump", "heatpump-hot-water", "heatpump-outside", "heatpump-hot-water-mode", "heatpump-heating-mode", "heatpump-generator-state", "heatpump-heater-state"), ...diag(void 0, "heatpump-energy-management", "heatpump-power-desired", "heatpump-pv-optimization", "heatpump-power-min", "heatpump-power-max", "heatpump-connection")],
+		metadata: [
+			{
+				attribute: "model",
+				key: "Heatpump.IndoorUnit.DeviceType"
+			},
+			{
+				attribute: "serialNumber",
+				key: "Heatpump.SerialNumber"
+			},
+			{
+				attribute: "indoorUnitSerialNumber",
+				key: "Heatpump.IndoorUnit.SerialNumber"
+			},
+			{
+				attribute: "firmware",
+				key: "Heatpump.SoftwareVersion"
+			},
+			{
+				attribute: "indoorUnitFirmware",
+				key: "Heatpump.IndoorUnit.SoftwareVersion"
+			},
+			{
+				attribute: "gatewayModel",
+				key: "Heatpump.Gateway.Device.Type"
+			},
+			{
+				attribute: "gatewaySerialNumber",
+				key: "Heatpump.Gateway.SerialNumber"
+			},
+			{
+				attribute: "gatewayFirmware",
+				key: "Heatpump.Gateway.SoftwareVersion"
+			}
+		],
+		primaryChildPreference: [
 			"heatpump",
 			"heatpump-hot-water",
 			"heatpump-outside"
 		]
-	}
+	})
 ];
 function findEquipment(id) {
 	return ENPAL_EQUIPMENT.find((e) => e.id === id);
@@ -102929,24 +104210,61 @@ function childNativeId(equipmentId, specId) {
 * they stay, whatever the box reports later, so a restart with the box off keeps them.
 */
 var enpalEquipmentSchema = object({
-	equipment: string().min(1).describe("Equipment id (pv, battery, grid, house, heatpump)"),
+	equipment: string().min(1).describe("Equipment id (impianto, heatpump; older adoptions: pv, battery, grid, house)"),
 	specIds: array(string().min(1)).describe("Catalog entries adopted as children"),
 	integrationId: string().min(1).describe("Owning integration"),
 	system: literal(ENPAL_SYSTEM).optional()
 });
-/** The Sensor children the kernel spawns under an equipment Container. */
+/**
+* The declared primary children of an adopted piece: its preference, limited to the children
+* it was adopted with. Empty for the gateway and for an equipment id the catalog dropped.
+*/
+function primaryChildPreferenceOf(found, specIds) {
+	if (found === void 0) return [];
+	return found.primaryChildPreference.filter((id) => specIds.includes(id));
+}
+/**
+* The accordion layout of an equipment Container, for the children it was adopted with.
+* Empty for a Container with no sections (the heat pump) or an unknown equipment.
+*/
+function childLayoutOf(found, specIds) {
+	if (found === void 0) return [];
+	const entries = [];
+	found.children.forEach((child, order) => {
+		if (child.section === void 0 || !specIds.includes(child.specId)) return;
+		entries.push({
+			childKey: child.specId,
+			section: child.section,
+			order
+		});
+	});
+	return entries;
+}
+/** The identity facts the box reported for an equipment, by device attribute. */
+function metadataOf(found, snapshot) {
+	const out = {};
+	for (const field of found?.metadata ?? []) {
+		const value = snapshot.texts.get(field.key);
+		if (value !== void 0) out[field.attribute] = value;
+	}
+	return out;
+}
+/** The Sensor children the kernel spawns under an adopted piece (a Container or the Gateway). */
 function accessoryChildSpecs(config) {
+	const found = findEquipment(config.equipment);
 	const out = [];
 	for (const specId of config.specIds) {
 		const spec = findSpec(specId);
 		if (spec === void 0) continue;
+		const diagnostic = found?.children.find((c) => c.specId === specId)?.diagnostic === true;
 		out.push({
 			stableIdSuffix: spec.id,
 			meta: {
 				type: DeviceType.Sensor,
 				name: spec.name,
 				role: spec.role,
-				integrationId: config.integrationId
+				integrationId: config.integrationId,
+				...diagnostic ? { display: { hidden: true } } : {}
 			},
 			config: {
 				specId: spec.id,
@@ -102959,18 +104277,87 @@ function accessoryChildSpecs(config) {
 	return out;
 }
 //#endregion
+//#region src/devices/enpal-metadata-sync.ts
+/**
+* Writes the identity facts a piece reported (model, serial, firmware) as device attributes.
+* A poll that changed none writes nothing; a failed write is logged and retried next poll.
+*/
+var EnpalMetadataSync = class {
+	options;
+	applied = "";
+	constructor(options) {
+		this.options = options;
+	}
+	async apply() {
+		const snapshot = this.options.getSnapshot();
+		if (snapshot === null) return;
+		const attributes = metadataOf(findEquipment(this.options.equipment), snapshot);
+		const fingerprint = JSON.stringify(attributes);
+		if (fingerprint === this.applied || Object.keys(attributes).length === 0) return;
+		try {
+			await this.options.write(attributes);
+			this.applied = fingerprint;
+		} catch (err) {
+			this.options.logger.warn("enpal: could not write the device attributes", {
+				tags: { deviceId: this.options.deviceId },
+				meta: {
+					equipment: this.options.equipment,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
+//#region src/devices/enpal-preference-backfill.ts
+/**
+* Stamp the declared primary-child preference on a container adopted before
+* the declaration existed. Adoption stamps it through `InitialDeviceMeta`;
+* a restore passes no initial meta, so an older row would otherwise never get
+* one and keep being shown by the heuristic's child.
+*
+* Only an ABSENT declaration is filled: a stored one is the provider's own and
+* is left alone. The operator's pick (`primaryChildEntityId`) is a different
+* column, never written here, and still wins at resolution.
+*
+* @returns whether it wrote.
+*/
+async function backfillPrimaryChildPreference(input) {
+	const { deviceId, stored, declared, write, logger } = input;
+	if (stored !== void 0 && stored.length > 0) return false;
+	if (declared.length === 0) return false;
+	try {
+		await write(declared);
+	} catch (err) {
+		logger.warn("enpal: could not stamp the primary-child preference", {
+			tags: { deviceId },
+			meta: { error: errMsg(err) }
+		});
+		return false;
+	}
+	logger.info("enpal: stamped the primary-child preference on a container adopted without one", {
+		tags: { deviceId },
+		meta: { primaryChildPreference: declared }
+	});
+	return true;
+}
+//#endregion
 //#region src/devices/enpal-equipment-device.ts
 /**
-* One physical piece of the installation (photovoltaic, battery, grid, house, heat pump) as a
+* One piece Enpal measures (the System: PV, battery, grid, house; the heat pump) as a
 * {@link DeviceType.Container}. It owns no caps: it declares the Sensor children it was
-* adopted with, and the kernel spawns and restores them. Online follows the integration's
-* box; the integration marks it offline when a poll fails.
+* adopted with, and the kernel spawns and restores them; which child stands for it is the
+* `primaryChildPreference` stamped at adoption, and re-stamped on activation for a
+* container adopted before it had one. Its model, serials and firmware are device
+* attributes, written from the box's text rows whenever they change. Online follows the
+* integration's box; the integration marks it offline when a poll fails.
 */
 var EnpalEquipmentDevice = class extends BaseDevice {
 	features = [];
 	equipment;
 	specIds;
 	integrationId;
+	snapshotUnsub = null;
 	constructor(ctx) {
 		const cfg = enpalEquipmentSchema.parse(ctx.persistedConfig ?? {});
 		super(ctx, enpalEquipmentSchema, { type: DeviceType.Container });
@@ -102983,6 +104370,42 @@ var EnpalEquipmentDevice = class extends BaseDevice {
 			system: ENPAL_SYSTEM
 		});
 	}
+	async onActivate() {
+		await super.onActivate();
+		await backfillPrimaryChildPreference({
+			deviceId: this.id,
+			stored: this.ctx.deviceMeta.primaryChildPreference,
+			declared: primaryChildPreferenceOf(findEquipment(this.equipment), this.specIds),
+			write: async (keys) => {
+				await this.ctx.api.deviceManager.setPrimaryChildPreference.mutate({
+					deviceId: this.id,
+					primaryChildPreference: keys
+				});
+			},
+			logger: this.ctx.logger
+		});
+		const metadata = new EnpalMetadataSync({
+			equipment: this.equipment,
+			deviceId: this.id,
+			getSnapshot: () => enpalConnections.getSnapshot(this.integrationId),
+			write: async (patch) => {
+				await this.ctx.api.deviceManager.setMetadata.mutate({
+					deviceId: this.id,
+					patch
+				});
+			},
+			logger: this.ctx.logger
+		});
+		this.snapshotUnsub = enpalConnections.onSnapshot(this.integrationId, () => {
+			metadata.apply();
+		});
+		await metadata.apply();
+	}
+	async removeDevice() {
+		this.snapshotUnsub?.();
+		this.snapshotUnsub = null;
+		await super.removeDevice();
+	}
 	getAccessoryChildren() {
 		return accessoryChildSpecs({
 			equipment: this.equipment,
@@ -102991,33 +104414,56 @@ var EnpalEquipmentDevice = class extends BaseDevice {
 		});
 	}
 };
+//#endregion
+//#region src/enpal-discovery.ts
 var METADATA = {
 	manufacturer: "Enpal",
 	integration: "enpal"
 };
+/** The Sensor candidates of one piece: the catalog entries of it the box reported. */
+function reportedChildren(equipment, snapshot) {
+	if (snapshot === null) return [];
+	const reported = new Map(availableSpecs(snapshot).map((spec) => [spec.id, spec]));
+	return equipment.specIds.flatMap((id) => {
+		const spec = reported.get(id);
+		if (spec === void 0) return [];
+		return [{
+			childNativeId: childNativeId(equipment.id, spec.id),
+			name: spec.name,
+			type: DeviceType.Sensor,
+			status: "online",
+			metadata: METADATA,
+			alreadyAdopted: false,
+			adoptedDeviceId: null,
+			capabilities: capsOfSpec(spec)
+		}];
+	});
+}
 /**
-* The box ({@link DeviceType.Gateway}, always offered, offline while it is unreachable), then one
-* Container candidate per equipment the box reported at least one value for, with the
-* Sensor children it reported. Pure.
+* The box ({@link DeviceType.Gateway}, always offered, offline while it is unreachable, with the
+* diagnostics it reported as children), then one Container candidate per other piece the box
+* reported at least one value for, with the Sensor children it reported. Pure.
 */
 function buildEnpalCandidates(input) {
 	const { snapshot } = input;
 	const boxAdopted = input.adopted.get("box") ?? null;
+	const box = findEquipment("box");
+	const boxChildren = box === void 0 ? [] : reportedChildren(box, snapshot);
 	const out = [{
 		childNativeId: "box",
-		name: input.box.name,
+		name: gatewayDeviceName("Enpal", "Box"),
 		type: DeviceType.Gateway,
 		status: input.box.online ? "online" : "offline",
 		metadata: METADATA,
 		alreadyAdopted: boxAdopted !== null,
 		adoptedDeviceId: boxAdopted,
-		capabilities: [deviceAdminLinkCapability.name]
+		capabilities: [deviceAdminLinkCapability.name],
+		...boxChildren.length > 0 ? { children: boxChildren } : {}
 	}];
-	if (snapshot === null) return out;
-	const reported = new Map(availableSpecs(snapshot).map((spec) => [spec.id, spec]));
 	for (const equipment of ENPAL_EQUIPMENT) {
-		const specs = equipment.specIds.flatMap((id) => reported.get(id) ?? []);
-		if (specs.length === 0) continue;
+		if (equipment.kind !== "container") continue;
+		const children = reportedChildren(equipment, snapshot);
+		if (children.length === 0) continue;
 		const adoptedId = input.adopted.get(equipment.id) ?? null;
 		out.push({
 			childNativeId: equipment.id,
@@ -103028,16 +104474,7 @@ function buildEnpalCandidates(input) {
 			alreadyAdopted: adoptedId !== null,
 			adoptedDeviceId: adoptedId,
 			capabilities: [],
-			children: specs.map((spec) => ({
-				childNativeId: childNativeId(equipment.id, spec.id),
-				name: spec.name,
-				type: DeviceType.Sensor,
-				status: "online",
-				metadata: METADATA,
-				alreadyAdopted: false,
-				adoptedDeviceId: null,
-				capabilities: capsOfSpec(spec)
-			}))
+			children
 		});
 	}
 	return out;
@@ -103051,7 +104488,12 @@ var DEVICES_FILTER = {
 };
 function buildEnpalAdoptionProvider(deps) {
 	const { getSnapshot, hasIntegration, listIntegrations, listAdopted, logger } = deps;
-	const boxName = (integrationId) => deps.integrationName(integrationId) ?? "Enpal";
+	const boxName = (integrationId) => deps.integrationName(integrationId) ?? findEquipment("box")?.name ?? "Enpal Box";
+	/** The catalog entries of a piece the offered candidate reports as children. */
+	const reportedSpecIds = (equipment, candidate) => {
+		const reported = new Set((candidate?.children ?? []).map((c) => c.childNativeId));
+		return equipment.specIds.filter((id) => reported.has(`${equipment.id}#${id}`));
+	};
 	async function adoptedMap(integrationId) {
 		const map = /* @__PURE__ */ new Map();
 		for (const device of await listAdopted()) {
@@ -103127,20 +104569,23 @@ function buildEnpalAdoptionProvider(deps) {
 			const adopted = [];
 			let failures = 0;
 			for (const equipmentId of childNativeIds) try {
-				if (equipmentId === "box") {
-					const { deviceId } = await deps.adoptGateway({
+				const candidate = offered.find((c) => c.childNativeId === equipmentId);
+				const equipment = findEquipment(equipmentId);
+				if (equipmentId === "box" && equipment !== void 0) {
+					const specIds = reportedSpecIds(equipment, candidate);
+					const { deviceId, accessoryDeviceIds } = await deps.adoptGateway({
 						integrationId,
-						name: perCandidate?.[equipmentId]?.name ?? boxName(integrationId)
+						name: perCandidate?.[equipmentId]?.name ?? gatewayDeviceName("Enpal", "Box"),
+						specIds,
+						childLayout: childLayoutOf(equipment, specIds)
 					});
 					adopted.push({
 						childNativeId: equipmentId,
 						parentDeviceId: deviceId,
-						accessoryDeviceIds: []
+						accessoryDeviceIds
 					});
 					continue;
 				}
-				const candidate = offered.find((c) => c.childNativeId === equipmentId);
-				const equipment = findEquipment(equipmentId);
 				if (candidate === void 0 || equipment === void 0) {
 					logger.warn("enpal adopt: the box reports nothing for this equipment — skipping", { meta: {
 						equipment: equipmentId,
@@ -103149,13 +104594,14 @@ function buildEnpalAdoptionProvider(deps) {
 					failures++;
 					continue;
 				}
-				const reported = new Set((candidate.children ?? []).map((c) => c.childNativeId));
-				const specIds = equipment.specIds.filter((id) => reported.has(`${equipment.id}#${id}`));
+				const specIds = reportedSpecIds(equipment, candidate);
 				const { deviceId, accessoryDeviceIds } = await deps.adoptDevice({
 					equipment: equipment.id,
 					specIds,
 					integrationId,
-					name: perCandidate?.[equipmentId]?.name ?? equipment.name
+					name: perCandidate?.[equipmentId]?.name ?? equipment.name,
+					childLayout: childLayoutOf(equipment, specIds),
+					primaryChildPreference: primaryChildPreferenceOf(equipment, specIds)
 				});
 				adopted.push({
 					childNativeId: equipmentId,
@@ -103186,10 +104632,187 @@ function buildEnpalAdoptionProvider(deps) {
 		}
 	};
 }
+var BlazorRowsSchema = array(object({
+	key: string(),
+	value: string(),
+	unit: string().nullable(),
+	timestamp: string().nullable()
+}));
+var BridgeResultSchema = discriminatedUnion("ok", [object({
+	ok: literal(true),
+	rows: BlazorRowsSchema
+}), object({
+	ok: literal(false),
+	kind: _enum([
+		"unreachable",
+		"bad-response",
+		"empty",
+		"protocol"
+	]),
+	error: string()
+})]);
+/** A failed bridge run. The message never carries the bridge's stderr beyond a short tail. */
+var BlazorBridgeError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.name = "BlazorBridgeError";
+		this.kind = kind;
+	}
+};
+/** The worker waits up to 12 s for the box's first render; this leaves room for connect and exit. */
+var DEFAULT_TIMEOUT_MS = 4e4;
+var WINDOW_MS = 12e3;
+/** A real answer is ~25 KB; anything near this is a runaway bridge, not a box. */
+var MAX_STDOUT_BYTES = 2 * 1024 * 1024;
+/**
+* How long `auto` leaves the Blazor channel alone after it failed. An older box that never
+* serves it would otherwise cost the full read window on every poll.
+*/
+var BLAZOR_BACKOFF_MS = 10 * 6e4;
+/** The slowest a good read takes: connect, the 12 s render window, exit. */
+var BLAZOR_WORST_CASE_READ_MS = 2e4;
+/**
+* The poll interval actually used. A box-web-channel read can take most of
+* {@link BLAZOR_WORST_CASE_READ_MS}, so a shorter interval is raised to it when that channel
+* can be the source: ticks would only pile onto the running read.
+*/
+function effectivePollIntervalMs(connection) {
+	return connection.source === "auto" || connection.source === "blazor" ? Math.max(connection.pollIntervalMs, BLAZOR_WORST_CASE_READ_MS) : connection.pollIntervalMs;
+}
+/** Remembers a failed Blazor read so `auto` skips it for a while. Forced `blazor` ignores it. */
+var BlazorBackoff = class {
+	#until = 0;
+	#reason = null;
+	/** Why the channel is being skipped now, or null when it may be tried. */
+	skipReason(now) {
+		if (this.#reason === null || now >= this.#until) return null;
+		return {
+			kind: this.#reason.kind,
+			message: `${this.#reason.message}; the box web channel is skipped for ${BLAZOR_BACKOFF_MS / 6e4} minutes after a failure`
+		};
+	}
+	failed(now, reason) {
+		this.#until = now + BLAZOR_BACKOFF_MS;
+		this.#reason = reason;
+	}
+	recovered() {
+		this.#until = 0;
+		this.#reason = null;
+	}
+};
+/** One bridge run per poll: spawn, write the request on stdin, parse one JSON answer. */
+function createBlazorReader(deps) {
+	const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	return (target) => new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)(deps.pythonPath, [deps.scriptPath], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		const finish = (action) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			action();
+		};
+		const timer = setTimeout(() => {
+			child.kill("SIGKILL");
+			finish(() => reject(new BlazorBridgeError("timeout", `Enpal box ${target.host} did not answer within ${timeoutMs / 1e3}s`)));
+		}, timeoutMs);
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk.toString("utf8");
+			if (stdout.length > MAX_STDOUT_BYTES) {
+				child.kill("SIGKILL");
+				finish(() => reject(new BlazorBridgeError("protocol", "the Enpal bridge wrote more output than any box answer")));
+			}
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr = (stderr + chunk.toString("utf8")).slice(-16384);
+		});
+		child.on("error", (err) => {
+			finish(() => reject(new BlazorBridgeError("protocol", `cannot start the Enpal bridge: ${err.message}`)));
+		});
+		child.on("close", (code) => {
+			finish(() => {
+				let json;
+				try {
+					json = JSON.parse(stdout.trim());
+				} catch {
+					const tail = stderr.trim().slice(-300) || "no stderr";
+					reject(new BlazorBridgeError("protocol", `the Enpal bridge produced no JSON (exit ${code ?? "null"}): ${tail}`));
+					return;
+				}
+				const parsed = BridgeResultSchema.safeParse(json);
+				if (!parsed.success) {
+					reject(new BlazorBridgeError("protocol", "the Enpal bridge answered an unknown shape"));
+					return;
+				}
+				if (!parsed.data.ok) {
+					reject(new BlazorBridgeError(parsed.data.kind, parsed.data.error));
+					return;
+				}
+				resolve(parsed.data.rows);
+			});
+		});
+		child.stdin.on("error", () => void 0);
+		child.stdin.end(JSON.stringify({
+			host: target.host,
+			port: target.port,
+			windowMs: WINDOW_MS
+		}));
+	});
+}
+var KEY_SHAPE$2 = /^[A-Z][A-Za-z0-9]*(\.[A-Za-z0-9-]+)+$/;
+/** A bare decimal number: `3.6`, `-40`, `0`. A version, a hash or a timestamp is not one. */
+var NUMBER = /^-?\d+(?:[.,]\d+)?$/;
+/**
+* The numeric sensors of the bridge's rows. A text value (a state name, a serial number, the
+* inverter's markup bitfield) is not a reading, and neither is a dotted string that only
+* looks like a key (`V1.1.7`, a version).
+*/
+function blazorRowsToReadings(rows) {
+	const readings = [];
+	for (const row of rows) {
+		if (!KEY_SHAPE$2.test(row.key)) continue;
+		const text = row.value.trim();
+		if (!NUMBER.test(text)) continue;
+		const value = Number(text.replace(",", "."));
+		if (!Number.isFinite(value)) continue;
+		readings.push({
+			key: row.key,
+			value,
+			unit: normalizeEnpalUnit(row.unit ?? void 0),
+			measurement: void 0
+		});
+	}
+	return readings;
+}
+/**
+* Every row's text as delivered, for state labels, serial numbers and firmware strings. A
+* row with no value, or whose value is markup (the inverter's `<ul>` bitfield), carries no
+* text worth showing and is left out.
+*/
+function blazorRowsToTexts(rows) {
+	const texts = [];
+	for (const row of rows) {
+		if (!KEY_SHAPE$2.test(row.key)) continue;
+		const value = row.value.trim();
+		if (value.length === 0 || value.startsWith("<")) continue;
+		texts.push({
+			key: row.key,
+			value
+		});
+	}
+	return texts;
+}
 //#endregion
 //#region src/enpal-device-page.ts
-var CARD_HEADER = /<div class="card-header">\s*<h2>([^<]+)<\/h2>/g;
-var ROW = /<tr>\s*<td>([^<]+)<\/td>\s*<td>([^<]*)<\/td>\s*<td>[^<]*<\/td>\s*<\/tr>/g;
+var CARD_HEADER = /<div class="card-header[^"]*">\s*<h2>([^<]+)<\/h2>/g;
+var ROW = /<tr(?:\s[^>]*)?>\s*<td>([^<]+)<\/td>\s*<td>([^<]*)<\/td>\s*<td>[^<]*<\/td>\s*<\/tr>/g;
 var KEY_SHAPE$1 = /^[A-Za-z][A-Za-z0-9]*(\.[A-Za-z0-9-]+)+$/;
 /** `10231W`, `-350W`, `1.85kW`, `51°C`, `62.5%`, `3` */
 var VALUE = /^(-?\d+(?:[.,]\d+)?)\s*(\S*)$/;
@@ -103212,7 +104835,7 @@ function cardOffsets(html) {
 * no zone, so it is not used: the poll time is.
 *
 * Firmware 8.51 and later pre-render only the "Site Data" card; the device rows then never
-* appear and this returns `[]`.
+* appear here (they come through the Blazor circuit, `enpal-blazor.ts`).
 */
 function parseDeviceMessages(html) {
 	const cards = cardOffsets(html);
@@ -103328,7 +104951,7 @@ function canonicalKey(key) {
 * Index readings by canonical key. The box writes some keys into two measurements: the first
 * occurrence wins.
 */
-function createSnapshot(source, readings, fetchedAt, fallbackReason) {
+function createSnapshot(source, readings, fetchedAt, fallbackReason, texts = []) {
 	const map = /* @__PURE__ */ new Map();
 	for (const reading of readings) {
 		const key = canonicalKey(reading.key);
@@ -103338,9 +104961,15 @@ function createSnapshot(source, readings, fetchedAt, fallbackReason) {
 			key
 		});
 	}
+	const textMap = /* @__PURE__ */ new Map();
+	for (const text of texts) {
+		const key = canonicalKey(text.key);
+		if (!textMap.has(key)) textMap.set(key, text.value);
+	}
 	return {
 		source,
 		readings: map,
+		texts: textMap,
 		fetchedAt,
 		...fallbackReason !== void 0 ? { fallbackReason } : {}
 	};
@@ -103399,14 +105028,42 @@ async function readInflux(input) {
 		}
 	}, input.fetch));
 	if (readings.length === 0) throw new EnpalError("empty", "influxdb", `Enpal InfluxDB on ${connection.host} returned no series for bucket "${connection.bucket}" in the last two hours`);
-	return readings;
+	return {
+		readings,
+		texts: []
+	};
+}
+async function readBlazor(input) {
+	const { connection } = input;
+	if (input.blazor === void 0) throw new EnpalError("bridge-unavailable", "blazor", "The embedded Python the Enpal bridge needs is not available on this node");
+	let readings;
+	let texts;
+	try {
+		const rows = await input.blazor({
+			host: connection.host,
+			port: connection.pagePort
+		});
+		readings = blazorRowsToReadings(rows);
+		texts = blazorRowsToTexts(rows);
+	} catch (error) {
+		if (!(error instanceof BlazorBridgeError)) throw error;
+		throw new EnpalError(error.kind === "protocol" ? "bad-response" : error.kind, "blazor", error.message);
+	}
+	if (readings.length === 0) throw new EnpalError("empty", "blazor", `Enpal box ${connection.host} sent no numeric sensor rows`);
+	return {
+		readings,
+		texts
+	};
 }
 async function readPage(input) {
 	const { connection } = input;
 	const url = `http://${connection.host}:${connection.pagePort}/deviceMessages`;
 	const readings = parseDeviceMessages(await request("device-page", connection.host, url, { method: "GET" }, input.fetch));
 	if (readings.length === 0) throw new EnpalError("empty", "device-page", `The device page of ${connection.host} lists no device rows (firmware 8.51 and later render them only through the web socket)`);
-	return readings;
+	return {
+		readings,
+		texts: []
+	};
 }
 function reasonOf(error) {
 	return {
@@ -103414,28 +105071,64 @@ function reasonOf(error) {
 		message: error.message
 	};
 }
+var READERS = {
+	blazor: readBlazor,
+	influxdb: readInflux,
+	"device-page": readPage
+};
+/** One reason from several: the kind of the first real failure, every message. */
+function joinReasons(reasons) {
+	if (reasons.length === 0) return void 0;
+	return {
+		kind: reasons.find((r) => r.kind !== "bridge-unavailable")?.kind ?? "bridge-unavailable",
+		message: reasons.map((r) => r.message).join("; ")
+	};
+}
+var PYTHON_MISSING = {
+	kind: "bridge-unavailable",
+	message: "Python is not available on this node, so the box web channel (the only complete source on firmware 8.51 and later) is not used"
+};
 /**
-* Read every data point the box reports, once. `auto` tries InfluxDB first (stable, numeric)
-* and falls back to the device page, recording why on the snapshot; when both fail the
-* InfluxDB failure is the one reported. A failed read throws {@link EnpalError}: it never
-* yields a snapshot of zeros.
+* Read every data point the box reports, once. `auto` tries the Blazor channel first (the
+* only one that carries the device tables on firmware 8.51 and later, no credential), then
+* InfluxDB when a token is set, then the device page. The snapshot records why a preferred
+* source was not used: Python missing, the channel skipped after a recent failure, or the
+* failure itself. A Blazor failure in `auto` is remembered for {@link BLAZOR_BACKOFF_MS}.
+* When every source fails the FIRST real failure is the one reported. A failed read throws
+* {@link EnpalError}: it never yields a snapshot of zeros.
 */
 async function readEnpalSnapshot(input) {
-	const { source } = input.connection;
-	if (source === "influx") return createSnapshot("influxdb", await readInflux(input), input.now());
-	if (source === "page") return createSnapshot("device-page", await readPage(input), input.now());
-	if (!(input.tokenLocked !== true && input.connection.token.trim().length > 0)) return createSnapshot("device-page", await readPage(input), input.now());
-	try {
-		return createSnapshot("influxdb", await readInflux(input), input.now());
-	} catch (primary) {
-		if (!(primary instanceof EnpalError)) throw primary;
-		try {
-			return createSnapshot("device-page", await readPage(input), input.now(), reasonOf(primary));
-		} catch (secondary) {
-			if (!(secondary instanceof EnpalError)) throw secondary;
-			throw primary;
+	const { source: mode } = input.connection;
+	const now = input.now();
+	const hasToken = input.tokenLocked !== true && input.connection.token.trim().length > 0;
+	const reasons = [];
+	let first;
+	const order = [];
+	if (mode === "blazor") order.push("blazor");
+	else if (mode === "influx") order.push("influxdb");
+	else if (mode === "page") order.push("device-page");
+	else {
+		if (input.blazor === void 0) reasons.push(PYTHON_MISSING);
+		else {
+			const skip = input.blazorBackoff?.skipReason(now) ?? null;
+			if (skip !== null) reasons.push(skip);
+			else order.push("blazor");
 		}
+		if (hasToken) order.push("influxdb");
+		order.push("device-page");
 	}
+	for (const source of order) try {
+		const read = await READERS[source](input);
+		if (source === "blazor") input.blazorBackoff?.recovered();
+		return createSnapshot(source, read.readings, now, joinReasons(reasons), read.texts);
+	} catch (error) {
+		if (!(error instanceof EnpalError)) throw error;
+		if (source === "blazor" && mode === "auto") input.blazorBackoff?.failed(now, reasonOf(error));
+		first ??= error;
+		reasons.push(reasonOf(error));
+	}
+	if (first === void 0) throw new Error("readEnpalSnapshot: no source to read");
+	throw first;
 }
 //#endregion
 //#region src/enpal-integration-manager.ts
@@ -103450,6 +105143,9 @@ var EnpalIntegrationManager = class {
 	#snapshot = null;
 	#lastError = null;
 	#timer = null;
+	#blazorBackoff = new BlazorBackoff();
+	#lastSource = null;
+	#lastFallbackKey = null;
 	#inFlight = null;
 	#stopped = true;
 	#failureLogged = false;
@@ -103481,7 +105177,7 @@ var EnpalIntegrationManager = class {
 		if (this.#stopped || this.#timer !== null) return;
 		this.#timer = setInterval(() => {
 			this.poll();
-		}, this.#options.connection.pollIntervalMs);
+		}, effectivePollIntervalMs(this.#options.connection));
 		this.#timer.unref();
 	}
 	async stop() {
@@ -103501,6 +105197,19 @@ var EnpalIntegrationManager = class {
 		this.#inFlight = run;
 		return run;
 	}
+	/**
+	* A preferred source that is not in use is said once per change of source or of reason kind (the back-off text changes every poll, the cause does not), not
+	* once per boot: a box that drops from the web channel to the page mid-run is visible.
+	*/
+	#logSourceChange(source, fallback) {
+		const fallbackMessage = fallback?.message;
+		const fallbackKey = fallback?.kind ?? null;
+		const changed = source !== this.#lastSource || fallbackKey !== this.#lastFallbackKey;
+		if (changed && fallbackMessage !== void 0) this.#options.logger.warn(`Enpal box ${this.name}: preferred source not used (${fallbackMessage}), reading ${source}`);
+		else if (changed && this.#lastSource !== null && source !== this.#lastSource) this.#options.logger.info(`Enpal box ${this.name}: now reading ${source}`);
+		this.#lastSource = source;
+		this.#lastFallbackKey = fallbackKey;
+	}
 	async #pollOnce() {
 		const wasConnected = this.#status === "connected";
 		try {
@@ -103508,6 +105217,8 @@ var EnpalIntegrationManager = class {
 				connection: this.#options.connection,
 				tokenLocked: this.#options.tokenLocked,
 				fetch: this.#fetch,
+				blazor: this.#options.blazor?.(),
+				blazorBackoff: this.#blazorBackoff,
 				now: this.#options.now ?? Date.now
 			});
 			if (this.#stopped) return;
@@ -103515,7 +105226,7 @@ var EnpalIntegrationManager = class {
 			this.#lastError = null;
 			this.#status = "connected";
 			if (this.#failureLogged || !wasConnected) this.#options.logger.info(`Enpal box ${this.name} reachable through ${snapshot.source} (${snapshot.readings.size} data points)`);
-			if (snapshot.fallbackReason !== void 0 && !wasConnected) this.#options.logger.warn(`Enpal box ${this.name}: InfluxDB not used (${snapshot.fallbackReason.kind}), reading the device page`);
+			this.#logSourceChange(snapshot.source, snapshot.fallbackReason);
 			this.#failureLogged = false;
 			if (!wasConnected) this.#options.onConnected();
 			this.#options.onPolled();
@@ -103572,6 +105283,7 @@ var EnpalClientRegistry = class {
 			tokenLocked,
 			logger: this.#logger.withTags({ integrationId }),
 			fetch: this.#deps.fetch,
+			blazor: this.#deps.blazor,
 			now: this.#deps.now,
 			onConnected: () => {
 				this.#deps.onConnected(integrationId);
@@ -103618,6 +105330,26 @@ var EnpalClientRegistry = class {
 	}
 };
 //#endregion
+//#region src/enpal-python-paths.ts
+var WORKER = "enpal_worker.py";
+/**
+* Absolute path of the bundled `python/enpal_worker.py`: next to `dist/` in a deployed
+* package, two levels up from `src/` in the workspace.
+*/
+function resolveEnpalWorker(fromModuleUrl = require("url").pathToFileURL(__filename).href) {
+	const here = (0, node_path.dirname)((0, node_url.fileURLToPath)(fromModuleUrl));
+	const candidates = [
+		(0, node_path.join)(here, "../python"),
+		(0, node_path.join)(here, "../../python"),
+		(0, node_path.join)(here, "python")
+	];
+	for (const dir of candidates) {
+		const file = (0, node_path.join)(dir, WORKER);
+		if ((0, node_fs.existsSync)(file)) return file;
+	}
+	throw new Error(`provider-enpal: ${WORKER} not found. Searched:\n${candidates.join("\n")}`);
+}
+//#endregion
 //#region src/enpal-instances.ts
 /**
 * Enpal integrations as `integration-instances` (planning#416, D1007): one `connections` record
@@ -103799,23 +105531,29 @@ async function cascadeRemoveDevicesForIntegration(input) {
 var enpalGatewaySchema = object({
 	equipment: literal("box"),
 	integrationId: string().min(1).describe("Owning integration"),
-	system: literal(ENPAL_SYSTEM).optional()
+	system: literal(ENPAL_SYSTEM).optional(),
+	/** The box diagnostics it was adopted with; a box adopted before they existed has none. */
+	specIds: array(string().min(1)).default([])
 });
 /**
-* The Enpal box itself, as a {@link DeviceType.Gateway}. Its connection lives on the
-* INTEGRATION; this device is the box's presence in the device list, and carries the one
-* action the box really supports: `device-admin-link`, its local device page. The box has no
-* reboot and no update. Equipment is NOT a child of it; each piece is adopted as its own
-* top-level Container. Online follows the integration's box (the integration marks it
-* offline when a poll fails).
+* The Enpal box itself ("Enpal Box"), as a {@link DeviceType.Gateway}. Its connection lives on
+* the INTEGRATION; this device is the box's presence in the device list: its identity and
+* firmware as device attributes, its own diagnostics (CPU, memory, LTE) as hidden Sensor
+* children, and the one action the box really supports, `device-admin-link`, its local device
+* page. The box has no reboot and no update. The System and the heat pump are NOT children of
+* it; each is adopted as its own top-level Container. Online follows the integration's box
+* (the integration marks it offline when a poll fails).
 */
 var EnpalGatewayDevice = class extends BaseDevice {
 	features = [];
 	integrationId;
+	specIds;
+	snapshotUnsub = null;
 	constructor(ctx) {
 		const cfg = enpalGatewaySchema.parse(ctx.persistedConfig ?? {});
 		super(ctx, enpalGatewaySchema, { type: DeviceType.Gateway });
 		this.integrationId = cfg.integrationId;
+		this.specIds = cfg.specIds;
 		this.online = enpalConnections.getSnapshot(this.integrationId) !== null;
 		this.registerAdminLinkCap();
 		this.updateSourceInfo({
@@ -103823,6 +105561,37 @@ var EnpalGatewayDevice = class extends BaseDevice {
 			system: ENPAL_SYSTEM
 		});
 	}
+	async onActivate() {
+		await super.onActivate();
+		const metadata = new EnpalMetadataSync({
+			equipment: "box",
+			deviceId: this.id,
+			getSnapshot: () => enpalConnections.getSnapshot(this.integrationId),
+			write: async (patch) => {
+				await this.ctx.api.deviceManager.setMetadata.mutate({
+					deviceId: this.id,
+					patch
+				});
+			},
+			logger: this.ctx.logger
+		});
+		this.snapshotUnsub = enpalConnections.onSnapshot(this.integrationId, () => {
+			metadata.apply();
+		});
+		await metadata.apply();
+	}
+	async removeDevice() {
+		this.snapshotUnsub?.();
+		this.snapshotUnsub = null;
+		await super.removeDevice();
+	}
+	getAccessoryChildren() {
+		return accessoryChildSpecs({
+			equipment: "box",
+			specIds: this.specIds,
+			integrationId: this.integrationId
+		});
+	}
 	/** The box's local device page (plain HTTP, the page port); no credentials in the URL. */
 	registerAdminLinkCap() {
 		this.ctx.registerNativeCap(deviceAdminLinkCapability, { getAdminLink: async ({ deviceId }) => {
@@ -103878,10 +105647,11 @@ var ENPAL_MIGRATIONS_DATE = "2026-11-05";
 /**
 * Enpal solar box provider, `mode: account` and broker-less. An integration is one box: its
 * host, InfluxDB access and token live on the integration's settings, and the addon polls it
-* with one manager per `integrationId`. Discovery offers the box itself
-* ({@link DeviceType.Gateway}, with a link to its device page) and one
-* {@link DeviceType.Container} per piece of equipment it reports (photovoltaic, battery,
-* grid, house, heat pump), and adopting a container adopts its Sensor children.
+* with one manager per `integrationId`. Discovery offers three pieces, each adopted only when
+* the operator picks it: the box itself ("Enpal Box", a {@link DeviceType.Gateway} carrying its
+* firmware, its diagnostics and a link to its device page), the "System" (PV, battery, grid,
+* house meter) and the "Heat pump (Enpal)", both {@link DeviceType.Container}s. Adopting a
+* piece adopts its Sensor children; a Container declares which of them stands for it.
 *
 * The box does not advertise itself on the network, so the integration is added by hand.
 */
@@ -103895,6 +105665,8 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 	integrationReconciler = null;
 	clients = null;
 	instances = null;
+	/** The Python bridge to the box's Blazor channel; null while the node has no embedded Python. */
+	blazorReader = null;
 	constructor() {
 		super({});
 	}
@@ -103917,7 +105689,9 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 			kind: enpalConnectionsEntryKind
 		}));
 		this.instances = buildEnpalInstances(records, { onChanged: () => this.reconcileIntegrations() });
+		this.blazorReader = await this.createBlazorBridge();
 		this.clients = new EnpalClientRegistry(this.ctx.logger, {
+			blazor: () => this.blazorReader ?? void 0,
 			onConnected: (integrationId) => this.setIntegrationDevicesOnline(integrationId, true),
 			onDisconnected: (integrationId) => this.setIntegrationDevicesOnline(integrationId, false)
 		});
@@ -103942,11 +105716,32 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 			this.ctx.logger.warn("Enpal shutdown error", { meta: { error: errMsg(err) } });
 		}
 		this.clients = null;
+		this.blazorReader = null;
 		this.integrationReconciler?.dispose();
 		this.integrationReconciler = null;
 		enpalConnections.clear();
 		await super.onShutdown();
 	}
+	/**
+	* The embedded Python and the bundled worker, or null with a logged reason: the addon then
+	* reads InfluxDB or the device page, which on firmware 8.51 and later hold less.
+	*/
+	async createBlazorBridge() {
+		try {
+			const pythonPath = await this.ctx.deps.ensurePython();
+			if (pythonPath === null) {
+				this.ctx.logger.warn("Enpal: embedded Python is unavailable, the Blazor channel is not used");
+				return null;
+			}
+			return createBlazorReader({
+				pythonPath,
+				scriptPath: resolveEnpalWorker()
+			});
+		} catch (err) {
+			this.ctx.logger.warn("Enpal: the Python bridge could not be prepared", { meta: { error: errMsg(err) } });
+			return null;
+		}
+	}
 	requireInstances() {
 		if (!this.instances) throw new Error("Enpal provider not initialised");
 		return this.instances;
@@ -104050,7 +105845,7 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 				}
 				return out;
 			},
-			adoptDevice: async ({ equipment, specIds, integrationId, name }) => {
+			adoptDevice: async ({ equipment, specIds, integrationId, name, childLayout, primaryChildPreference }) => {
 				const devices = this.ctx.kernel.devices;
 				if (!devices) throw new Error("enpal adopt: kernel.devices unavailable");
 				const config = {
@@ -104063,7 +105858,9 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 				const device = await devices.create(stableId, EnpalEquipmentDevice, config, null, {
 					type: DeviceType.Container,
 					name,
-					integrationId
+					integrationId,
+					...childLayout.length > 0 ? { childLayout } : {},
+					...primaryChildPreference.length > 0 ? { primaryChildPreference } : {}
 				});
 				const children = await devices.getChildren(device.id);
 				return {
@@ -104071,20 +105868,27 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 					accessoryDeviceIds: children.map((c) => c.id)
 				};
 			},
-			adoptGateway: async ({ integrationId, name }) => {
+			adoptGateway: async ({ integrationId, name, specIds, childLayout }) => {
 				const devices = this.ctx.kernel.devices;
 				if (!devices) throw new Error("enpal adopt: kernel.devices unavailable");
 				const config = {
 					equipment: "box",
+					specIds,
 					integrationId,
 					system: ENPAL_SYSTEM
 				};
 				const stableId = this.generateStableId(DeviceType.Gateway, config);
-				return { deviceId: (await devices.create(stableId, EnpalGatewayDevice, config, null, {
+				const device = await devices.create(stableId, EnpalGatewayDevice, config, null, {
 					type: DeviceType.Gateway,
 					name,
-					integrationId
-				})).id };
+					integrationId,
+					...childLayout.length > 0 ? { childLayout } : {}
+				});
+				const children = await devices.getChildren(device.id);
+				return {
+					deviceId: device.id,
+					accessoryDeviceIds: children.map((c) => c.id)
+				};
 			},
 			removeDevice: async (id) => {
 				await this.ctx.kernel.devices?.remove(id);