@camstack/addon-provider-enpal 0.1.1 → 0.1.2

package/dist/addon.js

@@ -10470,20 +10470,6 @@ object({
 	code: string().regex(/^[a-z][a-z0-9-]*(\.[a-z0-9-]+)+$/),
 	params: record(string(), union([string(), number()])).optional()
 });
-var CamstackError = class extends Error {
-	i18nCode;
-	i18nParams;
-	constructor(code, params, englishMessage) {
-		super(englishMessage);
-		this.name = "CamstackError";
-		this.i18nCode = code;
-		this.i18nParams = params;
-	}
-};
-/** `throw userError('device.not-found', { id }, 'Device 12 not found')` */
-function userError(code, params, englishFallback) {
-	return new CamstackError(code, params, englishFallback);
-}
 //#endregion
 //#region ../types/dist/err-msg-DIorGYeC.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
@@ -21033,19 +21019,36 @@ var ResyncResultSchema = object({
 	*  provider re-derived the device. 0/absent for a normal incremental re-sync. */
 	removedChildren: number().int().nonnegative().optional()
 });
-method(object({ integrationId: string() }), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }), method(ListCandidatesInputSchema, ListCandidatesOutputSchema, { auth: "admin" }), method(GetCandidateInputSchema, DiscoveredChildDeviceSchema.nullable(), { auth: "admin" }), method(object({ integrationId: string() }), AdoptionStatusSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(AdoptInputSchema, AdoptResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(ReleaseInputSchema, _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(ResyncInputSchema, ResyncResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-});
+var deviceAdoptionCapability = {
+	name: "device-adoption",
+	scope: "system",
+	mode: "collection",
+	status: {
+		schema: AdoptionStatusSchema,
+		kind: "poll"
+	},
+	methods: {
+		listCandidateFilters: method(object({ integrationId: string() }), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }),
+		listCandidates: method(ListCandidatesInputSchema, ListCandidatesOutputSchema, { auth: "admin" }),
+		getCandidate: method(GetCandidateInputSchema, DiscoveredChildDeviceSchema.nullable(), { auth: "admin" }),
+		refresh: method(object({ integrationId: string() }), AdoptionStatusSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		adopt: method(AdoptInputSchema, AdoptResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		release: method(ReleaseInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		resync: method(ResyncInputSchema, ResyncResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
+	}
+};
 /**
 * `device-export` — collection cap for addons that export camstack
 * devices to external ecosystems (HomeAssistant via MQTT discovery,
@@ -64361,9 +64364,9 @@ var PowerMeterStatusSchema = object({
 	/** Cumulative energy in kilowatt-hours since the meter was reset. */
 	kwhTotal: number().optional().meta(readingMeta("energy", { label: "Energy" })),
 	/** Voltage in volts. */
-	volts: number().optional().meta(readingMeta("voltage")),
+	volts: number().optional().meta(readingMeta("voltage", { label: "Voltage" })),
 	/** Current in amperes. */
-	amps: number().optional().meta(readingMeta("current")),
+	amps: number().optional().meta(readingMeta("current", { label: "Current" })),
 	/** Apparent power in volt-amperes. */
 	va: number().optional().meta(readingMeta("apparent-power")),
 	/** Power factor (0..1) if reported. */
@@ -64371,17 +64374,74 @@ var PowerMeterStatusSchema = object({
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: number()
 });
+/**
+* Loads that draw metered mains power (D951). The reading is a feature of the
+* device itself — a plug, a lamp, a fan, an air conditioner, a boiler, a
+* vacuum dock — not a separate sensor beside it. A `Sensor` stays: a clamp
+* meter or a standalone energy monitor IS the device. Cover, lock, valve,
+* camera and the like are left out: their draw is not what anyone meters.
+*/
+var POWER_METER_DEVICE_TYPES = [
+	DeviceType.Sensor,
+	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
+];
+/** 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);
+/** One scalar target per reading; each is sourced from a device of its own (D951). */
+function powerTarget(id, unit) {
+	return {
+		id,
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-meter",
+			stateField: id
+		},
+		deviceTypes: POWER_METER_CUSTOMIZE_DEVICE_TYPES,
+		apply: "add",
+		path: id,
+		sources: [{
+			kind: "numeric",
+			requiredUnit: unit,
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	};
+}
+/** "Power and energy" extension: watts, energy, voltage and current from other devices (D951). */
+var powerMeterCustomize = {
+	version: 1,
+	targets: [
+		powerTarget("watts", "W"),
+		powerTarget("kwhTotal", "kWh"),
+		powerTarget("volts", "V"),
+		powerTarget("amps", "A")
+	]
+};
 var powerMeterCapability = {
 	name: "power-meter",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [
-		DeviceType.Sensor,
-		DeviceType.Washer,
-		DeviceType.Dryer,
-		DeviceType.Dishwasher
-	],
+	deviceTypes: POWER_METER_DEVICE_TYPES,
 	methods: {},
 	status: {
 		schema: PowerMeterStatusSchema,
@@ -64438,7 +64498,8 @@ var powerMeterCapability = {
 	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
+	volatileStateFields: ["lastFetchedAt"],
+	customize: powerMeterCustomize
 };
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
@@ -70209,7 +70270,7 @@ function tryConvertUnit(value, from, to) {
 	return fromCanonical(toCanonical(value, fromSpec), toSpec);
 }
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Camera, DeviceType.Camera, 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.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Camera, 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.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.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.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.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
 String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 DeviceRole.BinarySensor, DeviceRole.MotionSensor;
 new Set(CAP_NAMES);
@@ -89643,9 +89704,9 @@ var MB = 1024 * 1024;
 //#endregion
 //#region src/config.ts
 /**
-* Operator-supplied connection for ONE Enpal box. The addon runs in `standalone`
-* mode (the VeSync / Ecowitt / Velux pattern): the CONNECTION lives on the box
-* DEVICE config, there is no broker registry.
+* Operator-supplied connection of ONE Enpal integration (`mode: account`, broker-less): the
+* 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`:
 *   - `influx`: the box's InfluxDB 2.x (port 8086, org `enpal`, bucket `solar`).
@@ -89666,6 +89727,10 @@ function markerToEmpty(value) {
 	return value === null || value === void 0 ? "" : value;
 }
 var blankToUndefined = (v) => v === "" || v === null ? void 0 : v;
+/** Names that are interpolated into a Flux string: no quote, no space, no operator. */
+var FLUX_NAME = /^[A-Za-z0-9_.-]+$/;
+/** The device-registry `system` tag every Enpal device carries. */
+var ENPAL_SYSTEM = "enpal";
 var enpalConnectionSchema = object({
 	host: preprocess(cleanHost, string().min(1).regex(/^[A-Za-z0-9._-]+$/, "host name or IP address only").describe("Enpal box host name or IP address")),
 	source: _enum([
@@ -89675,7 +89740,7 @@ var enpalConnectionSchema = object({
 	]).default("auto").describe("Where the readings come from"),
 	influxPort: preprocess(blankToUndefined, number().int().min(1).max(65535).default(8086)).describe("InfluxDB port"),
 	org: string().trim().min(1).default("enpal").describe("InfluxDB organisation"),
-	bucket: string().trim().regex(/^[A-Za-z0-9_.-]+$/, "letters, digits, dot, dash and underscore only").default("solar").describe("InfluxDB bucket"),
+	bucket: string().trim().regex(FLUX_NAME, "letters, digits, dot, dash and underscore only").default("solar").describe("InfluxDB bucket"),
 	token: preprocess(markerToEmpty, string().default("")).describe("InfluxDB access token (issued by Enpal support)").meta({ secret: true }),
 	pagePort: preprocess(blankToUndefined, number().int().min(1).max(65535).default(80)).describe("Device page HTTP port"),
 	pollIntervalMs: preprocess(blankToUndefined, number().int().min(1e4).max(36e5).default(3e4)).describe("Poll interval (ms)"),
@@ -89698,30 +89763,21 @@ function readConnection(settings) {
 		tokenLocked: isSecretMarkerLike(raw["token"])
 	};
 }
-/** Persisted config for the Enpal box {@link import('@camstack/types').DeviceType.Hub} device. */
-var enpalBoxSchema = object({
-	connection: enpalConnectionSchema,
-	/** Provenance marker used to scope offline / cascade helpers. */
-	system: literal("enpal-box").optional()
-});
-/**
-* Persisted config every adopted Enpal device carries. `specId` selects the entry of the
-* device catalog (PV, battery, grid import, ...); `boxId` selects the parent box (its Hub
-* `stableId`) in the in-process resolver.
-*/
-var enpalSensorSchema = object({
-	specId: string().min(1).describe("Device catalog entry id"),
-	boxId: string().min(1).describe("Parent box stableId"),
-	system: literal("enpal").optional()
-});
-/** Slugify a host into a readable, stable row-key fragment. */
-function slugifyHost(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+/** Parse an integration's settings into a connection, or null while its host is missing. */
+function connectionFromSettings(settings) {
+	const raw = toRecord(settings);
+	const parsed = enpalConnectionSchema.safeParse(raw);
+	if (!parsed.success) return null;
+	return {
+		connection: parsed.data,
+		tokenLocked: isSecretMarkerLike(raw["token"])
+	};
 }
-/**
-* Hand-written connection form for the box device-creation UI. The connection lives on the box
-* DEVICE config; a `name` field lets the operator name it at creation time.
-*/
+/** True when two connections would poll the box the same way. */
+function sameConnection(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+/** The integration's settings form (`globalSettingsSchema`); the integration carries the name. */
 function buildConnectionFormSchema() {
 	return { sections: [
 		{
@@ -89730,13 +89786,6 @@ function buildConnectionFormSchema() {
 			titleKey: "provider-enpal:connection.s_identity.title",
 			columns: 1,
 			fields: [{
-				type: "text",
-				key: "name",
-				label: "Name",
-				labelKey: "provider-enpal:connection.s_identity.name.label",
-				required: true,
-				placeholder: "Enpal"
-			}, {
 				type: "text",
 				key: "host",
 				label: "Box host / IP",
@@ -89891,7 +89940,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "power-meter",
 		id: "pv",
-		name: "PV production",
+		name: "Production",
 		role: DeviceRole.PowerSensor,
 		watts: point("power", "Power.DC.Total", "Power.DC.Total.Calculated", "Power.DC.Total.Huawei", "Power.Production.Total"),
 		kwh: point("energy", "Energy.Production.Total.Lifetime")
@@ -89910,7 +89959,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "meter",
 		id: "battery-charged",
-		name: "Battery energy charged",
+		name: "Energy charged",
 		role: DeviceRole.EnergySensor,
 		quantity: "energy",
 		value: point("energy", "Energy.Battery.Charge.Lifetime")
@@ -89918,7 +89967,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "meter",
 		id: "battery-discharged",
-		name: "Battery energy discharged",
+		name: "Energy discharged",
 		role: DeviceRole.EnergySensor,
 		quantity: "energy",
 		value: point("energy", "Energy.Battery.Discharge.Lifetime")
@@ -89926,7 +89975,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "power-meter",
 		id: "grid-import",
-		name: "Grid import",
+		name: "Import",
 		role: DeviceRole.PowerSensor,
 		watts: point("power", "Grid.Import.Power.Total.Calculated", {
 			key: "Power.Grid.Export",
@@ -89943,7 +89992,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "power-meter",
 		id: "grid-export",
-		name: "Grid export",
+		name: "Export",
 		role: DeviceRole.PowerSensor,
 		watts: point("power", {
 			key: "Power.Grid.Export",
@@ -89960,7 +90009,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "power-meter",
 		id: "house",
-		name: "House consumption",
+		name: "Consumption",
 		role: DeviceRole.PowerSensor,
 		watts: point("power", "Power.Consumption.Total", "Power.Consumption.AC"),
 		kwh: point("energy", "Energy.Consumption.Total.Lifetime")
@@ -89968,7 +90017,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "power-meter",
 		id: "heatpump",
-		name: "Heat pump",
+		name: "Consumption",
 		role: DeviceRole.PowerSensor,
 		watts: point("power", "Heatpump.Power.Consumption.Total"),
 		kwh: point("energy", "Heatpump.Energy.Consumption.Total.Lifetime")
@@ -89976,7 +90025,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "heatpump-hot-water",
-		name: "Heat pump hot water",
+		name: "Hot water temperature",
 		role: DeviceRole.TemperatureSensor,
 		quantity: "temperature",
 		value: point("temperature", "Heatpump.DomesticHotWater.Temperature")
@@ -89984,7 +90033,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "heatpump-outside",
-		name: "Heat pump outside temperature",
+		name: "Outside temperature",
 		role: DeviceRole.TemperatureSensor,
 		quantity: "temperature",
 		value: point("temperature", "Heatpump.Outside.Temperature")
@@ -90000,7 +90049,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "battery-temperature",
-		name: "Battery temperature",
+		name: "Temperature",
 		role: DeviceRole.TemperatureSensor,
 		quantity: "temperature",
 		value: point("temperature", "Temperature.Battery")
@@ -90008,7 +90057,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "battery-health",
-		name: "Battery health",
+		name: "Health",
 		role: DeviceRole.NumericSensor,
 		quantity: "percentage",
 		value: point("percentage", "Battery.SOH")
@@ -90165,36 +90214,528 @@ function computeSlices(spec, snapshot, options, now) {
 	}
 }
 //#endregion
-//#region src/enpal-discovery.ts
-/** The `childNativeId` of a catalog entry on a box: namespaced so two boxes never collide. */
-function specNativeId(boxId, specId) {
-	return `${boxId}:${specId}`;
+//#region src/enpal-counter-guard.ts
+/**
+* Smaller than the history deadband of the lifetime counters (0.01 kWh): float noise from
+* rounding or a unit conversion, never a real drop.
+*/
+var NOISE = .01;
+/**
+* Keeps a lifetime counter monotonic before it reaches a `counter` history series, where a
+* drop means "the meter was reset" and re-bases every later total.
+*
+* The box occasionally reports 0 or a stale lower figure for one poll (a restart, a partly
+* written window). One such reading is held back: the previous value is published instead.
+* A lower reading that is then followed by a value at or above it is a genuine reset or a
+* replaced meter, and is accepted.
+*/
+var LifetimeCounterGuard = class {
+	#published = null;
+	#suspect = null;
+	/** The value to publish for the reading `next`. */
+	accept(next) {
+		const published = this.#published;
+		if (published === null || next >= published - NOISE) {
+			this.#published = next;
+			this.#suspect = null;
+			return next;
+		}
+		const suspect = this.#suspect;
+		if (suspect !== null && next >= suspect - NOISE) {
+			this.#published = next;
+			this.#suspect = null;
+			return next;
+		}
+		this.#suspect = next;
+		return published;
+	}
+};
+//#endregion
+//#region src/enpal-resolver.ts
+/**
+* Per-integration registry that the adopted devices use to reach the live
+* {@link EnpalIntegrationManager}. Keyed on the integration id; the client registry publishes
+* a new manager here whenever the connection changes, and the sensors read through the
+* resolver so they follow it.
+*/
+var EnpalConnectionResolver = class {
+	#managers = /* @__PURE__ */ new Map();
+	#subs = /* @__PURE__ */ new Map();
+	set(integrationId, manager) {
+		if (manager === null) {
+			this.#managers.delete(integrationId);
+			return;
+		}
+		this.#managers.set(integrationId, manager);
+	}
+	getManager(integrationId) {
+		return this.#managers.get(integrationId) ?? null;
+	}
+	/** The latest snapshot, or null when the box is unreachable (never stale readings). */
+	getSnapshot(integrationId) {
+		return this.#managers.get(integrationId)?.getSnapshot() ?? null;
+	}
+	/** Subscribe to poll ticks (successful or not). Returns an unsubscribe function. */
+	onSnapshot(integrationId, cb) {
+		let set = this.#subs.get(integrationId);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			this.#subs.set(integrationId, set);
+		}
+		set.add(cb);
+		return () => {
+			const current = this.#subs.get(integrationId);
+			current?.delete(cb);
+			if (current !== void 0 && current.size === 0) this.#subs.delete(integrationId);
+		};
+	}
+	emitSnapshot(integrationId) {
+		const set = this.#subs.get(integrationId);
+		if (set === void 0) return;
+		for (const cb of set) try {
+			cb();
+		} catch {}
+	}
+	clear() {
+		this.#managers.clear();
+		this.#subs.clear();
+	}
+};
+var enpalConnections = new EnpalConnectionResolver();
+//#endregion
+//#region src/devices/enpal-sensor-device.ts
+var POWER_CAP = powerMeterCapability.name;
+var BATTERY_CAP = batteryCapability.name;
+var METER_CAP = meterCapability.name;
+var NUMERIC_CAP = numericSensorCapability.name;
+var POWER_COLD = { lastFetchedAt: 0 };
+var BATTERY_COLD = {
+	percentage: null,
+	charging: "unknown",
+	sleeping: false,
+	lastUpdated: 0
+};
+var VALUE_COLD = {
+	value: null,
+	lastFetchedAt: 0
+};
+/**
+* Persisted config of an Enpal Sensor. `specId` selects the entry of the catalog;
+* `integrationId` selects the integration whose box feeds it.
+*/
+var enpalSensorSchema = object({
+	specId: string().min(1).describe("Device catalog entry id"),
+	integrationId: string().min(1).describe("Owning integration"),
+	system: literal(ENPAL_SYSTEM).optional()
+});
+/**
+* One Enpal data point group (production, state of charge, grid import, ...) as a
+* {@link DeviceType.Sensor} child of an equipment Container. The catalog entry in `specId`
+* says which caps it registers and which box keys feed them; the slices are recomputed from
+* the integration's snapshot on every poll tick.
+*
+* An unreachable box marks the device offline and leaves the slices alone: a failed read is
+* a gap, never a zero (D393). A lifetime counter passes through {@link LifetimeCounterGuard}
+* so one stale low reading cannot become a history reset.
+*/
+var EnpalSensorDevice = class extends BaseDevice {
+	features = [];
+	spec;
+	integrationId;
+	energyGuard = new LifetimeCounterGuard();
+	meterGuard = new LifetimeCounterGuard();
+	snapshotUnsub = null;
+	constructor(ctx) {
+		const cfg = enpalSensorSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, enpalSensorSchema, { type: ctx.deviceMeta.type });
+		const spec = findSpec(cfg.specId);
+		if (spec === void 0) throw new Error(`Enpal: unknown device kind "${cfg.specId}"`);
+		this.spec = spec;
+		this.integrationId = cfg.integrationId;
+		this.online = enpalConnections.getSnapshot(this.integrationId) !== null;
+		this.updateSourceInfo({
+			id: `${this.integrationId}:${spec.id}`,
+			system: ENPAL_SYSTEM,
+			...spec.kind === "meter" || spec.kind === "numeric" ? { quantity: spec.quantity } : {}
+		});
+	}
+	async onActivate() {
+		await super.onActivate();
+		this.registerCaps();
+		this.snapshotUnsub = enpalConnections.onSnapshot(this.integrationId, () => {
+			try {
+				this.recompute();
+			} catch (err) {
+				this.ctx.logger.warn("enpal sensor: snapshot handler failed", {
+					tags: { deviceId: this.id },
+					meta: {
+						spec: this.spec.id,
+						error: errMsg(err)
+					}
+				});
+			}
+		});
+		this.recompute();
+	}
+	async removeDevice() {
+		this.snapshotUnsub?.();
+		this.snapshotUnsub = null;
+		await super.removeDevice();
+	}
+	recompute() {
+		const snapshot = enpalConnections.getSnapshot(this.integrationId);
+		if (snapshot === null) {
+			if (this.online) this.markOnline(false);
+			return;
+		}
+		if (!this.online) this.markOnline(true);
+		const invert = enpalConnections.getManager(this.integrationId)?.connection.invertBatteryPower ?? false;
+		const slices = computeSlices(this.spec, snapshot, { invertBatteryPower: invert }, snapshot.fetchedAt);
+		this.publish(slices);
+		for (const line of slices.refusals) this.ctx.logger.warn(`enpal sensor: reading not used, ${line}`, {
+			tags: { deviceId: this.id },
+			meta: { spec: this.spec.id }
+		});
+	}
+	publish(slices) {
+		if (slices.powerMeter !== void 0) {
+			const kwh = slices.powerMeter.kwhTotal;
+			this.runtimeState.setCapState(POWER_CAP, kwh === void 0 ? slices.powerMeter : {
+				...slices.powerMeter,
+				kwhTotal: this.energyGuard.accept(kwh)
+			});
+		}
+		if (slices.battery !== void 0) this.runtimeState.setCapState(BATTERY_CAP, slices.battery);
+		if (slices.meter !== void 0) {
+			const raw = slices.meter.value;
+			this.runtimeState.setCapState(METER_CAP, {
+				...slices.meter,
+				value: raw === null ? null : this.meterGuard.accept(raw)
+			});
+		}
+		if (slices.numeric !== void 0) this.runtimeState.setCapState(NUMERIC_CAP, slices.numeric);
+	}
+	registerCaps() {
+		switch (this.spec.kind) {
+			case "power-meter":
+				this.registerPowerMeter();
+				return;
+			case "battery":
+				this.registerBattery();
+				this.registerPowerMeter();
+				return;
+			case "meter":
+				this.ctx.registerNativeCap(meterCapability, { getStatus: async () => this.runtimeState.getCapState(METER_CAP) ?? VALUE_COLD });
+				this.runtimeState.setCapState(METER_CAP, VALUE_COLD);
+				return;
+			case "numeric":
+				this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState(NUMERIC_CAP) ?? VALUE_COLD });
+				this.runtimeState.setCapState(NUMERIC_CAP, VALUE_COLD);
+				return;
+		}
+	}
+	registerPowerMeter() {
+		this.ctx.registerNativeCap(powerMeterCapability, { getStatus: async () => this.runtimeState.getCapState(POWER_CAP) ?? POWER_COLD });
+		this.runtimeState.setCapState(POWER_CAP, POWER_COLD);
+	}
+	registerBattery() {
+		this.ctx.registerNativeCap(batteryCapability, {
+			getStatus: async () => this.runtimeState.getCapState(BATTERY_CAP) ?? BATTERY_COLD,
+			wakeForStream: async () => ({
+				awoke: false,
+				durationMs: 0
+			})
+		});
+		this.runtimeState.setCapState(BATTERY_CAP, BATTERY_COLD);
+	}
+};
+//#endregion
+//#region src/devices/enpal-sensor-factory.ts
+/** Constructor closure the kernel calls for every Sensor child of an equipment Container. */
+function enpalSensorFactory(ctx) {
+	return new EnpalSensorDevice(ctx);
 }
-/** The catalog entry id of a {@link specNativeId} value, or null. */
-function parseSpecNativeId(boxId, childNativeId) {
-	const prefix = `${boxId}:`;
-	if (!childNativeId.startsWith(prefix)) return null;
-	const id = childNativeId.slice(prefix.length);
-	return id.length > 0 ? id : null;
+//#endregion
+//#region src/enpal-equipment.ts
+/** Order is the order the candidates are listed in. Every catalog entry belongs to one. */
+var ENPAL_EQUIPMENT = [
+	{
+		id: "pv",
+		name: "Photovoltaic",
+		specIds: ["pv", "inverter-temperature"]
+	},
+	{
+		id: "battery",
+		name: "Battery",
+		specIds: [
+			"battery",
+			"battery-charged",
+			"battery-discharged",
+			"battery-temperature",
+			"battery-health"
+		]
+	},
+	{
+		id: "grid",
+		name: "Grid",
+		specIds: ["grid-import", "grid-export"]
+	},
+	{
+		id: "house",
+		name: "House",
+		specIds: ["house"]
+	},
+	{
+		id: "heatpump",
+		name: "Heat pump",
+		specIds: [
+			"heatpump",
+			"heatpump-hot-water",
+			"heatpump-outside"
+		]
+	}
+];
+function findEquipment(id) {
+	return ENPAL_EQUIPMENT.find((e) => e.id === id);
 }
-/** One Sensor candidate per data group the box reported. Pure. */
-function buildCandidates(input) {
-	return input.specs.map((spec) => {
-		const adoptedDeviceId = input.adoptedDeviceIdBySpec[spec.id] ?? null;
-		return {
-			childNativeId: specNativeId(input.boxId, spec.id),
-			name: `${input.boxName} ${spec.name}`,
-			type: DeviceType.Sensor,
-			status: input.online ? "online" : "offline",
-			metadata: {
-				manufacturer: "Enpal",
-				integration: "enpal"
+/** The `childNativeId` of a child candidate: namespaced by its container. */
+function childNativeId(equipmentId, specId) {
+	return `${equipmentId}#${specId}`;
+}
+/**
+* Persisted config of an equipment Container. `specIds` are the children it was adopted with:
+* 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)"),
+	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. */
+function accessoryChildSpecs(config) {
+	const out = [];
+	for (const specId of config.specIds) {
+		const spec = findSpec(specId);
+		if (spec === void 0) continue;
+		out.push({
+			stableIdSuffix: spec.id,
+			meta: {
+				type: DeviceType.Sensor,
+				name: spec.name,
+				role: spec.role,
+				integrationId: config.integrationId
+			},
+			config: {
+				specId: spec.id,
+				integrationId: config.integrationId,
+				system: ENPAL_SYSTEM
 			},
-			alreadyAdopted: adoptedDeviceId !== null,
-			adoptedDeviceId,
-			capabilities: capsOfSpec(spec)
+			factory: enpalSensorFactory
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/devices/enpal-equipment-device.ts
+/**
+* One physical piece of the installation (photovoltaic, battery, grid, house, 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.
+*/
+var EnpalEquipmentDevice = class extends BaseDevice {
+	features = [];
+	equipment;
+	specIds;
+	integrationId;
+	constructor(ctx) {
+		const cfg = enpalEquipmentSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, enpalEquipmentSchema, { type: DeviceType.Container });
+		this.equipment = cfg.equipment;
+		this.specIds = cfg.specIds;
+		this.integrationId = cfg.integrationId;
+		this.online = enpalConnections.getSnapshot(this.integrationId) !== null;
+		this.updateSourceInfo({
+			id: `${this.integrationId}:${this.equipment}`,
+			system: ENPAL_SYSTEM
+		});
+	}
+	getAccessoryChildren() {
+		return accessoryChildSpecs({
+			equipment: this.equipment,
+			specIds: this.specIds,
+			integrationId: this.integrationId
+		});
+	}
+};
+//#endregion
+//#region src/enpal-discovery.ts
+var METADATA = {
+	manufacturer: "Enpal",
+	integration: "enpal"
+};
+/**
+* One Container candidate per equipment the box reported at least one value for, with the
+* Sensor children it reported. Pure.
+*/
+function buildEnpalCandidates(input) {
+	const { snapshot } = input;
+	if (snapshot === null) return [];
+	const reported = new Map(availableSpecs(snapshot).map((spec) => [spec.id, spec]));
+	const out = [];
+	for (const equipment of ENPAL_EQUIPMENT) {
+		const specs = equipment.specIds.flatMap((id) => reported.get(id) ?? []);
+		if (specs.length === 0) continue;
+		const adoptedId = input.adopted.get(equipment.id) ?? null;
+		out.push({
+			childNativeId: equipment.id,
+			name: equipment.name,
+			type: DeviceType.Container,
+			status: "online",
+			metadata: METADATA,
+			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)
+			}))
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/enpal-adoption-provider.ts
+var DEVICES_FILTER = {
+	id: "devices",
+	label: "Devices",
+	isDefault: true
+};
+function buildEnpalAdoptionProvider(deps) {
+	const { getSnapshot, hasIntegration, listIntegrations, listAdopted, logger } = deps;
+	async function adoptedMap(integrationId) {
+		const map = /* @__PURE__ */ new Map();
+		for (const device of await listAdopted()) {
+			const cfg = device.config;
+			if (cfg["system"] !== "enpal" || cfg["integrationId"] !== integrationId) continue;
+			const equipment = cfg["equipment"];
+			if (typeof equipment === "string") map.set(equipment, device.id);
+		}
+		return map;
+	}
+	async function candidates(integrationId) {
+		return buildEnpalCandidates({
+			snapshot: getSnapshot(integrationId),
+			adopted: await adoptedMap(integrationId)
+		});
+	}
+	async function status(integrationId) {
+		return {
+			lastDiscoveryAt: Date.now(),
+			candidateCount: (await candidates(integrationId)).length,
+			adoptedCount: (await adoptedMap(integrationId)).size,
+			lastError: null
 		};
-	});
+	}
+	return {
+		listCandidateFilters: async () => ({ filters: [DEVICES_FILTER] }),
+		listCandidates: async ({ integrationId, page, pageSize }) => {
+			const all = await candidates(integrationId);
+			const start = (page - 1) * pageSize;
+			return {
+				candidates: all.slice(start, start + pageSize),
+				totalCount: all.length,
+				page,
+				pageSize
+			};
+		},
+		getCandidate: async ({ integrationId, childNativeId }) => {
+			return (await candidates(integrationId)).find((c) => c.childNativeId === childNativeId) ?? null;
+		},
+		getStatus: async () => {
+			try {
+				let candidateCount = 0;
+				let adoptedCount = 0;
+				for (const integrationId of listIntegrations()) {
+					const s = await status(integrationId);
+					candidateCount += s.candidateCount;
+					adoptedCount += s.adoptedCount;
+				}
+				return {
+					lastDiscoveryAt: Date.now(),
+					candidateCount,
+					adoptedCount,
+					lastError: null
+				};
+			} catch (err) {
+				return {
+					lastDiscoveryAt: null,
+					candidateCount: 0,
+					adoptedCount: 0,
+					lastError: errMsg(err)
+				};
+			}
+		},
+		refresh: async ({ integrationId }) => status(integrationId),
+		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
+			if (!hasIntegration(integrationId)) throw new Error(`enpal adopt: integration ${integrationId} not found`);
+			const offered = await candidates(integrationId);
+			const adopted = [];
+			let failures = 0;
+			for (const equipmentId of childNativeIds) try {
+				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,
+						integrationId
+					} });
+					failures++;
+					continue;
+				}
+				const reported = new Set((candidate.children ?? []).map((c) => c.childNativeId));
+				const specIds = equipment.specIds.filter((id) => reported.has(`${equipment.id}#${id}`));
+				const { deviceId, accessoryDeviceIds } = await deps.adoptDevice({
+					equipment: equipment.id,
+					specIds,
+					integrationId,
+					name: perCandidate?.[equipmentId]?.name ?? equipment.name
+				});
+				adopted.push({
+					childNativeId: equipmentId,
+					parentDeviceId: deviceId,
+					accessoryDeviceIds
+				});
+			} catch (err) {
+				logger.warn("enpal adopt: failed to adopt equipment", { meta: {
+					equipment: equipmentId,
+					integrationId,
+					error: errMsg(err)
+				} });
+				failures++;
+			}
+			if (adopted.length === 0 && failures > 0) throw new Error(`enpal adopt: all ${failures} adopt(s) failed`);
+			return { adopted };
+		},
+		release: async ({ camDeviceId }) => {
+			await deps.removeDevice(camDeviceId);
+		},
+		resync: async ({ camDeviceId }) => {
+			const cfg = await deps.findDeviceConfig(camDeviceId);
+			if (cfg === null || cfg["system"] !== "enpal") throw new Error(`enpal resync: device ${camDeviceId} is not an Enpal device`);
+			return {
+				changed: false,
+				rebuiltChildren: 0
+			};
+		}
+	};
 }
 //#endregion
 //#region src/enpal-device-page.ts
@@ -90550,505 +91091,337 @@ var EnpalIntegrationManager = class {
 	}
 };
 //#endregion
-//#region src/enpal-resolver.ts
+//#region src/enpal-client-registry.ts
 /**
-* Per-box registry that the adopted devices use to reach the live
-* {@link EnpalIntegrationManager}. Keyed on the box Hub device's `stableId`; the box
-* publishes a new manager here whenever its connection changes, and children read through
-* the resolver so they follow it.
+* Owns one poller per Enpal integration (`Map<integrationId, manager>`) and publishes each on
+* {@link enpalConnections} so the devices follow it. The caller reconciles it against the
+* live integration list at boot and on every integration lifecycle event.
 */
-var EnpalBoxResolver = class {
-	#managers = /* @__PURE__ */ new Map();
-	#subs = /* @__PURE__ */ new Map();
-	set(boxId, manager) {
-		if (manager === null) {
-			this.#managers.delete(boxId);
-			return;
+var EnpalClientRegistry = class {
+	#logger;
+	#deps;
+	#entries = /* @__PURE__ */ new Map();
+	constructor(logger, deps) {
+		this.#logger = logger;
+		this.#deps = deps;
+	}
+	/**
+	* Ensure a poller runs for `integrationId` with this connection. An unchanged connection
+	* keeps the running poller; a changed one replaces it. Never throws: a box that is off is
+	* an `error` status, polled again later.
+	*/
+	async upsert(integrationId, name, connection, tokenLocked) {
+		const existing = this.#entries.get(integrationId);
+		if (existing !== void 0) {
+			if (existing.tokenLocked === tokenLocked && sameConnection(existing.connection, connection)) return;
+			await this.remove(integrationId);
+		}
+		const manager = new EnpalIntegrationManager({
+			id: integrationId,
+			name,
+			connection,
+			tokenLocked,
+			logger: this.#logger.withTags({ integrationId }),
+			fetch: this.#deps.fetch,
+			now: this.#deps.now,
+			onConnected: () => {
+				this.#deps.onConnected(integrationId);
+			},
+			onDisconnected: () => {
+				this.#deps.onDisconnected(integrationId);
+				enpalConnections.emitSnapshot(integrationId);
+			},
+			onPolled: () => {
+				enpalConnections.emitSnapshot(integrationId);
+			}
+		});
+		this.#entries.set(integrationId, {
+			manager,
+			connection,
+			tokenLocked
+		});
+		enpalConnections.set(integrationId, manager);
+		await manager.start();
+		if (manager.status === "error") {
+			this.#deps.onDisconnected(integrationId);
+			enpalConnections.emitSnapshot(integrationId);
 		}
-		this.#managers.set(boxId, manager);
 	}
-	getManager(boxId) {
-		return this.#managers.get(boxId) ?? null;
+	async remove(integrationId) {
+		const entry = this.#entries.get(integrationId);
+		if (entry === void 0) return;
+		this.#entries.delete(integrationId);
+		enpalConnections.set(integrationId, null);
+		await entry.manager.stop();
 	}
-	/** The latest snapshot, or null when the box is unreachable (never stale readings). */
-	getSnapshot(boxId) {
-		return this.#managers.get(boxId)?.getSnapshot() ?? null;
+	/** Stop every poller whose integration is not in `keep`. */
+	async retain(keep) {
+		for (const id of [...this.#entries.keys()]) if (!keep.has(id)) await this.remove(id);
 	}
-	/** Subscribe to poll ticks (successful or not). Returns an unsubscribe function. */
-	onSnapshot(boxId, cb) {
-		let set = this.#subs.get(boxId);
-		if (set === void 0) {
-			set = /* @__PURE__ */ new Set();
-			this.#subs.set(boxId, set);
-		}
-		set.add(cb);
-		return () => {
-			const current = this.#subs.get(boxId);
-			current?.delete(cb);
-			if (current !== void 0 && current.size === 0) this.#subs.delete(boxId);
-		};
+	async shutdown() {
+		for (const id of [...this.#entries.keys()]) await this.remove(id);
 	}
-	emitSnapshot(boxId) {
-		const set = this.#subs.get(boxId);
-		if (set === void 0) return;
-		for (const cb of set) try {
-			cb();
-		} catch {}
+	has(integrationId) {
+		return this.#entries.has(integrationId);
 	}
-	clear() {
-		this.#managers.clear();
-		this.#subs.clear();
+	list() {
+		return [...this.#entries.keys()];
 	}
 };
-var enpalBoxes = new EnpalBoxResolver();
 //#endregion
-//#region src/enpal-counter-guard.ts
-/**
-* Smaller than the history deadband of the lifetime counters (0.01 kWh): float noise from
-* rounding or a unit conversion, never a real drop.
-*/
-var NOISE = .01;
-/**
-* Keeps a lifetime counter monotonic before it reaches a `counter` history series, where a
-* drop means "the meter was reset" and re-bases every later total.
-*
-* The box occasionally reports 0 or a stale lower figure for one poll (a restart, a partly
-* written window). One such reading is held back: the previous value is published instead.
-* A lower reading that is then followed by a value at or above it is a genuine reset or a
-* replaced meter, and is accepted.
-*/
-var LifetimeCounterGuard = class {
-	#published = null;
-	#suspect = null;
-	/** The value to publish for the reading `next`. */
-	accept(next) {
-		const published = this.#published;
-		if (published === null || next >= published - NOISE) {
-			this.#published = next;
-			this.#suspect = null;
-			return next;
-		}
-		const suspect = this.#suspect;
-		if (suspect !== null && next >= suspect - NOISE) {
-			this.#published = next;
-			this.#suspect = null;
-			return next;
-		}
-		this.#suspect = next;
-		return published;
-	}
-};
-//#endregion
-//#region src/devices/enpal-sensor-device.ts
-var POWER_CAP = powerMeterCapability.name;
-var BATTERY_CAP = batteryCapability.name;
-var METER_CAP = meterCapability.name;
-var NUMERIC_CAP = numericSensorCapability.name;
-var POWER_COLD = { lastFetchedAt: 0 };
-var BATTERY_COLD = {
-	percentage: null,
-	charging: "unknown",
-	sleeping: false,
-	lastUpdated: 0
-};
-var VALUE_COLD = {
-	value: null,
-	lastFetchedAt: 0
-};
-/**
-* One Enpal data group (PV, battery, grid import, ...) as a {@link DeviceType.Sensor}
-* child of the box. The catalog entry in `specId` says which caps it registers and which
-* box keys feed them; the slices are recomputed from the box snapshot on every poll tick.
-*
-* An unreachable box marks the device offline and leaves the slices alone: a failed read is
-* a gap, never a zero (D393). A lifetime counter passes through {@link LifetimeCounterGuard}
-* so one stale low reading cannot become a history reset.
-*/
-var EnpalSensorDevice = class extends BaseDevice {
-	features = [];
-	spec;
-	boxId;
-	energyGuard = new LifetimeCounterGuard();
-	meterGuard = new LifetimeCounterGuard();
-	snapshotUnsub = null;
-	constructor(ctx) {
-		const cfg = enpalSensorSchema.parse(ctx.persistedConfig ?? {});
-		super(ctx, enpalSensorSchema, { type: ctx.deviceMeta.type });
-		const spec = findSpec(cfg.specId);
-		if (spec === void 0) throw new Error(`Enpal: unknown device kind "${cfg.specId}"`);
-		this.spec = spec;
-		this.boxId = cfg.boxId;
-		this.online = enpalBoxes.getSnapshot(this.boxId) !== null;
-		this.updateSourceInfo({
-			id: `${this.boxId}:${spec.id}`,
-			system: "enpal",
-			...spec.kind === "meter" || spec.kind === "numeric" ? { quantity: spec.quantity } : {}
-		});
-	}
-	async onActivate() {
-		await super.onActivate();
-		this.registerCaps();
-		this.snapshotUnsub = enpalBoxes.onSnapshot(this.boxId, () => {
-			try {
-				this.recompute();
-			} catch (err) {
-				this.ctx.logger.warn("enpal sensor: snapshot handler failed", {
-					tags: { deviceId: this.id },
-					meta: {
-						spec: this.spec.id,
-						error: errMsg(err)
-					}
-				});
-			}
-		});
-		this.recompute();
-	}
-	async removeDevice() {
-		this.snapshotUnsub?.();
-		this.snapshotUnsub = null;
-		await super.removeDevice();
-	}
-	recompute() {
-		const snapshot = enpalBoxes.getSnapshot(this.boxId);
-		if (snapshot === null) {
-			if (this.online) this.markOnline(false);
-			return;
-		}
-		if (!this.online) this.markOnline(true);
-		const invert = enpalBoxes.getManager(this.boxId)?.connection.invertBatteryPower ?? false;
-		const slices = computeSlices(this.spec, snapshot, { invertBatteryPower: invert }, snapshot.fetchedAt);
-		this.publish(slices);
-		for (const line of slices.refusals) this.ctx.logger.warn(`enpal sensor: reading not used, ${line}`, {
-			tags: { deviceId: this.id },
-			meta: { spec: this.spec.id }
-		});
-	}
-	publish(slices) {
-		if (slices.powerMeter !== void 0) {
-			const kwh = slices.powerMeter.kwhTotal;
-			this.runtimeState.setCapState(POWER_CAP, kwh === void 0 ? slices.powerMeter : {
-				...slices.powerMeter,
-				kwhTotal: this.energyGuard.accept(kwh)
-			});
-		}
-		if (slices.battery !== void 0) this.runtimeState.setCapState(BATTERY_CAP, slices.battery);
-		if (slices.meter !== void 0) {
-			const raw = slices.meter.value;
-			this.runtimeState.setCapState(METER_CAP, {
-				...slices.meter,
-				value: raw === null ? null : this.meterGuard.accept(raw)
+//#region src/enpal-integration-device-cascade.ts
+/**
+* Remove every equipment Container of an integration that was deleted or disabled; the
+* kernel takes the Sensor children with it. Best-effort per device; returns the count removed.
+*/
+async function cascadeRemoveDevicesForIntegration(input) {
+	const { reg, devices, addonId, integrationId, logger } = input;
+	let removed = 0;
+	for (const d of reg.getAllForAddon(addonId)) {
+		if (d.parentDeviceId !== null) continue;
+		const cfg = await devices.loadConfig(d.id).catch(() => ({}));
+		if (cfg["system"] !== "enpal" || cfg["integrationId"] !== integrationId) continue;
+		try {
+			await devices.remove(d.id);
+			removed += 1;
+		} catch (err) {
+			logger.warn("enpal: integration cascade-remove failed", {
+				tags: { deviceId: d.id },
+				meta: {
+					integrationId,
+					error: errMsg(err)
+				}
 			});
 		}
-		if (slices.numeric !== void 0) this.runtimeState.setCapState(NUMERIC_CAP, slices.numeric);
-	}
-	registerCaps() {
-		switch (this.spec.kind) {
-			case "power-meter":
-				this.registerPowerMeter();
-				return;
-			case "battery":
-				this.registerBattery();
-				this.registerPowerMeter();
-				return;
-			case "meter":
-				this.ctx.registerNativeCap(meterCapability, { getStatus: async () => this.runtimeState.getCapState(METER_CAP) ?? VALUE_COLD });
-				this.runtimeState.setCapState(METER_CAP, VALUE_COLD);
-				return;
-			case "numeric":
-				this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState(NUMERIC_CAP) ?? VALUE_COLD });
-				this.runtimeState.setCapState(NUMERIC_CAP, VALUE_COLD);
-				return;
-		}
 	}
-	registerPowerMeter() {
-		this.ctx.registerNativeCap(powerMeterCapability, { getStatus: async () => this.runtimeState.getCapState(POWER_CAP) ?? POWER_COLD });
-		this.runtimeState.setCapState(POWER_CAP, POWER_COLD);
-	}
-	registerBattery() {
-		this.ctx.registerNativeCap(batteryCapability, {
-			getStatus: async () => this.runtimeState.getCapState(BATTERY_CAP) ?? BATTERY_COLD,
-			wakeForStream: async () => ({
-				awoke: false,
-				durationMs: 0
-			})
-		});
-		this.runtimeState.setCapState(BATTERY_CAP, BATTERY_COLD);
+	return removed;
+}
+//#endregion
+//#region src/enpal-integration-offline.ts
+/**
+* Set every Enpal device of `integrationId` (containers and their sensors) to `online`.
+* Churn-free: a device already in that state is left alone. Returns how many changed.
+*/
+function setIntegrationDevicesOnline(devices, integrationId, online) {
+	let count = 0;
+	for (const dev of devices) {
+		if (dev.config.get("system") !== "enpal") continue;
+		if (dev.config.get("integrationId") !== integrationId) continue;
+		if (dev.online === online) continue;
+		dev.markOnline(online);
+		count += 1;
 	}
-};
+	return count;
+}
 //#endregion
-//#region src/devices/enpal-box-device.ts
+//#region src/addon.ts
 /**
-* One Enpal box, a {@link DeviceType.Hub} device. The connection (host, InfluxDB access,
-* token) lives on this device's config; it owns the poller, publishes it on
-* {@link enpalBoxes} and registers `device-discovery` so the operator adopts the data groups
-* the box actually reports (PV, battery, grid, house, heat pump) as Sensor children.
+* 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`. The box is not a device: discovery offers one
+* {@link DeviceType.Container} per piece of equipment it reports (photovoltaic, battery,
+* grid, house, heat pump), and adopting a container adopts its Sensor children.
+*
+* The box does not advertise itself on the network, so the integration is added by hand.
 */
-var EnpalBoxDevice = class extends BaseDevice {
-	features = [];
-	manager = null;
-	eventUnsubscribers = [];
-	constructor(ctx) {
-		enpalBoxSchema.parse(ctx.persistedConfig ?? {});
-		super(ctx, enpalBoxSchema, { type: DeviceType.Hub });
-		this.online = false;
-		this.registerDeviceDiscovery();
-		this.updateSourceInfo({
-			id: this.stableId,
-			system: "enpal"
-		});
+var EnpalProviderAddon = class extends BaseDeviceProvider {
+	addonId = "provider-enpal";
+	providerName = "Enpal";
+	deviceClasses = { [DeviceType.Container]: EnpalEquipmentDevice };
+	clients = null;
+	constructor() {
+		super({});
 	}
-	async onActivate() {
-		await super.onActivate();
-		this.ensureManager().catch((err) => {
-			this.ctx.logger.warn("Enpal box: start failed", {
-				tags: { deviceId: this.id },
-				meta: { error: errMsg(err) }
-			});
+	async onInitialize() {
+		const regs = this.providerRegistrationsFromSuper(await super.onInitialize());
+		this.clients = new EnpalClientRegistry(this.ctx.logger, {
+			onConnected: (integrationId) => this.setIntegrationDevicesOnline(integrationId, true),
+			onDisconnected: (integrationId) => this.setIntegrationDevicesOnline(integrationId, false)
 		});
-		this.eventUnsubscribers.push(this.ctx.eventBus.subscribe({ category: EventCategory.DeviceUnregistered }, (event) => {
-			if (event.data.parentDeviceId !== this.id) return;
-			this.refreshDiscovery().catch(() => void 0);
-		}));
+		await this.reconcileIntegrations();
+		this.subscribeIntegrationLifecycle();
+		return [...regs, {
+			capability: deviceAdoptionCapability,
+			provider: this.buildAdoptionProvider()
+		}];
 	}
-	async removeDevice() {
-		for (const unsub of this.eventUnsubscribers) unsub();
-		this.eventUnsubscribers.length = 0;
-		await this.stopManager();
-		await super.removeDevice();
+	async onShutdown() {
+		try {
+			await this.clients?.shutdown();
+		} catch (err) {
+			this.ctx.logger.warn("Enpal shutdown error", { meta: { error: errMsg(err) } });
+		}
+		this.clients = null;
+		enpalConnections.clear();
+		await super.onShutdown();
 	}
-	async applySettingsPatch(patch) {
-		if (!("connection" in patch)) return;
-		const parsed = enpalBoxSchema.parse({
-			connection: patch["connection"],
-			system: "enpal-box"
-		});
-		await this.config.setAll({ connection: parsed.connection });
-		await this.stopManager();
-		await this.ensureManager();
+	requireClients() {
+		if (!this.clients) throw new Error("Enpal provider not initialised");
+		return this.clients;
 	}
-	async stopManager() {
-		const mgr = this.manager;
-		this.manager = null;
-		enpalBoxes.set(this.stableId, null);
-		if (mgr !== null) await mgr.stop();
+	/** One container per equipment per integration. */
+	generateStableId(_type, config) {
+		const integrationId = config?.["integrationId"];
+		const equipment = config?.["equipment"];
+		if (typeof integrationId !== "string" || integrationId.length === 0) throw new Error("enpal generateStableId: integrationId required");
+		if (typeof equipment !== "string" || equipment.length === 0) throw new Error("enpal generateStableId: equipment required");
+		return `enpal:${integrationId}:${equipment}`;
 	}
-	async ensureManager() {
-		if (this.manager !== null) return;
-		const { connection, tokenLocked } = readConnection(this.config.values.connection);
-		const mgr = new EnpalIntegrationManager({
-			id: this.stableId,
-			name: this.name,
-			connection,
-			tokenLocked,
-			logger: this.ctx.logger.withTags({ deviceId: this.id }),
-			onConnected: () => this.setOnline(true),
-			onDisconnected: () => {
-				this.setOnline(false);
-				enpalBoxes.emitSnapshot(this.stableId);
-			},
-			onPolled: () => {
-				this.refreshDiscovery().catch(() => void 0);
-				enpalBoxes.emitSnapshot(this.stableId);
+	/**
+	* Rebuild the pollers from the live integration list: upsert one per enabled integration
+	* with a host, drop the ones that vanished and cascade-remove their devices. Idempotent;
+	* runs at boot and on every integration lifecycle event.
+	*/
+	async reconcileIntegrations() {
+		const reg = this.requireClients();
+		try {
+			const mine = (await this.ctx.api.integrations.list.query()).filter((i) => i.addonId === this.ctx.id && i.enabled);
+			const surviving = /* @__PURE__ */ new Set();
+			for (const integration of mine) try {
+				const read = connectionFromSettings(await this.ctx.api.integrations.getSettings.query({ id: integration.id }));
+				if (read === null) {
+					this.ctx.logger.warn("Enpal integration has no box host — skipping", { meta: { integrationId: integration.id } });
+					continue;
+				}
+				await reg.upsert(integration.id, integration.name, read.connection, read.tokenLocked);
+				surviving.add(integration.id);
+			} catch (err) {
+				this.ctx.logger.warn("Enpal reconcile failed for integration", { meta: {
+					integrationId: integration.id,
+					error: errMsg(err)
+				} });
 			}
-		});
-		this.manager = mgr;
-		enpalBoxes.set(this.stableId, mgr);
-		await mgr.start();
-		if (mgr.status === "error") {
-			this.setOnline(false);
-			enpalBoxes.emitSnapshot(this.stableId);
+			const vanished = reg.list().filter((id) => !surviving.has(id));
+			await reg.retain(surviving);
+			for (const integrationId of vanished) await this.cascadeRemoveDevicesForIntegration(integrationId);
+		} catch (err) {
+			this.ctx.logger.warn("Enpal integration reconcile failed", { meta: { error: errMsg(err) } });
 		}
 	}
-	setOnline(online) {
-		if (this.online === online) return;
-		this.markOnline(online);
-		this.ctx.logger.info("Enpal box " + (online ? "online" : "offline"), { tags: { deviceId: this.id } });
+	subscribeIntegrationLifecycle() {
+		const handler = (event) => {
+			const addonId = event.data["addonId"];
+			if (typeof addonId === "string" && addonId !== this.ctx.id) return;
+			this.reconcileIntegrations();
+		};
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationEnabled }, handler);
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDisabled }, handler);
+		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDeleted }, handler);
 	}
-	registerDeviceDiscovery() {
-		this.ctx.registerNativeCap(deviceDiscoveryCapability, {
-			getStatus: async ({ deviceId }) => {
-				if (deviceId !== this.id) return null;
-				return this.runtimeState.getCapState("device-discovery") ?? null;
+	async cascadeRemoveDevicesForIntegration(integrationId) {
+		const reg = this.ctx.kernel.deviceRegistry;
+		const devices = this.ctx.kernel.devices;
+		if (!reg || !devices) return;
+		await cascadeRemoveDevicesForIntegration({
+			reg,
+			devices,
+			addonId: this.addonId,
+			integrationId,
+			logger: this.ctx.logger
+		});
+	}
+	buildAdoptionProvider() {
+		return buildEnpalAdoptionProvider({
+			getSnapshot: (integrationId) => enpalConnections.getSnapshot(integrationId),
+			hasIntegration: (integrationId) => this.requireClients().has(integrationId),
+			listIntegrations: () => this.requireClients().list(),
+			listAdopted: async () => {
+				const reg = this.ctx.kernel.deviceRegistry;
+				const devices = this.ctx.kernel.devices;
+				if (!reg || !devices) return [];
+				const out = [];
+				for (const d of reg.getAllForAddon(this.addonId)) {
+					if (d.parentDeviceId !== null) continue;
+					const config = await devices.loadConfig(d.id).catch(() => ({}));
+					out.push({
+						id: d.id,
+						config
+					});
+				}
+				return out;
 			},
-			listDiscovered: async ({ deviceId }) => {
-				if (deviceId !== this.id) return [];
-				return this.runtimeState.getCapState("device-discovery")?.discovered ?? [];
+			adoptDevice: async ({ equipment, specIds, integrationId, name }) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) throw new Error("enpal adopt: kernel.devices unavailable");
+				const config = {
+					equipment,
+					specIds,
+					integrationId,
+					system: ENPAL_SYSTEM
+				};
+				const stableId = this.generateStableId(DeviceType.Container, config);
+				const device = await devices.create(stableId, EnpalEquipmentDevice, config, null, {
+					type: DeviceType.Container,
+					name,
+					integrationId
+				});
+				const children = await devices.getChildren(device.id);
+				return {
+					deviceId: device.id,
+					accessoryDeviceIds: children.map((c) => c.id)
+				};
 			},
-			refreshDiscovery: async ({ deviceId }) => {
-				if (deviceId !== this.id) return [];
-				await this.refreshDiscovery();
-				return this.runtimeState.getCapState("device-discovery")?.discovered ?? [];
+			removeDevice: async (id) => {
+				await this.ctx.kernel.devices?.remove(id);
 			},
-			adoptDevice: async ({ deviceId, childNativeId, name }) => {
-				if (deviceId !== this.id) throw new Error(`adoptDevice: deviceId mismatch — got ${deviceId}, expected ${this.id}`);
-				return this.adopt(childNativeId, name);
+			findDeviceConfig: async (id) => {
+				const devices = this.ctx.kernel.devices;
+				if (!devices) return null;
+				return devices.loadConfig(id).catch(() => null);
 			},
-			releaseDevice: async ({ deviceId, childDeviceId }) => {
-				if (deviceId !== this.id) return;
-				await this.release(childDeviceId);
-			}
-		});
-		this.setCapSlice(deviceDiscoveryCapability, {
-			discovered: [],
-			lastDiscoveryAt: null,
-			lastError: null,
-			lastFetchedAt: 0
+			logger: this.ctx.logger
 		});
 	}
-	async refreshDiscovery() {
-		const snapshot = enpalBoxes.getSnapshot(this.stableId);
-		let lastError = null;
-		let discovered = [];
-		if (snapshot === null) lastError = enpalBoxes.getManager(this.stableId)?.lastError?.message ?? null;
-		else try {
-			discovered = buildCandidates({
-				boxId: this.stableId,
-				boxName: this.name,
-				specs: availableSpecs(snapshot),
-				adoptedDeviceIdBySpec: await this.adoptedBySpec(),
-				online: true
-			});
-		} catch (err) {
-			lastError = errMsg(err);
-			this.ctx.logger.warn("Enpal box: discovery refresh failed", {
-				tags: { deviceId: this.id },
-				meta: { error: lastError }
-			});
-		}
-		this.runtimeState.setCapState(deviceDiscoveryCapability.name, {
-			discovered,
-			lastDiscoveryAt: Date.now(),
-			lastError,
-			lastFetchedAt: Date.now()
-		});
-	}
-	async adoptedBySpec() {
-		const out = {};
-		const children = await this.ctx.devices.getChildren(this.id).catch(() => []);
-		for (const child of children) {
-			const specId = (await this.ctx.devices.loadConfig(child.id).catch(() => ({})))["specId"];
-			if (typeof specId === "string") out[specId] = child.id;
-		}
-		return out;
-	}
-	async adopt(childNativeId, nameOverride) {
-		const specId = parseSpecNativeId(this.stableId, childNativeId);
-		const spec = specId === null ? void 0 : findSpec(specId);
-		if (spec === void 0) throw new Error(`adoptDevice: ${childNativeId} is not an Enpal device of this box`);
-		const existingId = (await this.adoptedBySpec())[spec.id];
-		if (typeof existingId === "number") {
-			const existing = (await this.ctx.devices.getAll()).find((d) => d.id === existingId);
-			if (existing) return {
-				deviceId: existing.id,
-				stableId: existing.stableId
-			};
-		}
-		const name = nameOverride ?? `${this.name} ${spec.name}`;
-		const stableId = specNativeId(this.stableId, spec.id);
-		const created = await this.ctx.devices.create(stableId, EnpalSensorDevice, {
-			specId: spec.id,
-			boxId: this.stableId,
-			system: "enpal",
-			name
-		}, this.id, {
-			type: DeviceType.Sensor,
-			name,
-			role: spec.role
-		});
-		this.ctx.logger.info("Enpal box: adopted device", {
-			tags: { deviceId: created.id },
-			meta: {
-				spec: spec.id,
-				stableId
-			}
-		});
-		await this.refreshDiscovery().catch(() => void 0);
-		return {
-			deviceId: created.id,
-			stableId
-		};
-	}
-	async release(childDeviceId) {
-		const child = (await this.ctx.devices.getAll()).find((d) => d.id === childDeviceId);
-		if (!child || child.parentDeviceId !== this.id) throw new Error(`releaseDevice: ${childDeviceId} is not a child of box ${this.id}`);
-		await this.ctx.devices.remove(childDeviceId);
-		await this.refreshDiscovery().catch(() => void 0);
-	}
-};
-//#endregion
-//#region src/addon.ts
-/**
-* Enpal solar box provider, `mode: standalone` (the VeSync / Ecowitt pattern, no broker).
-* A box is added as a {@link DeviceType.Hub} through the manual-creation form: its host,
-* InfluxDB access and token live on the device. The box registers `device-discovery` and
-* adopts the data groups it reports as Sensor devices. The box does not advertise itself on
-* the network, so there is no auto-discovery of the box itself.
-*/
-var EnpalProviderAddon = class extends BaseDeviceProvider {
-	addonId = "provider-enpal";
-	providerName = "Enpal";
-	deviceClasses = {
-		[DeviceType.Hub]: EnpalBoxDevice,
-		[DeviceType.Sensor]: EnpalSensorDevice
-	};
-	constructor() {
-		super({});
-	}
-	async supportsDiscovery() {
-		return false;
+	/** The integration's settings form; the submitted values are stored per integration. */
+	globalSettingsSchema() {
+		return buildConnectionFormSchema();
 	}
 	async supportsManualCreation() {
-		return true;
+		return false;
 	}
-	async onGetCreationSchema(type) {
-		return type === DeviceType.Hub ? buildConnectionFormSchema() : null;
+	async onGetCreationSchema(_type) {
+		return null;
 	}
-	async onCreateDevice(type, config) {
-		if (type !== DeviceType.Hub) throw new Error(`Enpal provider does not support device type: ${type}`);
-		const name = typeof config["name"] === "string" ? config["name"].trim() : "";
-		if (name.length === 0) throw userError("enpal.name-required", void 0, "Box name is required");
-		const parsed = enpalConnectionSchema.safeParse(config["connection"] ?? config);
-		if (!parsed.success || parsed.data.host.length === 0) throw userError("enpal.host-required", void 0, "The box host or IP is required");
-		return {
-			meta: {
-				type: DeviceType.Hub,
-				name
-			},
-			config: {
-				connection: parsed.data,
-				system: "enpal-box"
-			}
-		};
+	async onCreateDevice(_type, _config) {
+		throw new Error("Enpal devices are adopted from the integration");
 	}
-	/** One row per box host: re-adding the same box reuses its persisted row. */
-	generateStableId(_type, config) {
-		const host = readConnection(config?.["connection"] ?? config).connection.host;
-		if (host.length > 0) return `enpal:${slugifyHost(host)}`;
-		throw new Error("Enpal: box resolved no host — cannot persist a stable row key.");
+	setIntegrationDevicesOnline(integrationId, online) {
+		const reg = this.ctx.kernel.deviceRegistry;
+		if (!reg) return;
+		const n = setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), integrationId, online);
+		if (n > 0) this.ctx.logger.info("Enpal integration devices " + (online ? "online" : "offline"), { meta: {
+			integrationId,
+			count: n
+		} });
 	}
 };
 //#endregion
+exports.ENPAL_EQUIPMENT = ENPAL_EQUIPMENT;
 exports.ENPAL_SPECS = ENPAL_SPECS;
-exports.EnpalBoxDevice = EnpalBoxDevice;
-exports.EnpalBoxResolver = EnpalBoxResolver;
+exports.ENPAL_SYSTEM = ENPAL_SYSTEM;
+exports.EnpalClientRegistry = EnpalClientRegistry;
+exports.EnpalConnectionResolver = EnpalConnectionResolver;
+exports.EnpalEquipmentDevice = EnpalEquipmentDevice;
 exports.EnpalError = EnpalError;
 exports.EnpalIntegrationManager = EnpalIntegrationManager;
 exports.EnpalProviderAddon = EnpalProviderAddon;
 exports.EnpalSensorDevice = EnpalSensorDevice;
 exports.LifetimeCounterGuard = LifetimeCounterGuard;
+exports.accessoryChildSpecs = accessoryChildSpecs;
 exports.availableSpecs = availableSpecs;
-exports.buildCandidates = buildCandidates;
 exports.buildConnectionFormSchema = buildConnectionFormSchema;
+exports.buildEnpalAdoptionProvider = buildEnpalAdoptionProvider;
+exports.buildEnpalCandidates = buildEnpalCandidates;
 exports.capsOfSpec = capsOfSpec;
 exports.computeSlices = computeSlices;
-exports.enpalBoxSchema = enpalBoxSchema;
-exports.enpalBoxes = enpalBoxes;
+exports.connectionFromSettings = connectionFromSettings;
 exports.enpalConnectionSchema = enpalConnectionSchema;
+exports.enpalConnections = enpalConnections;
+exports.enpalEquipmentSchema = enpalEquipmentSchema;
 exports.enpalSensorSchema = enpalSensorSchema;
+exports.findEquipment = findEquipment;
 exports.findSpec = findSpec;
-exports.parseSpecNativeId = parseSpecNativeId;
 exports.readConnection = readConnection;
 exports.readEnpalSnapshot = readEnpalSnapshot;
+exports.sameConnection = sameConnection;
 exports.settingsToConnection = settingsToConnection;
-exports.slugifyHost = slugifyHost;
-exports.specNativeId = specNativeId;