@camstack/addon-provider-enpal 0.1.15 → 0.1.16

package/dist/addon.mjs

@@ -1,3 +1,7 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 //#region ../types/dist/event-category-78tcBemo.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -6025,7 +6029,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-Dz1P6--1.mjs
+//#region ../types/dist/sleep-Cw1uUXvl.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -15066,6 +15070,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),
@@ -15333,6 +15338,7 @@ var CAP_NAMES = Object.freeze([
 	"camera-streams",
 	"carbon-monoxide",
 	"climate-control",
+	"cluster-update",
 	"color",
 	"composer",
 	"connectivity",
@@ -49549,6 +49555,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.
@@ -50880,7 +51020,7 @@ var mediaPlayerCapability = {
 	} }
 };
 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 = {
+var NUMBER$1 = {
 	kind: "fixed",
 	result: ["number"]
 };
@@ -50889,19 +51029,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,
@@ -50918,7 +51058,7 @@ Object.freeze({
 		kind: "fixed",
 		result: ["number", "null"]
 	},
-	count: NUMBER,
+	count: NUMBER$1,
 	dwell: {
 		kind: "fixed",
 		result: ["boolean", "null"]
@@ -50944,7 +51084,7 @@ var CHANGED = {
 	fieldPath: "lastChangedAt",
 	expr: "now"
 };
-function numeric(input) {
+function numeric$1(input) {
 	const { alsoFrom, ...base } = input;
 	return {
 		...base,
@@ -50979,7 +51119,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,
@@ -50997,7 +51137,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,
@@ -51015,7 +51155,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,
@@ -51026,7 +51166,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,
@@ -51037,7 +51177,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,
@@ -51048,7 +51188,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,
@@ -51059,7 +51199,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,
@@ -51083,7 +51223,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,
@@ -53021,6 +53161,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(),
@@ -53506,6 +53730,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()
 });
@@ -53654,6 +53881,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(),
@@ -53869,6 +54099,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()
@@ -54006,7 +54242,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({
@@ -57704,6 +57940,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"). */
@@ -69493,13 +69731,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);
@@ -73537,18 +73785,18 @@ var powerSourceCapability = {
 	mode: "singleton",
 	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
 	methods: {
-		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "admin" }),
+		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "protected" }),
 		powerOn: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		}),
 		powerOff: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		}),
 		forceRestart: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		})
 	},
 	runtimeState: PowerSourceStateSchema,
@@ -88298,6 +88546,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",
@@ -89670,6 +89939,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",
@@ -89761,6 +90037,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",
@@ -94400,28 +94683,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",
@@ -98285,6 +98568,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceManager.setPrimaryChildPreference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.setRole": [{
 		name: "deviceId",
 		form: "single",
@@ -101753,7 +102041,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(),
@@ -101769,7 +102059,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(),
@@ -102135,13 +102427,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) {
@@ -102159,6 +102453,7 @@ var FLUX_NAME = /^[A-Za-z0-9_.-]+$/;
 var ENPAL_SYSTEM = "enpal";
 var ENPAL_SOURCES = [
 	"auto",
+	"blazor",
 	"influx",
 	"page"
 ];
@@ -102219,7 +102514,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: [
@@ -102232,9 +102527,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",
@@ -102350,6 +102650,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
@@ -102432,7 +102748,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")
 	},
 	{
@@ -102482,7 +102798,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);
@@ -102494,6 +102890,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) {
@@ -102507,6 +102904,7 @@ function pointsOf(spec) {
 		];
 		case "meter":
 		case "numeric": return [spec.value];
+		case "text": return [];
 	}
 }
 function resolve(target, snapshot) {
@@ -102514,7 +102912,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;
@@ -102533,7 +102931,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;
@@ -102632,6 +103030,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
@@ -102729,6 +103138,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,
@@ -102740,6 +103150,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.
@@ -102777,7 +103192,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() {
@@ -102835,6 +103251,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) {
@@ -102849,6 +103266,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);
@@ -102878,43 +103299,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);
@@ -102928,24 +103472,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,
@@ -102958,18 +103539,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 });
@@ -102982,6 +103632,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,
@@ -102990,18 +103676,41 @@ 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,
@@ -103010,13 +103719,13 @@ function buildEnpalCandidates(input) {
 		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,
@@ -103027,16 +103736,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;
@@ -103050,7 +103750,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()) {
@@ -103126,20 +103831,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 ?? boxName(integrationId),
+						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,
@@ -103148,13 +103856,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,
@@ -103185,10 +103894,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 = 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*)$/;
@@ -103211,7 +104097,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);
@@ -103327,7 +104213,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);
@@ -103337,9 +104223,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 } : {}
 	};
@@ -103398,14 +104290,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 {
@@ -103413,28 +104333,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
@@ -103449,6 +104405,9 @@ var EnpalIntegrationManager = class {
 	#snapshot = null;
 	#lastError = null;
 	#timer = null;
+	#blazorBackoff = new BlazorBackoff();
+	#lastSource = null;
+	#lastFallbackKey = null;
 	#inFlight = null;
 	#stopped = true;
 	#failureLogged = false;
@@ -103480,7 +104439,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() {
@@ -103500,6 +104459,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 {
@@ -103507,6 +104479,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;
@@ -103514,7 +104488,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();
@@ -103571,6 +104545,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);
@@ -103617,6 +104592,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 = import.meta.url) {
+	const here = dirname(fileURLToPath(fromModuleUrl));
+	const candidates = [
+		join(here, "../python"),
+		join(here, "../../python"),
+		join(here, "python")
+	];
+	for (const dir of candidates) {
+		const file = join(dir, WORKER);
+		if (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
@@ -103798,23 +104793,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({
@@ -103822,6 +104823,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 }) => {
@@ -103877,10 +104909,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.
 */
@@ -103894,6 +104927,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({});
 	}
@@ -103916,7 +104951,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)
 		});
@@ -103941,11 +104978,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;
@@ -104049,7 +105107,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 = {
@@ -104062,7 +105120,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 {
@@ -104070,20 +105130,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);