@camstack/addon-provider-dreame 0.1.14 → 0.1.16

package/dist/addon.js

@@ -4680,7 +4680,7 @@ function preprocess(fn, schema) {
 	});
 }
 //#endregion
-//#region ../types/dist/sleep-B3AOslwX.mjs
+//#region ../types/dist/sleep-C2M2zF7x.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -6248,6 +6248,12 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Switch"] = "switch";
 	DeviceType["Sensor"] = "sensor";
 	DeviceType["Thermostat"] = "thermostat";
+	/** Air-conditioner / heat-pump climate device (HVAC) — shares the
+	*  `climate-control` cap surface with `Thermostat` but renders a
+	*  dedicated AC-appropriate control UI (mode chips, fan speed,
+	*  independent vertical/horizontal swing). Sources: native Gree, and
+	*  reusable by other AC integrations. */
+	DeviceType["Climate"] = "climate";
 	DeviceType["Button"] = "button";
 	/** Generic stateless event emitter — carries a device's EXACT declared
 	*  event vocabulary verbatim (no normalization). Installed with the
@@ -9043,7 +9049,7 @@ var climateControlCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Thermostat],
+	deviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
 	methods: {
 		setMode: method(object({
 			deviceId: number().int().nonnegative(),
@@ -13642,10 +13648,30 @@ var deviceProviderCapability = {
 			type: string()
 		}))),
 		supportsDiscovery: method(object({}), boolean()),
-		discoverDevices: method(object({}), array(DiscoveryCandidateSchema), {
+		/**
+		* Run a network scan. `params` carries optional provider-specific scan
+		* inputs (e.g. a broadcast address / subnet for cross-subnet discovery),
+		* shaped by `getDiscoveryParamsSchema`. Omitted for the generic scan
+		* (provider uses its local-network default).
+		*/
+		discoverDevices: method(object({ params: record(string(), unknown()).optional() }), array(DiscoveryCandidateSchema), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Optional form schema (`ConfigUISchema`) for the EXTRA per-scan inputs a
+		* provider accepts (e.g. Gree's broadcast address for a different subnet).
+		* `null` when the provider takes no extra scan params — the generic
+		* aggregated scan never renders this; the per-integration scan does.
+		*/
+		getDiscoveryParamsSchema: method(object({}), CreationSchemaOutputSchema),
+		/**
+		* The DeviceType this provider creates via manual add (Camera for
+		* Reolink/ONVIF, Container for Gree, Hub for Ecowitt). `null` when the
+		* provider does not support manual creation. Lets the Add-Device dialog
+		* pick the right type instead of assuming Camera.
+		*/
+		getManualCreationType: method(object({}), object({ deviceType: _enum(DeviceType).nullable() })),
 		adoptDiscoveredDevice: method(object({ candidate: DiscoveryCandidateSchema }), DeviceSummarySchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -13769,9 +13795,23 @@ var BaseDeviceProvider = class extends BaseAddon {
 	async supportsDiscovery() {
 		return false;
 	}
-	async discoverDevices() {
+	async discoverDevices(_input) {
 		return [];
 	}
+	/** Extra per-scan input form (e.g. a broadcast address for another subnet).
+	*  Null = no extra params. Override in providers that support scoped scans. */
+	async getDiscoveryParamsSchema() {
+		return null;
+	}
+	/**
+	* The DeviceType this provider creates via manual add — derived from the
+	* `deviceClasses` map (first registered type). `null` when manual creation is
+	* unsupported. Lets the Add-Device dialog pick the right type per provider.
+	*/
+	async getManualCreationType() {
+		if (!await this.supportsManualCreation()) return { deviceType: null };
+		return { deviceType: Object.values(DeviceType).find((t) => this.deviceClasses[t] !== void 0) ?? null };
+	}
 	async adoptDiscoveredDevice(_input) {
 		throw new Error(`${this.providerName} provider does not support discovery-based adoption`);
 	}
@@ -14818,83 +14858,34 @@ var GetStateInputSchema = object({
 	*  HA:   entity_id (returns the cached entity state). */
 	key: string()
 });
-var brokerCapability = {
-	name: "broker",
-	scope: "system",
-	mode: "collection",
-	providerKind: "broker",
-	status: {
-		schema: RegistryStatusSchema,
-		kind: "poll"
-	},
-	methods: {
-		list: method(ListInputSchema, array(BrokerInfoSchema$1)),
-		get: method(GetInputSchema, BrokerInfoSchema$1.nullable()),
-		/** Enumerate which addon provides which broker kind(s) for the
-		*  unified create picker. The auto-mount fans this array across
-		*  every registered `broker` provider (array-output method), so the
-		*  picker sees every kind from every provider in one call. */
-		listProviders: method(_void(), array(BrokerProviderInfoSchema), { auth: "admin" }),
-		add: method(AddInputSchema, AddResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		remove: method(RemoveInputSchema, _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		testConnection: method(GetInputSchema, TestConnectionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Read the persisted settings record for a broker (kind-specific
-		*  shape). Admin-only — settings may contain secrets. Returns `null`
-		*  when the broker id is unknown to the provider (the collection
-		*  fallback may route a foreign id to the first provider). */
-		getSettings: method(GetInputSchema, SettingsRecordSchema$1.nullable(), { auth: "admin" }),
-		/** Overwrite the persisted settings record. The kind-specific
-		*  provider validates the shape and applies the change (reconnects
-		*  if credentials changed). */
-		setSettings: method(object({
-			id: string(),
-			settings: SettingsRecordSchema$1
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Returns the kind-specific connection config the consumer needs
-		*  to open its own client (MQTT pattern: `{url, username, password,
-		*  clientIdPrefix}`). HA providers MAY return the auth envelope
-		*  but typical HA consumers use `publish` / `subscribe` instead.
-		*  Returns `null` when the broker id is unknown to the provider. */
-		getBrokerConfig: method(GetInputSchema, SettingsRecordSchema$1.nullable(), { auth: "admin" }),
-		getSettingsSchema: method(SettingsSchemaInputSchema, SettingsSchemaResultSchema, { auth: "admin" }),
-		testSettings: method(TestSettingsInputSchema, TestSettingsResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		publish: method(PublishInputSchema, unknown(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		subscribe: method(SubscribeInputSchema, SubscribeResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		unsubscribe: method(UnsubscribeInputSchema, _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Read the broker's cached state for a key. Returns `null` when
-		*  unknown to the broker (never published / unknown entity). */
-		getState: method(GetStateInputSchema, unknown().nullable()),
-		/** Status method — explicit registration with a `z.void()` input so
-		*  the codegen-generated tRPC router types its input as
-		*  `{addonId?: string, nodeId?: string}` (system-scoped collection
-		*  shape) instead of the device-scoped `{deviceId}` fallback. */
-		getStatus: method(_void(), RegistryStatusSchema)
-	}
-};
+method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, BrokerInfoSchema$1.nullable()), method(_void(), array(BrokerProviderInfoSchema), { auth: "admin" }), method(AddInputSchema, AddResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(RemoveInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(GetInputSchema, TestConnectionResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(GetInputSchema, SettingsRecordSchema$1.nullable(), { auth: "admin" }), method(object({
+	id: string(),
+	settings: SettingsRecordSchema$1
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(GetInputSchema, SettingsRecordSchema$1.nullable(), { auth: "admin" }), method(SettingsSchemaInputSchema, SettingsSchemaResultSchema, { auth: "admin" }), method(TestSettingsInputSchema, TestSettingsResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(PublishInputSchema, unknown(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(SubscribeInputSchema, SubscribeResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(UnsubscribeInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
 DeviceType.Camera;
 /**
 * `custom-model-registry` — collection cap exposing operator-registered
@@ -15682,7 +15673,10 @@ method(object({
 }), FieldProbeResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(ListCandidatesInputSchema.extend({ addonId: string() }), ListCandidatesOutputSchema, { auth: "admin" }), method(object({
+}), method(object({
+	addonId: string(),
+	integrationId: string()
+}), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }), method(ListCandidatesInputSchema.extend({ addonId: string() }), ListCandidatesOutputSchema, { auth: "admin" }), method(object({
 	addonId: string(),
 	integrationId: string()
 }), AdoptionStatusSchema, {
@@ -15697,7 +15691,24 @@ method(object({
 }), method(ResyncInputSchema, ResyncResultSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({}), object({ providers: array(object({
+	addonId: string(),
+	label: string()
+})).readonly() }), { auth: "admin" }), method(object({}), object({ groups: array(object({
+	addonId: string(),
+	label: string(),
+	candidates: array(DiscoveryCandidateSchema).readonly(),
+	error: string().nullable()
+})).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
+	addonId: string(),
+	params: record(string(), unknown()).optional()
+}), object({ candidates: array(DiscoveryCandidateSchema).readonly() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ addonId: string() }), object({ deviceType: _enum(DeviceType).nullable() }), { auth: "admin" }), method(object({ addonId: string() }), unknown(), { auth: "admin" }), method(object({
 	deviceId: number(),
 	key: string(),
 	value: unknown()
@@ -18366,6 +18377,17 @@ var AvailableIntegrationTypeSchema = object({
 	iconUrl: string().nullable(),
 	color: string(),
 	instanceMode: string(),
+	/**
+	* Integration wizard `mode` (LOCKED MODEL): `standalone` (create
+	* immediately then add devices, no config step/button), `account` (config
+	* step), or `broker` (broker step). Derived server-side by
+	* `getAvailableTypes` when the addon manifest omits an explicit `mode`.
+	*/
+	mode: _enum([
+		"standalone",
+		"account",
+		"broker"
+	]),
 	discoveryMode: string(),
 	/**
 	* Which integration-marker cap the addon declared, so the wizard can
@@ -20826,6 +20848,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionListCandidateFilters": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.adoptionListCandidates": {
 		capName: "device-manager",
 		capScope: "system",
@@ -20874,12 +20902,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.discoverAllProviders": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.discoverDevices": {
 		capName: "device-manager",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.discoverProvider": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceManager.discoveryProviders": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.enable": {
 		capName: "device-manager",
 		capScope: "system",
@@ -21030,6 +21076,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.providerCreationType": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceManager.providerDiscoveryParamsSchema": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.registerDevice": {
 		capName: "device-manager",
 		capScope: "system",
@@ -21246,6 +21304,18 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceProvider.getDiscoveryParamsSchema": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceProvider.getManualCreationType": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceProvider.getStatus": {
 		capName: "device-provider",
 		capScope: "system",
@@ -24084,6 +24154,124 @@ object({
 	schemaVersion: literal(1)
 });
 //#endregion
+//#region src/config.ts
+/**
+* The Dreame cloud regions the wrapped `@apocaliss92/nodedreame` client
+* supports. Mirrors the library's `DreameRegion` union — kept local so the
+* addon validates the operator-supplied value at the system boundary without
+* importing a runtime value the library does not export.
+*/
+var DREAME_REGIONS = [
+	"eu",
+	"us",
+	"cn",
+	"ru",
+	"sg",
+	"in",
+	"de",
+	"tw"
+];
+var DreameRegionSchema = _enum(DREAME_REGIONS);
+/**
+* Operator-supplied Dreamehome account settings for ONE broker (= one cloud
+* account). The Dreame integration is cloud-only (outbound HTTPS + per-device
+* MQTT push), so the connection is just account credentials plus a region.
+*
+* `pollIntervalMs` is the fallback poll cadence the library uses while a
+* device's MQTT push is down; `0` disables poll fallback.
+*
+* The diagnostic catalog (enum/numeric sensors, switches, selects) is seeded
+* from the cloud SHADOW once at broker start and then tracked by the library's
+* MQTT push. Live `get_properties` is NOT polled: a docked/asleep robot times it
+* out (Home Assistant shows the same diagnostics as `unavailable` then), and
+* hammering it only adds cloud load — so we rely on the shadow seed + push.
+*/
+var dreameConfigSchema = object({
+	username: string().min(1).describe("Dreamehome account email / username"),
+	password: string().min(1).describe("Dreamehome account password"),
+	region: DreameRegionSchema.default("eu").describe("Dreame cloud region"),
+	pollIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(0).max(36e5).default(3e4)).describe("Poll fallback interval (ms) while MQTT push is down — 0 disables")
+});
+/**
+* Build the `NodreameOptions` the wrapped client constructor expects from the
+* validated addon config. Pure: same config in → same options out.
+*/
+function toNodreameOptions(config) {
+	return {
+		username: config.username,
+		password: config.password,
+		region: config.region,
+		fetchInitialValues: true,
+		pollIntervalMs: config.pollIntervalMs
+	};
+}
+/**
+* Parse an integration's settings into a connection, or null when the mandatory
+* credentials (username + password) are missing. Used by the boot/lifecycle
+* reconcile to skip an integration whose account form was not completed.
+*/
+function connectionFromSettings(settings) {
+	const parsed = dreameConfigSchema.safeParse(settings);
+	return parsed.success ? parsed.data : null;
+}
+/**
+* Hand-written connection form for the account/integration creation UI — the
+* wizard's `account` config step renders this via `getGlobalSettings`. A flat
+* set of sections the admin UI renders into the "Add Dreame account" modal.
+*/
+function buildConnectionFormSchema() {
+	return { sections: [
+		{
+			id: "credentials",
+			title: "Dreamehome account",
+			description: "Sign in with your Dreamehome (Dreame app) account credentials.",
+			columns: 1,
+			fields: [{
+				type: "text",
+				key: "username",
+				label: "Email / username",
+				required: true,
+				placeholder: "you@example.com"
+			}, {
+				type: "password",
+				key: "password",
+				label: "Password",
+				required: true,
+				showToggle: true
+			}]
+		},
+		{
+			id: "region",
+			title: "Region",
+			description: "Select the Dreame cloud region your account is registered in.",
+			columns: 1,
+			fields: [{
+				type: "select",
+				key: "region",
+				label: "Region",
+				default: "eu",
+				options: DREAME_REGIONS.map((r) => ({
+					value: r,
+					label: r.toUpperCase()
+				}))
+			}]
+		},
+		{
+			id: "advanced",
+			title: "Advanced",
+			columns: 1,
+			fields: [{
+				type: "number",
+				key: "pollIntervalMs",
+				label: "Poll fallback interval (ms, 0 = disabled)",
+				min: 0,
+				max: 36e5,
+				default: 3e4
+			}]
+		}
+	] };
+}
+//#endregion
 //#region node_modules/undici/lib/core/symbols.js
 var require_symbols$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
@@ -74386,134 +74574,6 @@ objectType({
 	})
 });
 //#endregion
-//#region src/config.ts
-/**
-* The Dreame cloud regions the wrapped `@apocaliss92/nodedreame` client
-* supports. Mirrors the library's `DreameRegion` union — kept local so the
-* addon validates the operator-supplied value at the system boundary without
-* importing a runtime value the library does not export.
-*/
-var DREAME_REGIONS = [
-	"eu",
-	"us",
-	"cn",
-	"ru",
-	"sg",
-	"in",
-	"de",
-	"tw"
-];
-var DreameRegionSchema = _enum(DREAME_REGIONS);
-/**
-* Operator-supplied Dreamehome account settings for ONE broker (= one cloud
-* account). The Dreame integration is cloud-only (outbound HTTPS + per-device
-* MQTT push), so the connection is just account credentials plus a region.
-*
-* `pollIntervalMs` is the fallback poll cadence the library uses while a
-* device's MQTT push is down; `0` disables poll fallback.
-*
-* The diagnostic catalog (enum/numeric sensors, switches, selects) is seeded
-* from the cloud SHADOW once at broker start and then tracked by the library's
-* MQTT push. Live `get_properties` is NOT polled: a docked/asleep robot times it
-* out (Home Assistant shows the same diagnostics as `unavailable` then), and
-* hammering it only adds cloud load — so we rely on the shadow seed + push.
-*/
-var dreameConfigSchema = object({
-	username: string().min(1).describe("Dreamehome account email / username"),
-	password: string().min(1).describe("Dreamehome account password"),
-	region: DreameRegionSchema.default("eu").describe("Dreame cloud region"),
-	pollIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(0).max(36e5).default(3e4)).describe("Poll fallback interval (ms) while MQTT push is down — 0 disables")
-});
-/**
-* Build the `NodreameOptions` the wrapped client constructor expects from the
-* validated addon config. Pure: same config in → same options out.
-*/
-function toNodreameOptions(config) {
-	return {
-		username: config.username,
-		password: config.password,
-		region: config.region,
-		fetchInitialValues: true,
-		pollIntervalMs: config.pollIntervalMs
-	};
-}
-/** Top-level addon config — an ordered list of broker entries (default empty). */
-var dreameAddonConfigSchema = object({ brokers: array(object({
-	/** Stable opaque identifier — e.g. 'dreame_001', 'dreame_002'. */
-	id: string().min(1),
-	/** Human-readable label shown in the admin UI. */
-	name: string().min(1),
-	/** Validated account connection settings. */
-	connection: dreameConfigSchema,
-	/** FK to the spawning integration — auto-cleanup on integration delete. */
-	integrationId: string().optional()
-})).default([]) });
-/**
-* Coerce a loose settings blob (from the broker `add`/`setSettings` cap) through
-* the connection schema, applying all defaults. Throws a `ZodError` on invalid
-* input so the caller surfaces a clear error at the system boundary.
-*/
-function settingsToDreameConfig(settings) {
-	return dreameConfigSchema.parse(settings ?? {});
-}
-/**
-* Hand-written connection form for the broker/integration creation UI. Mirrors
-* the Homematic / Home Assistant broker-settings form shape — a flat set of
-* sections the admin UI renders into the "Add Dreame account" modal.
-*/
-function buildConnectionFormSchema() {
-	return { sections: [
-		{
-			id: "credentials",
-			title: "Dreamehome account",
-			description: "Sign in with your Dreamehome (Dreame app) account credentials.",
-			columns: 1,
-			fields: [{
-				type: "text",
-				key: "username",
-				label: "Email / username",
-				required: true,
-				placeholder: "you@example.com"
-			}, {
-				type: "password",
-				key: "password",
-				label: "Password",
-				required: true,
-				showToggle: true
-			}]
-		},
-		{
-			id: "region",
-			title: "Region",
-			description: "Select the Dreame cloud region your account is registered in.",
-			columns: 1,
-			fields: [{
-				type: "select",
-				key: "region",
-				label: "Region",
-				default: "eu",
-				options: DREAME_REGIONS.map((r) => ({
-					value: r,
-					label: r.toUpperCase()
-				}))
-			}]
-		},
-		{
-			id: "advanced",
-			title: "Advanced",
-			columns: 1,
-			fields: [{
-				type: "number",
-				key: "pollIntervalMs",
-				label: "Poll fallback interval (ms, 0 = disabled)",
-				min: 0,
-				max: 36e5,
-				default: 3e4
-			}]
-		}
-	] };
-}
-//#endregion
 //#region src/dreame-entity-catalog.ts
 var STATS = "Statistics";
 var MAINT = "Maintenance";
@@ -75160,6 +75220,34 @@ function enumOptions(e) {
 		label: humanizeEnumName(name)
 	}));
 }
+/**
+* MiotError codes that are BENIGN completion / reminder states, not active
+* faults. HA does not surface these as errors — a fresh cloud-shadow read of an
+* idle docked robot legitimately returns `TaskComplete` (68). We relabel them to
+* the `Clear` label so the Error sensor only shows real faults (HA parity).
+* Extend this set if other non-fault codes surface as spurious "errors".
+*/
+var BENIGN_ERROR_CODES = new Set([MiotError.TaskComplete]);
+/** `MiotError` options with the benign completion codes remapped to the `Clear`
+*  label, so the Error sensor reads as no-error for them (matches HA). */
+function errorEnumOptions() {
+	const clearLabel = humanizeEnumName(MiotError[MiotError.Clear]);
+	return enumOptions(MiotError).map((o) => BENIGN_ERROR_CODES.has(o.value) ? {
+		...o,
+		label: clearLabel
+	} : o);
+}
+/**
+* Resolve the CURRENT catalog options for an enum-sensor by its MIoT coordinates
+* (across both the vacuum and mower enum-sensor catalogs). The enum-sensor child
+* persists its option map at adoption; preferring the live catalog here lets a
+* label change (e.g. the benign-error remap) take effect for already-adopted
+* children on the next boot — without a re-adopt. Null when no catalog entry
+* matches (persisted config is then the only source).
+*/
+function enumSensorOptionsFor(siid, piid) {
+	return [...DREAME_ENUM_SENSORS, ...DREAME_MOWER_ENUM_SENSORS].find((es) => es.siid === siid && es.piid === piid)?.options ?? null;
+}
 /** Humanise a Tasshack SNAKE_CASE enum name → spaced Title Case
 *  ('BACK_HOME' → 'Back Home'). */
 function humanizeSnake(name) {
@@ -75285,7 +75373,7 @@ var DREAME_ENUM_SENSORS = [
 		label: "Error",
 		siid: 2,
 		piid: 2,
-		options: enumOptions(MiotError),
+		options: errorEnumOptions(),
 		section: DIAG
 	},
 	{
@@ -76100,35 +76188,51 @@ var DreameFacadeResolver = class {
 *  and device instances. */
 var dreameFacades = new DreameFacadeResolver();
 //#endregion
-//#region src/dreame-broker-registry.ts
+//#region src/dreame-client-registry.ts
+/**
+* Per-integration Dreame connection registry (account mode).
+*
+* Under the LOCKED integration/adoption model (design §7.1), Dreame is a
+* `mode: account` addon: each Dreame integration carries its own Dreamehome
+* account credentials in its `integration.settings`, and this registry holds one
+* {@link DreameIntegrationManager} per `integrationId`
+* (`Map<integrationId, DreameIntegrationManager>`). Multi-account = multiple
+* integrations; there is NO shared broker.
+*
+* The live `Nodreame` facade each manager owns is published on the in-process
+* {@link dreameFacades} resolver KEYED BY `integrationId`, so the device classes
+* resolve their live handle by the `brokerId` field they persist — which now
+* holds the integrationId (unchanged device-side code, see the addon migration
+* note). MQTT session/socket lifecycle stays entirely inside the manager +
+* library (no reintroduced socket-leak): the registry only starts/stops managers.
+*/
 /**
-* Manages N live Dreamehome account connections ("brokers"), each backed by a
-* {@link DreameIntegrationManager}. Allocates stable ids (`dreame_001`, …),
-* supports CRUD, an integration FK index for cascade-delete, and lifecycle
-* helpers. Mirrors `HmBrokerRegistry`.
+* Owns the `Map<integrationId, DreameIntegrationManager>`. Callers reconcile the
+* map against the live integration list on boot + on every integration lifecycle
+* event; device classes + the adoption provider resolve their facade by
+* `integrationId` through {@link dreameFacades}.
+*
+* Structural twin of `WyzeClientRegistry` — `upsert` is session-preserving when
+* credentials are unchanged, `retain` drops vanished integrations.
 */
-var DreameBrokerRegistry = class {
+var DreameClientRegistry = class {
 	#logger;
-	#onBrokerConnected;
-	#onBrokerDisconnected;
+	#onConnected;
+	#onDisconnected;
 	#makeManager;
-	#managers = /* @__PURE__ */ new Map();
-	#facades = /* @__PURE__ */ new Map();
-	#integrationToBroker = /* @__PURE__ */ new Map();
-	#nextId = 1;
 	#useDefaultFactory;
+	#entries = /* @__PURE__ */ new Map();
 	constructor(logger, deps = {}) {
 		this.#logger = logger;
-		this.#onBrokerConnected = deps.onBrokerConnected ?? (() => void 0);
-		this.#onBrokerDisconnected = deps.onBrokerDisconnected ?? (() => void 0);
+		this.#onConnected = deps.onConnected ?? (() => void 0);
+		this.#onDisconnected = deps.onDisconnected ?? (() => void 0);
 		this.#useDefaultFactory = deps.makeManager === void 0;
 		this.#makeManager = deps.makeManager ?? ((opts) => {
 			const raw = new Nodreame(toNodreameOptions(opts.connection));
-			this.#facades.set(opts.id, raw);
-			dreameFacades.set(opts.id, raw);
+			dreameFacades.set(opts.integrationId, raw);
 			const wrapped = raw;
 			return new DreameIntegrationManager({
-				id: opts.id,
+				id: opts.integrationId,
 				name: opts.name,
 				connection: opts.connection,
 				logger: opts.logger,
@@ -76138,270 +76242,124 @@ var DreameBrokerRegistry = class {
 			});
 		});
 	}
-	/** Restore persisted broker entries on boot (best-effort per manager). */
-	async restore(entries) {
-		for (const entry of entries) this.#seedCounter(entry.id);
-		for (const entry of entries) try {
-			await this.#startManager(entry);
-		} catch (err) {
-			this.#logger.warn("DreameBrokerRegistry: failed to restore manager", {
-				tags: { brokerId: entry.id },
-				meta: { error: errMsg(err) }
-			});
-		}
+	setOnConnected(cb) {
+		this.#onConnected = cb;
 	}
-	/** Stop all managers and clear state. */
-	async shutdown() {
-		const ids = Array.from(this.#managers.keys());
-		await Promise.all(ids.map(async (id) => {
+	setOnDisconnected(cb) {
+		this.#onDisconnected = cb;
+	}
+	/**
+	* Ensure a manager exists for `integrationId` with the given credentials.
+	* Idempotent: an existing entry with identical credentials is preserved
+	* (keeps its live MQTT session); a credentials change re-applies the
+	* connection atomically (stop + start). Best-effort start — a failed login
+	* leaves the entry registered so a later reconcile / lifecycle event retries.
+	*/
+	async upsert(integrationId, name, connection) {
+		const existing = this.#entries.get(integrationId);
+		if (existing) {
+			if (sameConnection(existing.connection, connection)) return;
 			try {
-				await this.#managers.get(id)?.stop();
+				if (this.#useDefaultFactory) {
+					const raw = new Nodreame(toNodreameOptions(connection));
+					dreameFacades.set(integrationId, raw);
+				}
+				await existing.manager.applyConnection(connection);
+				this.#entries.set(integrationId, {
+					manager: existing.manager,
+					connection
+				});
 			} catch (err) {
-				this.#logger.warn("DreameBrokerRegistry: shutdown stop failed", {
-					tags: { brokerId: id },
+				this.#logger.warn("DreameClientRegistry: applyConnection failed", {
+					tags: { integrationId },
 					meta: { error: errMsg(err) }
 				});
 			}
-		}));
-		this.#managers.clear();
-		this.#facades.clear();
-		this.#integrationToBroker.clear();
-		dreameFacades.clear();
-	}
-	setOnBrokerConnected(cb) {
-		this.#onBrokerConnected = cb;
-	}
-	setOnBrokerDisconnected(cb) {
-		this.#onBrokerDisconnected = cb;
-	}
-	async createEntry(name, connection, opts = {}) {
-		const id = this.#allocateId();
-		const entry = {
-			id,
+			return;
+		}
+		const manager = this.#makeManager({
+			integrationId,
 			name,
 			connection,
-			...opts.integrationId !== void 0 ? { integrationId: opts.integrationId } : {}
-		};
-		await this.#startManager(entry);
-		if (opts.integrationId !== void 0) this.#integrationToBroker.set(opts.integrationId, id);
-		return entry;
-	}
-	async removeEntry(id) {
-		const mgr = this.#managers.get(id);
-		if (!mgr) throw new Error(`DreameBrokerRegistry: unknown broker id "${id}"`);
-		for (const [integrationId, brokerId] of this.#integrationToBroker.entries()) if (brokerId === id) this.#integrationToBroker.delete(integrationId);
-		this.#managers.delete(id);
-		this.#facades.delete(id);
-		dreameFacades.set(id, null);
+			logger: this.#logger,
+			onConnected: (id) => this.#onConnected(id),
+			onDisconnected: (id) => this.#onDisconnected(id)
+		});
+		this.#entries.set(integrationId, {
+			manager,
+			connection
+		});
 		try {
-			await mgr.stop();
+			await manager.start();
 		} catch (err) {
-			this.#logger.warn("DreameBrokerRegistry: removeEntry stop failed", {
-				tags: { brokerId: id },
+			this.#logger.warn("DreameClientRegistry: manager start failed", {
+				tags: { integrationId },
 				meta: { error: errMsg(err) }
 			});
 		}
 	}
-	async updateEntry(id, connection) {
-		const mgr = this.#managers.get(id);
-		if (!mgr) throw new Error(`DreameBrokerRegistry: unknown broker id "${id}"`);
-		if (this.#useDefaultFactory) {
-			const raw = new Nodreame(toNodreameOptions(connection));
-			this.#facades.set(id, raw);
-			dreameFacades.set(id, raw);
+	/** Stop + drop the manager for an integration that no longer exists. */
+	async remove(integrationId) {
+		const entry = this.#entries.get(integrationId);
+		if (!entry) return;
+		this.#entries.delete(integrationId);
+		dreameFacades.set(integrationId, null);
+		try {
+			await entry.manager.stop();
+		} catch (err) {
+			this.#logger.warn("DreameClientRegistry: remove stop failed", {
+				tags: { integrationId },
+				meta: { error: errMsg(err) }
+			});
 		}
-		await mgr.applyConnection(connection);
-		return {
-			id,
-			name: mgr.getInfo().name,
-			connection
-		};
 	}
-	linkIntegration(integrationId, brokerId) {
-		this.#integrationToBroker.set(integrationId, brokerId);
+	/** Stop + drop every manager whose integrationId is not in `keep`. */
+	async retain(keep) {
+		const stale = [...this.#entries.keys()].filter((id) => !keep.has(id));
+		for (const id of stale) await this.remove(id);
 	}
-	getBrokerIdByIntegrationId(integrationId) {
-		const brokerId = this.#integrationToBroker.get(integrationId);
-		if (brokerId === void 0) throw new Error(`DreameBrokerRegistry: no broker linked for integration id "${integrationId}"`);
-		return brokerId;
+	/** Stop every manager and clear all state (full shutdown). */
+	async shutdown() {
+		const ids = [...this.#entries.keys()];
+		await Promise.all(ids.map(async (id) => {
+			try {
+				await this.#entries.get(id)?.manager.stop();
+			} catch (err) {
+				this.#logger.warn("DreameClientRegistry: shutdown stop failed", {
+					tags: { integrationId: id },
+					meta: { error: errMsg(err) }
+				});
+			}
+		}));
+		this.#entries.clear();
+		dreameFacades.clear();
 	}
-	getFacade(id) {
-		return this.#facades.get(id) ?? null;
+	/** True when a manager is registered for the integration. */
+	has(integrationId) {
+		return this.#entries.has(integrationId);
 	}
+	/** The registered integration ids (one per account). */
 	list() {
-		return Array.from(this.#managers.values()).map((m) => m.getInfo());
+		return [...this.#entries.keys()];
 	}
-	get(id) {
-		return this.#managers.get(id)?.getInfo() ?? null;
+	/** The current connection an integration's manager is configured with. */
+	getConnection(integrationId) {
+		return this.#entries.get(integrationId)?.connection ?? null;
 	}
-	getConnection(id) {
-		return this.#managers.get(id)?.getConnection() ?? null;
+	/** Immutable status snapshot for an integration's manager. */
+	getInfo(integrationId) {
+		return this.#entries.get(integrationId)?.manager.getInfo() ?? null;
 	}
 	size() {
-		return this.#managers.size;
+		return this.#entries.size;
 	}
 	connectedCount() {
 		let count = 0;
-		for (const mgr of this.#managers.values()) if (mgr.getInfo().status === "connected") count++;
+		for (const entry of this.#entries.values()) if (entry.manager.getInfo().status === "connected") count++;
 		return count;
 	}
-	async #startManager(entry) {
-		if (this.#managers.has(entry.id)) {
-			if (entry.integrationId !== void 0) this.#integrationToBroker.set(entry.integrationId, entry.id);
-			return;
-		}
-		const mgr = this.#makeManager({
-			id: entry.id,
-			name: entry.name,
-			connection: entry.connection,
-			logger: this.#logger,
-			onConnected: (id) => this.#onBrokerConnected(id),
-			onDisconnected: (id) => this.#onBrokerDisconnected(id)
-		});
-		this.#managers.set(entry.id, mgr);
-		if (entry.integrationId !== void 0) this.#integrationToBroker.set(entry.integrationId, entry.id);
-		await mgr.start();
-	}
-	#allocateId() {
-		const id = `dreame_${String(this.#nextId).padStart(3, "0")}`;
-		this.#nextId++;
-		return id;
-	}
-	#seedCounter(id) {
-		const match = /^dreame_(\d+)$/.exec(id);
-		if (match === null || match[1] === void 0) return;
-		const n = parseInt(match[1], 10);
-		if (!isNaN(n)) this.#nextId = Math.max(this.#nextId, n + 1);
-	}
 };
 //#endregion
-//#region src/dreame-broker-provider.ts
-/** Kind tag registered by this provider — matches the `listProviders` entry. */
-var DREAME_KIND = "dreame";
-/**
-* Construct the `broker` cap provider for the Dreame addon. Pure builder: all
-* side-effecting deps are injected so the returned object is unit-testable.
-* Mirrors `buildHmBrokerProvider`.
-*/
-function buildDreameBrokerProvider(deps) {
-	const { ownerAddonId, registry, getBrokers, persistBrokers, cascadeRemoveDevices, logger } = deps;
-	const owns = (id) => getBrokers().some((b) => b.id === id);
-	return {
-		list: async ({ kind }) => {
-			if (kind && kind !== DREAME_KIND) return [];
-			return registry.list().map((info) => ({
-				...info,
-				addonId: ownerAddonId
-			}));
-		},
-		get: async ({ id }) => {
-			const info = registry.get(id);
-			return info ? {
-				...info,
-				addonId: ownerAddonId
-			} : null;
-		},
-		listProviders: async () => [{
-			addonId: ownerAddonId,
-			kinds: [{
-				kind: DREAME_KIND,
-				label: "Dreame"
-			}]
-		}],
-		add: async ({ kind, name, settings }) => {
-			if (kind !== DREAME_KIND) throw new Error(`provider-dreame: only kind '${DREAME_KIND}' is handled here (got '${kind}')`);
-			const entry = await registry.createEntry(name, settingsToDreameConfig(settings));
-			await persistBrokers([...getBrokers(), entry]);
-			return { id: entry.id };
-		},
-		remove: async ({ id }) => {
-			if (!owns(id)) return;
-			await registry.removeEntry(id);
-			await cascadeRemoveDevices(id).catch((err) => {
-				logger.warn("dreame: broker cascade-remove threw", {
-					tags: { brokerId: id },
-					meta: { error: errMsg(err) }
-				});
-			});
-			await persistBrokers(getBrokers().filter((b) => b.id !== id));
-		},
-		testConnection: async ({ id }) => {
-			if (!owns(id)) return {
-				ok: false,
-				error: "unknown broker"
-			};
-			const info = registry.get(id);
-			if (!info) return {
-				ok: false,
-				error: "unknown broker"
-			};
-			if (info.status === "connected") return {
-				ok: true,
-				latencyMs: info.lastCheckedAt ? Math.max(0, Date.now() - info.lastCheckedAt) : 0
-			};
-			return {
-				ok: false,
-				error: info.error ?? `status: ${info.status}`
-			};
-		},
-		getSettings: async ({ id }) => {
-			const entry = getBrokers().find((b) => b.id === id);
-			if (!entry) return null;
-			return {
-				...entry.connection,
-				password: ""
-			};
-		},
-		setSettings: async ({ id, settings }) => {
-			if (!owns(id)) return;
-			const existing = getBrokers().find((b) => b.id === id);
-			if (!existing) return;
-			const parsed = settingsToDreameConfig(settings);
-			const merged = {
-				...parsed,
-				password: parsed.password.length > 0 ? parsed.password : existing.connection.password
-			};
-			const updated = await registry.updateEntry(id, merged);
-			await persistBrokers(getBrokers().map((b) => b.id === id ? updated : b));
-		},
-		getBrokerConfig: async ({ id }) => {
-			const entry = getBrokers().find((b) => b.id === id);
-			if (!entry) return null;
-			return {
-				...entry.connection,
-				password: ""
-			};
-		},
-		getSettingsSchema: async ({ kind }) => {
-			if (kind !== DREAME_KIND) return null;
-			return buildConnectionFormSchema();
-		},
-		testSettings: async ({ kind, settings }) => {
-			if (kind !== DREAME_KIND) return {
-				ok: false,
-				error: `unsupported kind: ${kind}`
-			};
-			try {
-				settingsToDreameConfig(settings);
-				return { ok: true };
-			} catch (err) {
-				return {
-					ok: false,
-					error: errMsg(err)
-				};
-			}
-		},
-		publish: async () => null,
-		subscribe: async () => ({ subscriptionId: "" }),
-		unsubscribe: async () => void 0,
-		getState: async () => null,
-		getStatus: async () => ({
-			brokerCount: registry.size(),
-			connectedCount: registry.connectedCount()
-		})
-	};
-}
-//#endregion
 //#region src/dreame-mapping.ts
 /** Classify a Dreame cloud `model` string into a supported device kind. Pure. */
 function classifyDreameModel(model) {
@@ -76454,11 +76412,11 @@ var DEVICES_FILTER = {
 	label: "Devices",
 	isDefault: true
 };
-/** Build a `dreameDeviceId → CamStack deviceId` map for a single broker. */
-async function adoptedMapForBroker(brokerId, listAdoptedDreame) {
+/** Build a `dreameDeviceId → CamStack deviceId` map for a single integration. */
+async function adoptedMapForIntegration(integrationId, listAdoptedDreame) {
 	const all = await listAdoptedDreame();
 	const map = /* @__PURE__ */ new Map();
-	for (const device of all) if (device.config["system"] === "dreame" && device.config["brokerId"] === brokerId) {
+	for (const device of all) if (device.config["system"] === "dreame" && device.config["brokerId"] === integrationId) {
 		const dreameId = device.config["dreameDeviceId"];
 		if (typeof dreameId === "string") map.set(dreameId, device.id);
 	}
@@ -76466,15 +76424,15 @@ async function adoptedMapForBroker(brokerId, listAdoptedDreame) {
 }
 /**
 * Construct the `device-adoption` cap provider for the Dreame addon. Pure
-* builder: all side-effecting deps are injected. Mirrors `buildHmAdoptionProvider`
-* but with a single `devices` granularity (one Container per cloud device).
+* builder: all side-effecting deps are injected. Single `devices` granularity
+* (one Container per cloud device); resolves each account by `integrationId`.
 */
 function buildDreameAdoptionProvider(deps) {
-	const { registry, getBrokerIdForIntegration, listAdoptedDreame, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
-	async function allCandidatesForBroker(brokerId) {
+	const { getFacade, hasIntegration, listIntegrations, listAdoptedDreame, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
+	async function allCandidatesForIntegration(integrationId) {
 		return buildDreameCandidates({
-			devices: registry.getFacade(brokerId)?.devices ?? [],
-			adopted: await adoptedMapForBroker(brokerId, listAdoptedDreame)
+			devices: getFacade(integrationId)?.devices ?? [],
+			adopted: await adoptedMapForIntegration(integrationId, listAdoptedDreame)
 		});
 	}
 	function applyCandidateTextFilter(cands, filterText) {
@@ -76492,7 +76450,7 @@ function buildDreameAdoptionProvider(deps) {
 	return {
 		listCandidateFilters: async () => ({ filters: [DEVICES_FILTER] }),
 		listCandidates: async ({ integrationId, page, pageSize, filterText }) => {
-			const filtered = applyCandidateTextFilter(await allCandidatesForBroker(await getBrokerIdForIntegration(integrationId)), filterText);
+			const filtered = applyCandidateTextFilter(await allCandidatesForIntegration(integrationId), filterText);
 			const start = (page - 1) * pageSize;
 			return {
 				candidates: filtered.slice(start, start + pageSize),
@@ -76502,13 +76460,12 @@ function buildDreameAdoptionProvider(deps) {
 			};
 		},
 		getCandidate: async ({ integrationId, childNativeId }) => {
-			return (await allCandidatesForBroker(await getBrokerIdForIntegration(integrationId))).find((c) => c.childNativeId === childNativeId) ?? null;
+			return (await allCandidatesForIntegration(integrationId)).find((c) => c.childNativeId === childNativeId) ?? null;
 		},
 		getStatus: async () => {
 			try {
-				const brokers = registry.list();
 				let candidateCount = 0;
-				for (const broker of brokers) candidateCount += (await allCandidatesForBroker(broker.id)).length;
+				for (const integrationId of listIntegrations()) candidateCount += (await allCandidatesForIntegration(integrationId)).length;
 				const adoptedCount = (await listAdoptedDreame()).filter((d) => d.config["system"] === "dreame").length;
 				return {
 					lastDiscoveryAt: Date.now(),
@@ -76527,9 +76484,8 @@ function buildDreameAdoptionProvider(deps) {
 			}
 		},
 		refresh: async ({ integrationId }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			const candidateCount = (await allCandidatesForBroker(brokerId)).length;
-			const adoptedCount = (await listAdoptedDreame()).filter((d) => d.config["system"] === "dreame" && d.config["brokerId"] === brokerId).length;
+			const candidateCount = (await allCandidatesForIntegration(integrationId)).length;
+			const adoptedCount = (await adoptedMapForIntegration(integrationId, listAdoptedDreame)).size;
 			return {
 				lastDiscoveryAt: Date.now(),
 				candidateCount,
@@ -76538,18 +76494,17 @@ function buildDreameAdoptionProvider(deps) {
 			};
 		},
 		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			const facade = registry.getFacade(brokerId);
-			if (facade === null) throw new Error(`dreame adopt: broker ${brokerId} not connected`);
+			const facade = getFacade(integrationId);
+			if (facade === null) throw new Error(`dreame adopt: integration ${integrationId} not connected`);
 			const devices = facade.devices;
 			const adopted = [];
 			let failures = 0;
 			for (const dreameDeviceId of childNativeIds) try {
 				const dev = devices.find((d) => d.deviceId === dreameDeviceId);
 				if (dev === void 0) {
-					logger.warn("dreame adopt: device not found on broker — skipping", { meta: {
+					logger.warn("dreame adopt: device not found on integration — skipping", { meta: {
 						dreameDeviceId,
-						brokerId
+						integrationId
 					} });
 					failures++;
 					continue;
@@ -76561,7 +76516,7 @@ function buildDreameAdoptionProvider(deps) {
 				if (candidate === void 0) {
 					logger.warn("dreame adopt: device model unsupported — skipping", { meta: {
 						dreameDeviceId,
-						brokerId,
+						integrationId,
 						model: dev.model
 					} });
 					failures++;
@@ -76570,7 +76525,6 @@ function buildDreameAdoptionProvider(deps) {
 				const name = perCandidate?.[dreameDeviceId]?.name ?? dev.name ?? dreameDeviceId;
 				const { deviceId, accessoryDeviceIds } = await adoptDevice({
 					dreameDeviceId,
-					brokerId,
 					integrationId,
 					type: candidate.type,
 					name,
@@ -76584,7 +76538,7 @@ function buildDreameAdoptionProvider(deps) {
 			} catch (err) {
 				logger.warn("dreame adopt: failed to adopt device", { meta: {
 					dreameDeviceId,
-					brokerId,
+					integrationId,
 					error: errMsg(err)
 				} });
 				failures++;
@@ -76599,9 +76553,10 @@ function buildDreameAdoptionProvider(deps) {
 			const cfg = await findDeviceConfig(camDeviceId);
 			if (cfg === null) throw new Error(`dreame resync: device ${camDeviceId} not found`);
 			if (cfg["system"] !== "dreame") throw new Error(`dreame resync: device ${camDeviceId} is not a Dreame device`);
-			const brokerId = String(cfg["brokerId"]);
+			const integrationId = String(cfg["brokerId"]);
 			const dreameDeviceId = String(cfg["dreameDeviceId"]);
-			if (!(registry.getFacade(brokerId)?.devices.some((d) => d.deviceId === dreameDeviceId) ?? false)) throw new Error(`dreame resync: device ${dreameDeviceId} no longer present on broker ${brokerId}`);
+			if (!hasIntegration(integrationId)) throw new Error(`dreame resync: integration ${integrationId} not connected`);
+			if (!(getFacade(integrationId)?.devices.some((d) => d.deviceId === dreameDeviceId) ?? false)) throw new Error(`dreame resync: device ${dreameDeviceId} no longer present on integration ${integrationId}`);
 			return {
 				changed: false,
 				rebuiltChildren: 0
@@ -76610,29 +76565,31 @@ function buildDreameAdoptionProvider(deps) {
 	};
 }
 //#endregion
-//#region src/dreame-broker-device-cascade.ts
+//#region src/dreame-integration-device-cascade.ts
 /**
 * Remove every adopted Dreame PARENT device (children cascade via the kernel)
-* whose persisted config carries `{ system: 'dreame', brokerId }`. Used when a
-* broker is removed (broker.remove) and when its spawning integration is
-* deleted. Best-effort per device; returns the count removed. Mirrors the
-* Homematic cascade helper.
+* whose persisted config carries `{ system: 'dreame', brokerId: integrationId }`.
+* Used when an integration is deleted. Best-effort per device; returns the count
+* removed.
+*
+* NOTE: the persisted config field is still named `brokerId` (unchanged
+* device-side schema) but under the account model it holds the `integrationId`.
 */
-async function cascadeRemoveDevicesForBroker(input) {
-	const { reg, devices, addonId, brokerId, logger } = input;
+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"] !== "dreame" || cfg["brokerId"] !== brokerId) continue;
+		if (cfg["system"] !== "dreame" || cfg["brokerId"] !== integrationId) continue;
 		try {
 			await devices.remove(d.id);
 			removed += 1;
 		} catch (err) {
-			logger.warn("dreame: broker cascade-remove failed", {
+			logger.warn("dreame: integration cascade-remove failed", {
 				tags: { deviceId: d.id },
 				meta: {
-					brokerId,
+					integrationId,
 					error: errMsg(err)
 				}
 			});
@@ -76641,20 +76598,22 @@ async function cascadeRemoveDevicesForBroker(input) {
 	return removed;
 }
 //#endregion
-//#region src/dreame-broker-offline.ts
+//#region src/dreame-integration-offline.ts
 /**
-* Set every Dreame device belonging to `brokerId` to the requested online
+* Set every Dreame device belonging to `integrationId` to the requested online
 * state. `devices` is the addon-scoped device list; every Dreame top-level
-* Container carries `{ system: 'dreame', brokerId }` in its config blob.
+* Container carries `{ system: 'dreame', brokerId: integrationId }` in its
+* config blob (the `brokerId` field name is unchanged; it now holds the
+* integrationId).
 *
 * Churn-free: skips any device already in the target state. Returns the count
-* of devices actually transitioned. Mirrors the Homematic offline helper.
+* of devices actually transitioned.
 */
-function setBrokerDevicesOnline(devices, brokerId, online) {
+function setIntegrationDevicesOnline(devices, integrationId, online) {
 	let count = 0;
 	for (const dev of devices) {
 		if (dev.config.get("system") !== "dreame") continue;
-		if (dev.config.get("brokerId") !== brokerId) continue;
+		if (dev.config.get("brokerId") !== integrationId) continue;
 		if (dev.online === online) continue;
 		dev.markOnline(online);
 		count += 1;
@@ -77141,7 +77100,7 @@ var DreameEnumSensorDevice = class extends DreameChildDevice {
 		const cfg = dreameEnumSensorSchema.parse(ctx.persistedConfig ?? {});
 		this.#siid = cfg.siid;
 		this.#piid = cfg.piid;
-		this.#options = cfg.options;
+		this.#options = enumSensorOptionsFor(cfg.siid, cfg.piid) ?? cfg.options;
 		this.updateSourceInfo({
 			id: `${this.dreameDeviceId}:enum:${cfg.siid}-${cfg.piid}`,
 			system: "dreame"
@@ -77391,6 +77350,15 @@ var CONSUMABLES_CAP_NAME$1 = "consumables";
 var CONSUMABLES_WAKE_RETRIES = 2;
 /** Spacing between wake-window retries. */
 var CONSUMABLES_RETRY_DELAY_MS = 1500;
+/**
+* Cloud-shadow (no-wake) refresh cadence for the mower's battery / charging /
+* status props. The shadow read (`refreshFromCache` → `getCachedProperties`)
+* hits the cloud SHADOW, not the device — so it succeeds even while the mower
+* sleeps at base, UNLIKE the synchronous CMS action above (which 80001s). The
+* mower never PUSHES battery over MQTT, so without this poll `batteryLevel`
+* stays null. A gentle interval keeps the level current as it charges.
+*/
+var SHADOW_POLL_MS = 12e4;
 var COLD_START = {
 	activity: "idle",
 	batteryLevel: null,
@@ -77430,6 +77398,8 @@ var DreameMowerDevice = class extends DreameChildDevice {
 	#prevStatus = null;
 	/** Last seen `chargingStatus` value — second awake-and-charging trigger. */
 	#prevCharging = null;
+	/** Periodic cloud-shadow refresh timer (battery / charging / status). */
+	#shadowTimer = null;
 	constructor(ctx) {
 		super(ctx);
 	}
@@ -77465,6 +77435,35 @@ var DreameMowerDevice = class extends DreameChildDevice {
 	async onActivate() {
 		await super.onActivate();
 		this.refreshConsumables(CONSUMABLES_WAKE_RETRIES);
+		this.#refreshShadow();
+		this.#shadowTimer = setInterval(() => {
+			this.#refreshShadow();
+		}, SHADOW_POLL_MS);
+	}
+	async removeDevice() {
+		if (this.#shadowTimer) {
+			clearInterval(this.#shadowTimer);
+			this.#shadowTimer = null;
+		}
+		await super.removeDevice();
+	}
+	/**
+	* Seed the cached MIoT props (battery / charging / status …) from the CLOUD
+	* SHADOW — a no-wake read that succeeds even while the mower sleeps at base.
+	* `refreshFromCache` emits `stateChanged`, which drives `recomputeSlice`, so
+	* the battery level lands in the slice. Best-effort; failures log at debug.
+	*/
+	async #refreshShadow() {
+		const mower = this.resolveMower();
+		if (mower === null) return;
+		try {
+			await mower.refreshFromCache();
+		} catch (err) {
+			this.ctx.logger.debug("dreame mower: cloud-shadow refresh failed", { meta: {
+				dreameDeviceId: this.dreameDeviceId,
+				error: errMsg(err)
+			} });
+		}
 	}
 	recomputeSlice() {
 		const mower = this.resolveMower();
@@ -79433,101 +79432,53 @@ var DreameContainerDevice = class extends BaseDevice$1 {
 };
 //#endregion
 //#region src/addon.ts
-/** Default multi-broker config — a fresh install starts with no accounts. */
-var DEFAULTS = { brokers: [] };
 /**
-* Dreame device-provider addon (multi-account).
+* Dreame device-provider addon — `mode: account` (multi-account, broker-less).
+*
+* Wraps the `@apocaliss92/nodedreame` Dreamehome cloud client. Each Dreame
+* integration carries its own account credentials in its `integration.settings`;
+* the addon holds one {@link DreameIntegrationManager} per `integrationId` in
+* {@link DreameClientRegistry} (`Map<integrationId, manager>`). There is NO
+* shared broker. The live `Nodreame` facade each manager owns is published on
+* the in-process `dreameFacades` resolver KEYED BY `integrationId`.
 *
-* Wraps the `@apocaliss92/nodedreame` Dreamehome cloud client. One registered
-* account = one "broker"; each adopted cloud device becomes a {@link DeviceType.Container}
-* parent that fans out a single typed accessory child (vacuum or mower). Modelled
-* directly on the Homematic / Home Assistant device-provider template:
-* `broker` + `device-adoption` cap providers for connection + adoption, the
-* `device-provider` cap from the base class, and an in-process facade resolver
-* (`dreameFacades`) the device classes read.
+* A `device-adoption` cap provider enumerates each account's cloud devices and
+* adopts them; each adopted cloud device becomes a {@link DeviceType.Container}
+* parent that fans out a single typed accessory child (vacuum or mower) and its
+* entity children. The device classes resolve their live handle by the
+* `brokerId` config field — UNCHANGED device-side code; that field now holds the
+* integrationId (see the migration note in the addon docs).
+*
+* `hub-only`: the map data-plane binds 127.0.0.1.
 */
 var DreameProviderAddon = class extends BaseDeviceProvider {
 	addonId = "provider-dreame";
 	providerName = "Dreame";
 	deviceClasses = { [DeviceType.Container]: DreameContainerDevice };
-	registry = null;
+	clients = null;
 	/** Teardown for the `/map` data-plane listener (vacuum-map PNG serving). */
 	mapDataPlaneDispose = null;
 	constructor() {
-		super({ ...DEFAULTS });
+		super({});
 	}
 	async onInitialize() {
 		const regs = await super.onInitialize();
-		this.registry = new DreameBrokerRegistry(this.ctx.logger);
-		this.registry.setOnBrokerConnected((brokerId) => {
-			this.ctx.logger.info("Dreame: broker connected", { meta: { brokerId } });
-			this.setBrokerDevicesOnline(brokerId, true);
+		this.clients = new DreameClientRegistry(this.ctx.logger);
+		this.clients.setOnConnected((integrationId) => {
+			this.ctx.logger.info("Dreame: integration connected", { meta: { integrationId } });
+			this.setIntegrationDevicesOnline(integrationId, true);
 		});
-		this.registry.setOnBrokerDisconnected((brokerId) => {
-			this.setBrokerDevicesOnline(brokerId, false);
+		this.clients.setOnDisconnected((integrationId) => {
+			this.setIntegrationDevicesOnline(integrationId, false);
 		});
-		await this.registry.restore(this.config.brokers);
-		this.ctx.logger.info("Dreame: provider initialised", { meta: { brokerCount: this.config.brokers.length } });
-		await this.reconcileIntegrationsToBrokers();
+		await this.reconcileIntegrations();
 		this.subscribeIntegrationLifecycle();
 		await this.setupMapDataPlane();
-		return [
-			...regs,
-			{
-				capability: brokerCapability,
-				provider: this.buildBrokerProvider()
-			},
-			{
-				capability: deviceAdoptionCapability,
-				provider: this.buildAdoptionProvider()
-			}
-		];
-	}
-	/** Reconcile the live registry against the persisted `brokers` array after a
-	*  settings write (UI save or `broker.*` cap). Mirrors the HA / Homematic addon. */
-	async onConfigChanged() {
-		const reg = this.registry;
-		if (!reg) return;
-		const persisted = this.config.brokers;
-		const liveIds = new Set(reg.list().map((b) => b.id));
-		const persistedIds = new Set(persisted.map((e) => e.id));
-		for (const liveId of liveIds) if (!persistedIds.has(liveId)) try {
-			await reg.removeEntry(liveId);
-		} catch (err) {
-			this.ctx.logger.warn("Dreame onConfigChanged: removeEntry failed", { meta: {
-				brokerId: liveId,
-				error: errMsg(err)
-			} });
-		}
-		for (const entry of persisted) {
-			if (entry.id && liveIds.has(entry.id)) {
-				if (sameConnection(entry.connection, reg.getConnection(entry.id))) continue;
-				try {
-					await reg.updateEntry(entry.id, entry.connection);
-				} catch (err) {
-					this.ctx.logger.warn("Dreame onConfigChanged: updateEntry failed", { meta: {
-						brokerId: entry.id,
-						error: errMsg(err)
-					} });
-				}
-				continue;
-			}
-			try {
-				const created = await reg.createEntry(entry.name, entry.connection);
-				if (created.id !== entry.id) {
-					const next = persisted.map((b) => b === entry ? {
-						...b,
-						id: created.id
-					} : b);
-					await this.updateGlobalSettings({ brokers: next });
-				}
-			} catch (err) {
-				this.ctx.logger.warn("Dreame onConfigChanged: failed to start new broker", { meta: {
-					brokerName: entry.name,
-					error: errMsg(err)
-				} });
-			}
-		}
+		this.ctx.logger.info("Dreame: provider initialised", { meta: { integrationCount: this.requireClients().size() } });
+		return [...regs, {
+			capability: deviceAdoptionCapability,
+			provider: this.buildAdoptionProvider()
+		}];
 	}
 	async onShutdown() {
 		try {
@@ -79538,13 +79489,17 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 		this.mapDataPlaneDispose = null;
 		setMapBaseUrl(null);
 		try {
-			await this.registry?.shutdown();
+			await this.clients?.shutdown();
 		} catch (err) {
 			this.ctx.logger.warn("Dreame: provider shutdown error", { meta: { error: errMsg(err) } });
 		}
-		this.registry = null;
+		this.clients = null;
 		await super.onShutdown();
 	}
+	requireClients() {
+		if (!this.clients) throw new Error("Dreame provider not initialised");
+		return this.clients;
+	}
 	/**
 	* Register the `/map` data-plane route that streams rendered vacuum-map PNGs
 	* to the browser (`<img>` loads `/addon/<addonId>/map?did=…&t=…`). The map
@@ -79575,93 +79530,76 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 			this.ctx.logger.warn("Dreame: map data-plane setup failed", { meta: { error: errMsg(err) } });
 		}
 	}
-	/** Stable id, broker-scoped so two accounts exposing the same device id don't
-	*  collide (mirrors the HA/Homematic broker-scoping). */
+	/**
+	* Stable id, integration-scoped so two accounts exposing the same cloud device
+	* id don't collide. `brokerId` in the config is the integrationId (unchanged
+	* field name).
+	*/
 	generateStableId(_type, config) {
 		return `dreame:${String(config?.["brokerId"] ?? "unknown")}:${String(config?.["dreameDeviceId"] ?? Date.now())}`;
 	}
-	buildBrokerProvider() {
-		return buildDreameBrokerProvider({
-			ownerAddonId: this.ctx.id,
-			registry: this.requireRegistry(),
-			getBrokers: () => this.config.brokers,
-			persistBrokers: (brokers) => this.updateGlobalSettings({ brokers: [...brokers] }),
-			cascadeRemoveDevices: (brokerId) => this.cascadeRemoveDevicesForBroker(brokerId),
-			logger: this.ctx.logger
-		});
-	}
-	async cascadeRemoveDevicesForBroker(brokerId) {
-		const reg = this.ctx.kernel.deviceRegistry;
-		const devices = this.ctx.kernel.devices;
-		if (!reg || !devices) return;
-		await cascadeRemoveDevicesForBroker({
-			reg,
-			devices,
-			addonId: this.addonId,
-			brokerId,
-			logger: this.ctx.logger
-		});
-	}
 	/**
-	* Link each surviving integration (carrying `{ brokerId }` in its settings) to
-	* its broker so the generic `device-adoption` cap resolves the account, and
-	* cascade-clean brokers (+ their adopted devices) whose spawning integration
-	* was deleted. Idempotent; runs on boot + on every integration lifecycle event.
-	* Guarded so a failure never fails init.
+	* Rebuild the `Map<integrationId, manager>` from the live integration list:
+	* for each surviving Dreame integration read its settings and upsert a manager
+	* (session-preserving if credentials are unchanged); drop managers whose
+	* integration was deleted/disabled — cascade-removing their adopted devices.
+	* Idempotent; runs on boot + on every integration lifecycle event. Guarded so
+	* a failure never fails init.
 	*/
-	async reconcileIntegrationsToBrokers() {
+	async reconcileIntegrations() {
+		const reg = this.requireClients();
 		try {
-			const mine = (await this.ctx.api.integrations.list.query()).filter((i) => i.addonId === this.ctx.id);
-			const surviving = new Set(mine.map((i) => i.id));
-			for (const integration of mine) {
-				const settings = await this.ctx.api.integrations.getSettings.query({ id: integration.id });
-				const brokerId = typeof settings["brokerId"] === "string" ? settings["brokerId"] : void 0;
-				if (brokerId === void 0) continue;
-				if (!this.config.brokers.some((b) => b.id === brokerId)) {
-					this.ctx.logger.warn("Dreame integration→broker: linked broker not found", { meta: {
-						integrationId: integration.id,
-						brokerId
-					} });
+			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 connection = connectionFromSettings(await this.ctx.api.integrations.getSettings.query({ id: integration.id }));
+				if (!connection) {
+					this.ctx.logger.warn("Dreame integration has no complete credentials — skipping", { meta: { integrationId: integration.id } });
 					continue;
 				}
-				this.requireRegistry().linkIntegration(integration.id, brokerId);
-			}
-			const toRemove = this.config.brokers.filter((b) => b.integrationId !== void 0 && !surviving.has(b.integrationId)).map((b) => b.id);
-			if (toRemove.length === 0) return;
-			for (const id of toRemove) try {
-				await this.requireRegistry().removeEntry(id);
-				await this.cascadeRemoveDevicesForBroker(id);
+				await reg.upsert(integration.id, integration.name, connection);
+				surviving.add(integration.id);
 			} catch (err) {
-				this.ctx.logger.warn("Dreame integration→broker: broker cleanup failed", { meta: {
-					brokerId: id,
+				this.ctx.logger.warn("Dreame reconcile: failed to read integration settings", { meta: {
+					integrationId: integration.id,
 					error: errMsg(err)
 				} });
 			}
-			const nextBrokers = this.config.brokers.filter((b) => !toRemove.includes(b.id));
-			await this.updateGlobalSettings({ brokers: nextBrokers });
+			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("Dreame integration→broker reconcile failed", { meta: { error: errMsg(err) } });
+			this.ctx.logger.warn("Dreame integration reconcile failed", { meta: { error: errMsg(err) } });
 		}
 	}
 	subscribeIntegrationLifecycle() {
 		const handler = (event) => {
 			const addonId = event.data["addonId"];
 			if (typeof addonId === "string" && addonId !== this.ctx.id) return;
-			this.reconcileIntegrationsToBrokers();
+			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);
 	}
+	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 buildDreameAdoptionProvider({
-			registry: this.requireRegistry(),
 			logger: this.ctx.logger,
-			getBrokerIdForIntegration: async (id) => {
-				const brokerId = (await this.ctx.api.integrations.getSettings.query({ id }))["brokerId"];
-				if (typeof brokerId !== "string") throw new Error(`integration ${id} has no linked brokerId`);
-				return brokerId;
-			},
+			getFacade: (integrationId) => dreameFacades.get(integrationId),
+			hasIntegration: (integrationId) => this.requireClients().has(integrationId),
+			listIntegrations: () => this.requireClients().list(),
 			listAdoptedDreame: async () => {
 				const reg = this.ctx.kernel.deviceRegistry;
 				const devices = this.ctx.kernel.devices;
@@ -79677,12 +79615,12 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 				}
 				return out;
 			},
-			adoptDevice: async ({ dreameDeviceId, brokerId, integrationId, name, model }) => {
+			adoptDevice: async ({ dreameDeviceId, integrationId, name, model }) => {
 				const devices = this.ctx.kernel.devices;
 				if (!devices) throw new Error("dreame adopt: kernel.devices unavailable");
 				const config = {
 					dreameDeviceId,
-					brokerId,
+					brokerId: integrationId,
 					model,
 					system: "dreame",
 					integrationId,
@@ -79711,18 +79649,7 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 		});
 	}
 	globalSettingsSchema() {
-		return this.schema({ sections: [{
-			id: "dreame-broker",
-			title: "Dreame account",
-			description: "Dreame accounts are managed in the External systems → Brokers tab.",
-			columns: 1,
-			fields: [{
-				type: "info",
-				key: "brokerHelp",
-				label: "Accounts are managed separately",
-				content: "This integration links to a Dreamehome account broker. Add, edit, or remove accounts from External systems → Brokers. The integration only stores a reference to its broker — credentials live on the broker."
-			}]
-		}] });
+		return buildConnectionFormSchema();
 	}
 	async supportsManualCreation() {
 		return false;
@@ -79733,28 +79660,24 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 	async onCreateDevice(_type, _config) {
 		throw new Error("Dreame devices are adopted from the cloud, not created manually");
 	}
-	setBrokerDevicesOnline(brokerId, online) {
+	setIntegrationDevicesOnline(integrationId, online) {
 		const reg = this.ctx.kernel.deviceRegistry;
 		if (!reg) return;
-		const n = setBrokerDevicesOnline(reg.getAllForAddon(this.addonId), brokerId, online);
-		if (n > 0) this.ctx.logger.info("Dreame: broker devices " + (online ? "online" : "offline"), { meta: {
-			brokerId,
+		const n = setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), integrationId, online);
+		if (n > 0) this.ctx.logger.info("Dreame: integration devices " + (online ? "online" : "offline"), { meta: {
+			integrationId,
 			count: n
 		} });
 	}
-	requireRegistry() {
-		if (!this.registry) throw new Error("Dreame provider not initialised");
-		return this.registry;
-	}
 };
 //#endregion
 exports.DreameProviderAddon = DreameProviderAddon;
 exports.__toCommonJS = __toCommonJS;
 exports.buildConnectionFormSchema = buildConnectionFormSchema;
 exports.classifyDreameModel = classifyDreameModel;
+exports.connectionFromSettings = connectionFromSettings;
 exports.controlCapForKind = controlCapForKind;
 exports.deviceTypeForKind = deviceTypeForKind;
-exports.dreameAddonConfigSchema = dreameAddonConfigSchema;
 exports.dreameConfigSchema = dreameConfigSchema;
 exports.mapMiotStateToVacuumState = mapMiotStateToVacuumState;
 exports.mapMowerStatusToActivity = mapMowerStatusToActivity;