@camstack/addon-provider-dreo 0.1.5 → 0.1.7

package/dist/addon.js

@@ -4664,7 +4664,7 @@ function _instanceof(cls, params = {}) {
 	return inst;
 }
 //#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";
@@ -6232,6 +6232,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
@@ -9027,7 +9033,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(),
@@ -13626,10 +13632,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"
@@ -13753,9 +13779,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`);
 	}
@@ -14802,83 +14842,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
@@ -15666,7 +15657,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, {
@@ -15681,7 +15675,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()
@@ -18333,6 +18344,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
@@ -20793,6 +20815,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",
@@ -20841,12 +20869,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",
@@ -20997,6 +21043,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",
@@ -21213,6 +21271,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",
@@ -24051,6 +24121,89 @@ object({
 	schemaVersion: literal(1)
 });
 //#endregion
+//#region src/config.ts
+/**
+* Dreo cloud regions the wrapped `@apocaliss92/nodedreo` client accepts. The
+* library does not export a region enum (region is a free `opts.region` string),
+* so we mirror the common Dreo regions locally and validate the operator-supplied
+* value at the system boundary. `us` is the default (the most common Dreo cloud).
+*/
+var DREO_REGIONS = ["us", "eu"];
+var DreoRegionSchema = _enum(DREO_REGIONS);
+/**
+* Operator-supplied Dreo account settings for ONE integration (= one cloud
+* account). The Dreo integration is cloud-only (REST auth + a persistent
+* WebSocket push), so the connection is just account credentials plus a region.
+*/
+var dreoConfigSchema = object({
+	email: string().min(1).describe("Dreo account email"),
+	password: string().min(1).describe("Dreo account password"),
+	region: DreoRegionSchema.default("us").describe("Dreo cloud region")
+});
+/**
+* Split the validated addon config into the two arguments the `Nodedreo`
+* constructor expects (`creds`, `opts`). Pure: same config in → same args out.
+*/
+function toDreoConstructorArgs(config) {
+	return {
+		creds: {
+			email: config.email,
+			password: config.password
+		},
+		opts: { region: config.region }
+	};
+}
+/**
+* Parse an integration's settings into a connection, or null when the mandatory
+* credentials (email + password) are missing. Used by the boot/lifecycle
+* reconcile to skip an integration whose account form was not completed.
+*/
+function connectionFromSettings(settings) {
+	const parsed = dreoConfigSchema.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 Dreo account" modal.
+*/
+function buildConnectionFormSchema() {
+	return { sections: [{
+		id: "credentials",
+		title: "Dreo account",
+		description: "Sign in with your Dreo app account credentials.",
+		columns: 1,
+		fields: [{
+			type: "text",
+			key: "email",
+			label: "Email",
+			required: true,
+			placeholder: "you@example.com"
+		}, {
+			type: "password",
+			key: "password",
+			label: "Password",
+			required: true,
+			showToggle: true
+		}]
+	}, {
+		id: "region",
+		title: "Region",
+		description: "Select the Dreo cloud region your account is registered in.",
+		columns: 1,
+		fields: [{
+			type: "select",
+			key: "region",
+			label: "Region",
+			default: "us",
+			options: DREO_REGIONS.map((r) => ({
+				value: r,
+				label: r.toUpperCase()
+			}))
+		}]
+	}] };
+}
+//#endregion
 //#region ../../node_modules/ws/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var BINARY_TYPES = [
@@ -28896,99 +29049,6 @@ var Nodedreo = class {
 	}
 };
 //#endregion
-//#region src/config.ts
-/**
-* Dreo cloud regions the wrapped `@apocaliss92/nodedreo` client accepts. The
-* library does not export a region enum (region is a free `opts.region` string),
-* so we mirror the common Dreo regions locally and validate the operator-supplied
-* value at the system boundary. `us` is the default (the most common Dreo cloud).
-*/
-var DREO_REGIONS = ["us", "eu"];
-var DreoRegionSchema = _enum(DREO_REGIONS);
-/**
-* Operator-supplied Dreo account settings for ONE broker (= one cloud account).
-* The Dreo integration is cloud-only (REST auth + a persistent WebSocket push),
-* so the connection is just account credentials plus a region.
-*/
-var dreoConfigSchema = object({
-	email: string().min(1).describe("Dreo account email"),
-	password: string().min(1).describe("Dreo account password"),
-	region: DreoRegionSchema.default("us").describe("Dreo cloud region")
-});
-/**
-* Split the validated addon config into the two arguments the `Nodedreo`
-* constructor expects (`creds`, `opts`). Pure: same config in → same args out.
-*/
-function toDreoConstructorArgs(config) {
-	return {
-		creds: {
-			email: config.email,
-			password: config.password
-		},
-		opts: { region: config.region }
-	};
-}
-/** Top-level addon config — an ordered list of broker entries (default empty). */
-var dreoAddonConfigSchema = object({ brokers: array(object({
-	/** Stable opaque identifier — e.g. 'dreo_001', 'dreo_002'. */
-	id: string().min(1),
-	/** Human-readable label shown in the admin UI. */
-	name: string().min(1),
-	/** Validated account connection settings. */
-	connection: dreoConfigSchema,
-	/** 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 settingsToDreoConfig(settings) {
-	return dreoConfigSchema.parse(settings ?? {});
-}
-/**
-* Hand-written connection form for the broker/integration creation UI. Mirrors
-* the Dreame / Homematic broker-settings form shape — a flat set of sections the
-* admin UI renders into the "Add Dreo account" modal.
-*/
-function buildConnectionFormSchema() {
-	return { sections: [{
-		id: "credentials",
-		title: "Dreo account",
-		description: "Sign in with your Dreo app account credentials.",
-		columns: 1,
-		fields: [{
-			type: "text",
-			key: "email",
-			label: "Email",
-			required: true,
-			placeholder: "you@example.com"
-		}, {
-			type: "password",
-			key: "password",
-			label: "Password",
-			required: true,
-			showToggle: true
-		}]
-	}, {
-		id: "region",
-		title: "Region",
-		description: "Select the Dreo cloud region your account is registered in.",
-		columns: 1,
-		fields: [{
-			type: "select",
-			key: "region",
-			label: "Region",
-			default: "us",
-			options: DREO_REGIONS.map((r) => ({
-				value: r,
-				label: r.toUpperCase()
-			}))
-		}]
-	}] };
-}
-//#endregion
 //#region src/dreo-integration-manager.ts
 function defaultFacade(config) {
 	const { creds, opts } = toDreoConstructorArgs(config);
@@ -29146,15 +29206,20 @@ function sameConnection(a, b) {
 //#endregion
 //#region src/dreo-gateway.ts
 /**
-* Per-broker registry that device classes use to reach a live Dreo device
+* Per-integration registry that device classes use to reach a live Dreo device
 * handle (and the discovery info) for a given Dreo account.
 *
+* `mode: account`: keyed by `integrationId`. The string key is generically named
+* `brokerId` in the method signatures below because the device classes pass their
+* persisted `brokerId` config field — which now holds the integrationId
+* (unchanged device-side code, see the addon migration note).
+*
 * The kernel constructs device classes with only a `DeviceContext` — it cannot
 * thread the handle in as a constructor arg. Like the Dreame addon's
 * `dreameFacades`, we keep it simple and in-process: the integration manager
 * owns the connection surface per registered account and publishes it here;
 * device classes resolve their live `BaseDevice` handle by `(brokerId,
-* deviceId)`.
+* deviceId)` where `brokerId` = integrationId.
 */
 var DreoConnectionResolver = class {
 	#surfaces = /* @__PURE__ */ new Map();
@@ -29191,31 +29256,51 @@ var DreoConnectionResolver = class {
 		this.#surfaces.clear();
 	}
 };
