@camstack/addon-provider-enpal 0.1.1 → 0.1.2

package/dist/addon.mjs

@@ -10469,20 +10469,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) {
@@ -21032,19 +21018,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,
@@ -64360,9 +64363,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. */
@@ -64370,17 +64373,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,
@@ -64437,7 +64497,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
@@ -70208,7 +70269,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);
@@ -89642,9 +89703,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`).
@@ -89665,6 +89726,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([
@@ -89674,7 +89739,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)"),
@@ -89697,30 +89762,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: [
 		{
@@ -89729,13 +89785,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",
@@ -89890,7 +89939,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")
@@ -89909,7 +89958,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")
@@ -89917,7 +89966,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")
@@ -89925,7 +89974,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",
@@ -89942,7 +89991,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",
@@ -89959,7 +90008,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")
@@ -89967,7 +90016,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")
@@ -89975,7 +90024,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")
@@ -89983,7 +90032,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")
@@ -89999,7 +90048,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "battery-temperature",
-		name: "Battery temperature",
+		name: "Temperature",
 		role: DeviceRole.TemperatureSensor,
 		quantity: "temperature",
 		value: point("temperature", "Temperature.Battery")
@@ -90007,7 +90056,7 @@ var ENPAL_SPECS = [
 	{
 		kind: "numeric",
 		id: "battery-health",
-		name: "Battery health",
+		name: "Health",
 		role: DeviceRole.NumericSensor,
 		quantity: "percentage",
 		value: point("percentage", "Battery.SOH")
@@ -90164,36 +90213,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
@@ -90549,482 +91090,309 @@ 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
-export { slugifyHost as C, EnpalProviderAddon, settingsToConnection as S, buildConnectionFormSchema as _, enpalBoxes as a, enpalSensorSchema as b, readEnpalSnapshot as c, specNativeId as d, ENPAL_SPECS as f, findSpec as g, computeSlices as h, EnpalBoxResolver as i, buildCandidates as l, capsOfSpec as m, EnpalSensorDevice as n, EnpalIntegrationManager as o, availableSpecs as p, LifetimeCounterGuard as r, EnpalError as s, EnpalBoxDevice as t, parseSpecNativeId as u, enpalBoxSchema as v, readConnection as x, enpalConnectionSchema as y };
+export { buildConnectionFormSchema as C, sameConnection as D, readConnection as E, EnpalProviderAddon, settingsToConnection as O, ENPAL_SYSTEM as S, enpalConnectionSchema as T, ENPAL_SPECS as _, buildEnpalAdoptionProvider as a, computeSlices as b, ENPAL_EQUIPMENT as c, findEquipment as d, EnpalSensorDevice as f, LifetimeCounterGuard as g, enpalConnections as h, readEnpalSnapshot as i, accessoryChildSpecs as l, EnpalConnectionResolver as m, EnpalIntegrationManager as n, buildEnpalCandidates as o, enpalSensorSchema as p, EnpalError as r, EnpalEquipmentDevice as s, EnpalClientRegistry as t, enpalEquipmentSchema as u, availableSpecs as v, connectionFromSettings as w, findSpec as x, capsOfSpec as y };