-/** The single in-process per-broker connection resolver shared between the
-*  registry/manager and device instances. */
+/** The single in-process per-integration connection resolver shared between the
+*  client registry/manager and device instances (keyed by integrationId). */
 var dreoConnections = new DreoConnectionResolver();
 //#endregion
-//#region src/dreo-broker-registry.ts
+//#region src/dreo-client-registry.ts
+/**
+* Per-integration Dreo connection registry (account mode).
+*
+* Under the LOCKED integration/adoption model (design §7.1), Dreo is a
+* `mode: account` addon: each Dreo integration carries its own Dreo cloud
+* account credentials in its `integration.settings`, and this registry holds one
+* {@link DreoIntegrationManager} per `integrationId`
+* (`Map<integrationId, DreoIntegrationManager>`). Multi-account = multiple
+* integrations; there is NO shared broker.
+*
+* The live Dreo connection surface each manager owns (discovery info + per-device
+* handles) is published on the in-process {@link dreoConnections} resolver KEYED
+* BY `integrationId` — the manager's id IS the integrationId. Device classes
+* resolve their live handle by the `brokerId` config field they persist, which
+* now holds the integrationId (unchanged device-side code, see the addon
+* migration note). The WebSocket push lifecycle stays entirely inside the manager
+* + library (no leak): the registry only starts/stops managers.
+*/
 /**
-* Manages N live Dreo account connections ("brokers"), each backed by a
-* {@link DreoIntegrationManager}. Allocates stable ids (`dreo_001`, …), supports
-* CRUD, an integration FK index for cascade-delete, and lifecycle helpers.
-* Mirrors `DreameBrokerRegistry`.
+* Owns the `Map<integrationId, DreoIntegrationManager>`. Callers reconcile the
+* map against the live integration list on boot + on every integration lifecycle
+* event; device classes + the adoption provider resolve their surface by
+* `integrationId` through {@link dreoConnections}.
+*
+* Structural twin of `DreameClientRegistry` / `WyzeClientRegistry` — `upsert` is
+* session-preserving when credentials are unchanged, `retain` drops vanished
+* integrations.
 */
-var DreoBrokerRegistry = class {
+var DreoClientRegistry = class {
 	#logger;
-	#onBrokerConnected;
-	#onBrokerDisconnected;
+	#onConnected;
+	#onDisconnected;
 	#makeManager;
-	#managers = /* @__PURE__ */ new Map();
-	#integrationToBroker = /* @__PURE__ */ new Map();
-	#nextId = 1;
+	#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.#makeManager = deps.makeManager ?? ((opts) => new DreoIntegrationManager({
-			id: opts.id,
+			id: opts.integrationId,
 			name: opts.name,
 			connection: opts.connection,
 			logger: opts.logger,
@@ -29224,259 +29309,119 @@ var DreoBrokerRegistry = class {
 			surfaceSink: dreoConnections
 		}));
 	}
-	/** 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("DreoBrokerRegistry: 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 WebSocket 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();
+				await existing.manager.applyConnection(connection);
+				this.#entries.set(integrationId, {
+					manager: existing.manager,
+					connection
+				});
 			} catch (err) {
-				this.#logger.warn("DreoBrokerRegistry: shutdown stop failed", {
-					tags: { brokerId: id },
+				this.#logger.warn("DreoClientRegistry: applyConnection failed", {
+					tags: { integrationId },
 					meta: { error: errMsg(err) }
 				});
 			}
-		}));
-		this.#managers.clear();
-		this.#integrationToBroker.clear();
-		dreoConnections.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(`DreoBrokerRegistry: unknown broker id "${id}"`);
-		for (const [integrationId, brokerId] of this.#integrationToBroker.entries()) if (brokerId === id) this.#integrationToBroker.delete(integrationId);
-		this.#managers.delete(id);
+			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("DreoBrokerRegistry: removeEntry stop failed", {
-				tags: { brokerId: id },
+			this.#logger.warn("DreoClientRegistry: manager start failed", {
+				tags: { integrationId },
 				meta: { error: errMsg(err) }
 			});
 		}
 	}
-	async updateEntry(id, connection) {
-		const mgr = this.#managers.get(id);
-		if (!mgr) throw new Error(`DreoBrokerRegistry: unknown broker id "${id}"`);
-		await mgr.applyConnection(connection);
-		return {
-			id,
-			name: mgr.getInfo().name,
-			connection
-		};
+	/** 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);
+		try {
+			await entry.manager.stop();
+		} catch (err) {
+			this.#logger.warn("DreoClientRegistry: remove stop failed", {
+				tags: { integrationId },
+				meta: { error: errMsg(err) }
+			});
+		}
 	}
-	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(`DreoBrokerRegistry: 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("DreoClientRegistry: shutdown stop failed", {
+					tags: { integrationId: id },
+					meta: { error: errMsg(err) }
+				});
+			}
+		}));
+		this.#entries.clear();
+		dreoConnections.clear();
+	}
+	/** 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 = `dreo_${String(this.#nextId).padStart(3, "0")}`;
-		this.#nextId++;
-		return id;
-	}
-	#seedCounter(id) {
-		const match = /^dreo_(\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/dreo-broker-provider.ts
-/** Kind tag registered by this provider — matches the `listProviders` entry. */
-var DREO_KIND = "dreo";
-/**
-* Construct the `broker` cap provider for the Dreo addon. Pure builder: all
-* side-effecting deps are injected so the returned object is unit-testable.
-* Mirrors `buildDreameBrokerProvider`.
-*/
-function buildDreoBrokerProvider(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 !== DREO_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: DREO_KIND,
-				label: "Dreo"
-			}]
-		}],
-		add: async ({ kind, name, settings }) => {
-			if (kind !== DREO_KIND) throw new Error(`provider-dreo: only kind '${DREO_KIND}' is handled here (got '${kind}')`);
-			const entry = await registry.createEntry(name, settingsToDreoConfig(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("dreo: 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 = settingsToDreoConfig(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 !== DREO_KIND) return null;
-			return buildConnectionFormSchema();
-		},
-		testSettings: async ({ kind, settings }) => {
-			if (kind !== DREO_KIND) return {
-				ok: false,
-				error: `unsupported kind: ${kind}`
-			};
-			try {
-				settingsToDreoConfig(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/dreo-domain-mapping.ts
 /** Library device-type strings we treat as a CamStack `fan` kind. */
 var FAN_LIB_TYPES = new Set([
@@ -29598,11 +29543,11 @@ var DEVICES_FILTER = {
 	label: "Devices",
 	isDefault: true
 };
-/** Build a `dreoDeviceId → CamStack deviceId` map for a single broker. */
-async function adoptedMapForBroker(brokerId, listAdoptedDreo) {
+/** Build a `dreoDeviceId → CamStack deviceId` map for a single integration. */
+async function adoptedMapForIntegration(integrationId, listAdoptedDreo) {
 	const all = await listAdoptedDreo();
 	const map = /* @__PURE__ */ new Map();
-	for (const device of all) if (device.config["system"] === "dreo" && device.config["brokerId"] === brokerId) {
+	for (const device of all) if (device.config["system"] === "dreo" && device.config["brokerId"] === integrationId) {
 		const dreoId = device.config["dreoDeviceId"];
 		if (typeof dreoId === "string") map.set(dreoId, device.id);
 	}
@@ -29610,15 +29555,15 @@ async function adoptedMapForBroker(brokerId, listAdoptedDreo) {
 }
 /**
 * Construct the `device-adoption` cap provider for the Dreo addon. Pure builder:
-* all side-effecting deps are injected. Mirrors `buildDreameAdoptionProvider`
-* with a single `devices` granularity (one Container per cloud device).
+* all side-effecting deps are injected. Single `devices` granularity (one
+* Container per cloud device); resolves each account by `integrationId`.
 */
 function buildDreoAdoptionProvider(deps) {
-	const { registry, getBrokerIdForIntegration, listAdoptedDreo, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
-	async function allCandidatesForBroker(brokerId) {
+	const { registry, hasIntegration, listIntegrations, listAdoptedDreo, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
+	async function allCandidatesForIntegration(integrationId) {
 		return buildDreoCandidates({
-			devices: registry.infos(brokerId),
-			adopted: await adoptedMapForBroker(brokerId, listAdoptedDreo)
+			devices: registry.infos(integrationId),
+			adopted: await adoptedMapForIntegration(integrationId, listAdoptedDreo)
 		});
 	}
 	function applyCandidateTextFilter(cands, filterText) {
@@ -29636,7 +29581,7 @@ function buildDreoAdoptionProvider(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),
@@ -29646,13 +29591,12 @@ function buildDreoAdoptionProvider(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 listAdoptedDreo()).filter((d) => d.config["system"] === "dreo").length;
 				return {
 					lastDiscoveryAt: Date.now(),
@@ -29671,9 +29615,8 @@ function buildDreoAdoptionProvider(deps) {
 			}
 		},
 		refresh: async ({ integrationId }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			const candidateCount = (await allCandidatesForBroker(brokerId)).length;
-			const adoptedCount = (await listAdoptedDreo()).filter((d) => d.config["system"] === "dreo" && d.config["brokerId"] === brokerId).length;
+			const candidateCount = (await allCandidatesForIntegration(integrationId)).length;
+			const adoptedCount = (await adoptedMapForIntegration(integrationId, listAdoptedDreo)).size;
 			return {
 				lastDiscoveryAt: Date.now(),
 				candidateCount,
@@ -29682,17 +29625,16 @@ function buildDreoAdoptionProvider(deps) {
 			};
 		},
 		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			if (!registry.has(brokerId)) throw new Error(`dreo adopt: broker ${brokerId} not connected`);
-			const devices = registry.infos(brokerId);
+			if (!registry.has(integrationId)) throw new Error(`dreo adopt: integration ${integrationId} not connected`);
+			const devices = registry.infos(integrationId);
 			const adopted = [];
 			let failures = 0;
 			for (const dreoDeviceId of childNativeIds) try {
 				const dev = devices.find((d) => d.deviceId === dreoDeviceId);
 				if (dev === void 0) {
-					logger.warn("dreo adopt: device not found on broker — skipping", { meta: {
+					logger.warn("dreo adopt: device not found on integration — skipping", { meta: {
 						dreoDeviceId,
-						brokerId
+						integrationId
 					} });
 					failures++;
 					continue;
@@ -29704,7 +29646,7 @@ function buildDreoAdoptionProvider(deps) {
 				if (candidate === void 0) {
 					logger.warn("dreo adopt: device model unsupported — skipping", { meta: {
 						dreoDeviceId,
-						brokerId,
+						integrationId,
 						model: dev.model
 					} });
 					failures++;
@@ -29713,7 +29655,6 @@ function buildDreoAdoptionProvider(deps) {
 				const name = perCandidate?.[dreoDeviceId]?.name ?? dev.name ?? dreoDeviceId;
 				const { deviceId, accessoryDeviceIds } = await adoptDevice({
 					dreoDeviceId,
-					brokerId,
 					integrationId,
 					type: candidate.type,
 					name,
@@ -29727,7 +29668,7 @@ function buildDreoAdoptionProvider(deps) {
 			} catch (err) {
 				logger.warn("dreo adopt: failed to adopt device", { meta: {
 					dreoDeviceId,
-					brokerId,
+					integrationId,
 					error: errMsg(err)
 				} });
 				failures++;
@@ -29742,9 +29683,10 @@ function buildDreoAdoptionProvider(deps) {
 			const cfg = await findDeviceConfig(camDeviceId);
 			if (cfg === null) throw new Error(`dreo resync: device ${camDeviceId} not found`);
 			if (cfg["system"] !== "dreo") throw new Error(`dreo resync: device ${camDeviceId} is not a Dreo device`);
-			const brokerId = String(cfg["brokerId"]);
+			const integrationId = String(cfg["brokerId"]);
 			const dreoDeviceId = String(cfg["dreoDeviceId"]);
-			if (!registry.infos(brokerId).some((d) => d.deviceId === dreoDeviceId)) throw new Error(`dreo resync: device ${dreoDeviceId} no longer present on broker ${brokerId}`);
+			if (!hasIntegration(integrationId)) throw new Error(`dreo resync: integration ${integrationId} not connected`);
+			if (!registry.infos(integrationId).some((d) => d.deviceId === dreoDeviceId)) throw new Error(`dreo resync: device ${dreoDeviceId} no longer present on integration ${integrationId}`);
 			return {
 				changed: false,
 				rebuiltChildren: 0
@@ -29753,29 +29695,31 @@ function buildDreoAdoptionProvider(deps) {
 	};
 }
 //#endregion
-//#region src/dreo-broker-device-cascade.ts
+//#region src/dreo-integration-device-cascade.ts
 /**
 * Remove every adopted Dreo PARENT device (children cascade via the kernel)
-* whose persisted config carries `{ system: 'dreo', 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
-* Dreame cascade helper.
+* whose persisted config carries `{ system: 'dreo', brokerId: integrationId }`.
+* Used when an integration is deleted/disabled. 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"] !== "dreo" || cfg["brokerId"] !== brokerId) continue;
+		if (cfg["system"] !== "dreo" || cfg["brokerId"] !== integrationId) continue;
 		try {
 			await devices.remove(d.id);
 			removed += 1;
 		} catch (err) {
-			logger.warn("dreo: broker cascade-remove failed", {
+			logger.warn("dreo: integration cascade-remove failed", {
 				tags: { deviceId: d.id },
 				meta: {
-					brokerId,
+					integrationId,
 					error: errMsg(err)
 				}
 			});
@@ -29784,20 +29728,21 @@ async function cascadeRemoveDevicesForBroker(input) {
 	return removed;
 }
 //#endregion
-//#region src/dreo-broker-offline.ts
+//#region src/dreo-integration-offline.ts
 /**
-* Set every Dreo device belonging to `brokerId` to the requested online state.
-* `devices` is the addon-scoped device list; every Dreo top-level Container
-* carries `{ system: 'dreo', brokerId }` in its config blob.
+* Set every Dreo device belonging to `integrationId` to the requested online
+* state. `devices` is the addon-scoped device list; every Dreo top-level
+* Container carries `{ system: 'dreo', 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 Dreame offline helper.
+* 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") !== "dreo") 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;
@@ -30343,199 +30288,137 @@ var DreoContainerDevice = class extends BaseDevice$1 {
 };
 //#endregion
 //#region src/addon.ts
-/** Default multi-broker config — a fresh install starts with no accounts. */
-var DEFAULTS = { brokers: [] };
 /**
-* Dreo device-provider addon (multi-account).
+* Dreo device-provider addon — `mode: account` (multi-account, broker-less).
 *
-* Wraps the `@apocaliss92/nodedreo` Dreo cloud client (REST + WebSocket). One
-* registered account = one "broker"; each adopted cloud device becomes a
-* {@link DeviceType.Container} parent that fans out a single typed accessory
-* child (fan / purifier / heater / humidifier). Modelled directly on the Dreame
-* device-provider template: `broker` + `device-adoption` cap providers for
-* connection + adoption, the `device-provider` cap from the base class, and an
-* in-process connection resolver (`dreoConnections`) the device classes read.
+* Wraps the `@apocaliss92/nodedreo` Dreo cloud client (REST + WebSocket). Each
+* Dreo integration carries its own account credentials in its
+* `integration.settings`; the addon holds one {@link DreoIntegrationManager} per
+* `integrationId` in {@link DreoClientRegistry} (`Map<integrationId, manager>`).
+* There is NO shared broker. The live connection surface each manager owns
+* (discovery info + per-device handles) is published on the in-process
+* {@link dreoConnections} resolver KEYED BY `integrationId`.
+*
+* 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 (fan / purifier / heater /
+* humidifier) 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).
 *
 * Placement: hub-only — the Dreo cloud is reached over outbound HTTPS + a
 * persistent WebSocket from a single account session; no LAN proximity matters,
-* so (like Dreame) the broker lives on the hub.
+* so (like Dreame) the connection lives on the hub.
 */
 var DreoProviderAddon = class extends BaseDeviceProvider {
 	addonId = "provider-dreo";
 	providerName = "Dreo";
 	deviceClasses = { [DeviceType.Container]: DreoContainerDevice };
-	registry = null;
+	clients = null;
 	constructor() {
-		super({ ...DEFAULTS });
+		super({});
 	}
 	async onInitialize() {
 		const regs = await super.onInitialize();
-		this.registry = new DreoBrokerRegistry(this.ctx.logger);
-		this.registry.setOnBrokerConnected((brokerId) => {
-			this.ctx.logger.info("Dreo: broker connected", { meta: { brokerId } });
-			this.setBrokerDevicesOnline(brokerId, true);
+		this.clients = new DreoClientRegistry(this.ctx.logger);
+		this.clients.setOnConnected((integrationId) => {
+			this.ctx.logger.info("Dreo: 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("Dreo: provider initialised", { meta: { brokerCount: this.config.brokers.length } });
-		await this.reconcileIntegrationsToBrokers();
+		await this.reconcileIntegrations();
 		this.subscribeIntegrationLifecycle();
-		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 Dreame 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("Dreo 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("Dreo 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("Dreo onConfigChanged: failed to start new broker", { meta: {
-					brokerName: entry.name,
-					error: errMsg(err)
-				} });
-			}
-		}
+		this.ctx.logger.info("Dreo: provider initialised", { meta: { integrationCount: this.requireClients().size() } });
+		return [...regs, {
+			capability: deviceAdoptionCapability,
+			provider: this.buildAdoptionProvider()
+		}];
 	}
 	async onShutdown() {
 		try {
-			await this.registry?.shutdown();
+			await this.clients?.shutdown();
 		} catch (err) {
 			this.ctx.logger.warn("Dreo: provider shutdown error", { meta: { error: errMsg(err) } });
 		}
-		this.registry = null;
+		this.clients = null;
 		await super.onShutdown();
 	}
-	/** Stable id, broker-scoped so two accounts exposing the same device id don't
-	*  collide (mirrors the Dreame broker-scoping). */
+	requireClients() {
+		if (!this.clients) throw new Error("Dreo provider not initialised");
+		return this.clients;
+	}
+	/**
+	* 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 `dreo:${String(config?.["brokerId"] ?? "unknown")}:${String(config?.["dreoDeviceId"] ?? Date.now())}`;
 	}
-	buildBrokerProvider() {
-		return buildDreoBrokerProvider({
-			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 Dreo 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("Dreo 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("Dreo 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("Dreo integration→broker: broker cleanup failed", { meta: {
-					brokerId: id,
+				this.ctx.logger.warn("Dreo 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("Dreo integration→broker reconcile failed", { meta: { error: errMsg(err) } });
+			this.ctx.logger.warn("Dreo 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 buildDreoAdoptionProvider({
 			registry: dreoConnections,
 			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;
-			},
+			hasIntegration: (integrationId) => this.requireClients().has(integrationId),
+			listIntegrations: () => this.requireClients().list(),
 			listAdoptedDreo: async () => {
 				const reg = this.ctx.kernel.deviceRegistry;
 				const devices = this.ctx.kernel.devices;
@@ -30551,12 +30434,12 @@ var DreoProviderAddon = class extends BaseDeviceProvider {
 				}
 				return out;
 			},
-			adoptDevice: async ({ dreoDeviceId, brokerId, integrationId, name, model }) => {
+			adoptDevice: async ({ dreoDeviceId, integrationId, name, model }) => {
 				const devices = this.ctx.kernel.devices;
 				if (!devices) throw new Error("dreo adopt: kernel.devices unavailable");
 				const config = {
 					dreoDeviceId,
-					brokerId,
+					brokerId: integrationId,
 					model,
 					system: "dreo",
 					integrationId,
@@ -30585,18 +30468,7 @@ var DreoProviderAddon = class extends BaseDeviceProvider {
 		});
 	}
 	globalSettingsSchema() {
-		return this.schema({ sections: [{
-			id: "dreo-broker",
-			title: "Dreo account",
-			description: "Dreo 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 Dreo 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;
@@ -30607,19 +30479,15 @@ var DreoProviderAddon = class extends BaseDeviceProvider {
 	async onCreateDevice(_type, _config) {
 		throw new Error("Dreo 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("Dreo: broker devices " + (online ? "online" : "offline"), { meta: {
-			brokerId,
+		const n = setIntegrationDevicesOnline(reg.getAllForAddon(this.addonId), integrationId, online);
+		if (n > 0) this.ctx.logger.info("Dreo: integration devices " + (online ? "online" : "offline"), { meta: {
+			integrationId,
 			count: n
 		} });
 	}
-	requireRegistry() {
-		if (!this.registry) throw new Error("Dreo provider not initialised");
-		return this.registry;
-	}
 };
 //#endregion
 exports.DREO_MAX_FAN_LEVEL = DREO_MAX_FAN_LEVEL;
@@ -30630,8 +30498,8 @@ exports.buildDreoCandidates = buildDreoCandidates;
 exports.capsForKind = capsForKind;
 exports.clampPercent = clampPercent;
 exports.classifyDreoModel = classifyDreoModel;
+exports.connectionFromSettings = connectionFromSettings;
 exports.deviceTypeForKind = deviceTypeForKind;
-exports.dreoAddonConfigSchema = dreoAddonConfigSchema;
 exports.dreoConfigSchema = dreoConfigSchema;
 exports.levelToPercentage = levelToPercentage;
 exports.percentageStep = percentageStep;