@camstack/addon-provider-gree 0.1.8 → 0.1.10

package/dist/addon.mjs

@@ -4644,7 +4644,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";
@@ -6212,6 +6212,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
@@ -9007,7 +9013,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(),
@@ -13606,10 +13612,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"
@@ -13733,9 +13759,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`);
 	}
@@ -14782,83 +14822,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
@@ -15094,36 +15085,19 @@ var ResyncResultSchema = object({
 	*  provider re-derived the device. 0/absent for a normal incremental re-sync. */
 	removedChildren: number().int().nonnegative().optional()
 });
-var deviceAdoptionCapability = {
-	name: "device-adoption",
-	scope: "system",
-	mode: "singleton",
-	status: {
-		schema: AdoptionStatusSchema,
-		kind: "poll"
-	},
-	methods: {
-		listCandidateFilters: method(object({ integrationId: string() }), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }),
-		listCandidates: method(ListCandidatesInputSchema, ListCandidatesOutputSchema, { auth: "admin" }),
-		getCandidate: method(GetCandidateInputSchema, DiscoveredChildDeviceSchema.nullable(), { auth: "admin" }),
-		refresh: method(object({ integrationId: string() }), AdoptionStatusSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		adopt: method(AdoptInputSchema, AdoptResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		release: method(ReleaseInputSchema, _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		resync: method(ResyncInputSchema, ResyncResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		})
-	}
-};
+method(object({ integrationId: string() }), object({ filters: array(AdoptionFilterSchema) }), { auth: "admin" }), method(ListCandidatesInputSchema, ListCandidatesOutputSchema, { auth: "admin" }), method(GetCandidateInputSchema, DiscoveredChildDeviceSchema.nullable(), { auth: "admin" }), method(object({ integrationId: string() }), AdoptionStatusSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(AdoptInputSchema, AdoptResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(ReleaseInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ResyncInputSchema, ResyncResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
 /**
 * `device-export` — collection cap for addons that export camstack
 * devices to external ecosystems (HomeAssistant via MQTT discovery,
@@ -15646,7 +15620,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, {
@@ -15661,7 +15638,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()
@@ -18313,6 +18307,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
@@ -20773,6 +20778,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",
@@ -20821,12 +20832,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",
@@ -20977,6 +21006,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",
@@ -21193,6 +21234,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",
@@ -24031,77 +24084,257 @@ object({
 	schemaVersion: literal(1)
 });
 //#endregion
-//#region ../../node_modules/@apocaliss92/nodegree/dist/index.js
-var GreeError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "GreeError";
-	}
-};
-var GreeAuthError = class extends GreeError {
-	constructor(message) {
-		super(message);
-		this.name = "GreeAuthError";
-	}
-};
-var GreeTimeoutError = class extends GreeError {
-	constructor(message) {
-		super(message);
-		this.name = "GreeTimeoutError";
-	}
-};
-var GreeTransportError = class extends GreeError {
-	constructor(message) {
-		super(message);
-		this.name = "GreeTransportError";
-	}
-};
-function createDgramSocket() {
-	return new Promise((resolve, reject) => {
-		const socket = createSocket({
-			type: "udp4",
-			reuseAddr: true
-		});
-		socket.once("error", reject);
-		socket.bind(() => {
-			socket.removeListener("error", reject);
-			resolve({
-				send: (data, port, address) => new Promise((res, rej) => socket.send(data, port, address, (err) => err ? rej(err) : res())),
-				onMessage: (handler) => socket.on("message", (data, rinfo) => handler({
-					data,
-					address: rinfo.address,
-					port: rinfo.port
-				})),
-				setBroadcast: (enabled) => socket.setBroadcast(enabled),
-				address: () => socket.address().port,
-				close: () => new Promise((res) => socket.close(() => res()))
-			});
-		});
-	});
-}
-function buildEnvelope(opts) {
-	const env = {
-		t: opts.t,
-		i: opts.bindOrScan ? 1 : 0,
-		uid: 0,
-		cid: "app",
-		pack: opts.pack
+//#region src/config.ts
+/**
+* The AES negotiation modes the wrapped `@apocaliss92/nodegree` client accepts.
+* Mirrors the library's `encryption` 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. `auto` tries V2 (GCM) then V1 (ECB).
+*/
+var GREE_ENCRYPTION_MODES = [
+	"auto",
+	"v1",
+	"v2"
+];
+var GreeEncryptionSchema = _enum(GREE_ENCRYPTION_MODES);
+/**
+* Operator-supplied CONNECTION for ONE Gree air conditioner (standalone mode —
+* the Reolink / Ecowitt pattern). Gree is LOCAL-ONLY (a directed-broadcast bind
+* handshake + per-device AES control over UDP), so the connection carries no
+* credentials — only the AC's LAN address and the UDP tuning knobs. The
+* `broadcastAddr` is the directed target the bind scan is aimed at: point it at
+* the AC's own IP (unicast-directed) or the subnet broadcast (e.g.
+* `192.168.1.255`). Empty = the library's default global broadcast.
+*/
+var greeConfigSchema = object({
+	/** The AC's LAN IP address — the directed-bind target. Required for a manual
+	*  standalone add (the operator types it). */
+	host: string().default("").describe("Air conditioner LAN IP address"),
+	/** Directed broadcast address for the bind scan (e.g. `192.168.1.255`). Empty =
+	*  the library's default global broadcast; when a `host` is set the scan is
+	*  aimed at it directly. */
+	broadcastAddr: string().default("").describe("Directed broadcast address for the bind scan"),
+	/** UDP request timeout in ms. */
+	timeoutMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(500).max(3e4).default(3e3)).describe("UDP request timeout (ms)"),
+	/** Retry count per UDP request. */
+	retries: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(0).max(10).default(3)).describe("Retries per UDP request"),
+	/** AES negotiation mode. */
+	encryption: GreeEncryptionSchema.default("auto").describe("AES cipher negotiation")
+});
+/**
+* Build the `NodegreeOptions` the wrapped client constructor expects from the
+* validated connection. Pure: same config in → same options out. `host` and
+* `broadcastAddr` are NOT constructor options — they are passed to `discover()`
+* per scan — so they are intentionally omitted here.
+*/
+function toNodegreeOptions(config) {
+	return {
+		timeoutMs: config.timeoutMs,
+		retries: config.retries,
+		encryption: config.encryption
 	};
-	if (opts.mac) env.tcid = opts.mac;
-	if (opts.tag) env.tag = opts.tag;
-	return env;
 }
-function packRequest(cipher, opts) {
-	const { pack, tag } = cipher.encrypt(opts.payload);
-	return buildEnvelope({
-		t: opts.t,
-		mac: opts.mac,
-		bindOrScan: opts.bindOrScan,
-		pack,
-		tag
-	});
+/**
+* Coerce a loose settings blob (the manual-creation form values, or a persisted
+* `connection` blob) 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 settingsToGreeConfig(settings) {
+	return greeConfigSchema.parse(settings ?? {});
 }
-function unpackResponse(cipher, raw) {
+/**
+* Persisted config for a Gree AC {@link import('@camstack/types').DeviceType.Container}
+* device. The operator-supplied CONNECTION lives directly on the device (Reolink
+* pattern) — there is no broker registry. The device owns its own live
+* `@apocaliss92/nodegree` client keyed on its own `connectionKey`; its AC +
+* toggle accessory children resolve the bound handle via that key.
+*
+* `greeMac` is the durable device identity (resolved by the create-time bind);
+* `greeIp` is the last-known LAN address; `connectionKey` is the per-device
+* connection-resolver key (the device's own stableId — decoupled from any
+* broker); `connection` is the operator's UDP settings; `system`/`name` are
+* provenance.
+*/
+var greeAcDeviceSchema = object({
+	/** Durable AC identity (MAC, lowercased) resolved by the create-time bind. */
+	greeMac: string().min(1).describe("Gree AC MAC address"),
+	/** Last-known LAN IP (re-bound on each activate). */
+	greeIp: string().optional().describe("Last known LAN IP"),
+	/** Per-device connection-resolver key (the device's own stableId). */
+	connectionKey: string().min(1).describe("Per-device connection resolver key"),
+	/** The operator-supplied UDP connection settings the device's client dials. */
+	connection: greeConfigSchema,
+	system: literal("gree").optional(),
+	integrationId: string().optional(),
+	name: string().optional()
+});
+/**
+* Hand-written connection form for the AC device-creation UI (standalone mode —
+* Reolink pattern). The connection lives on the AC DEVICE config, not in a broker
+* registry. A `name` field is included so the operator names the AC at creation
+* time (mirrors the Reolink / Ecowitt creation form).
+*/
+function buildConnectionFormSchema() {
+	return { sections: [{
+		id: "identity",
+		title: "Air conditioner",
+		description: "Gree air conditioners are controlled directly over your LAN (no cloud). Enter the AC's IP address; CamStack binds to it over UDP.",
+		columns: 1,
+		fields: [{
+			type: "text",
+			key: "name",
+			label: "Name",
+			required: true,
+			placeholder: "Living room AC"
+		}, {
+			type: "text",
+			key: "host",
+			label: "IP address",
+			required: true,
+			placeholder: "192.168.1.50"
+		}]
+	}, {
+		id: "advanced",
+		title: "Advanced (UDP)",
+		columns: 2,
+		fields: [
+			{
+				type: "text",
+				key: "broadcastAddr",
+				label: "Broadcast address (optional)",
+				required: false,
+				placeholder: "192.168.1.255"
+			},
+			{
+				type: "number",
+				key: "timeoutMs",
+				label: "UDP timeout (ms)",
+				min: 500,
+				max: 3e4,
+				default: 3e3
+			},
+			{
+				type: "number",
+				key: "retries",
+				label: "Retries",
+				min: 0,
+				max: 10,
+				default: 3
+			},
+			{
+				type: "select",
+				key: "encryption",
+				label: "Encryption",
+				default: "auto",
+				options: GREE_ENCRYPTION_MODES.map((m) => ({
+					value: m,
+					label: m.toUpperCase()
+				}))
+			}
+		]
+	}] };
+}
+/**
+* Extra params form for a PER-INTEGRATION network scan. Gree's UDP broadcast
+* only reaches the addon node's local subnet; to find ACs on a DIFFERENT subnet
+* (e.g. 192.168.20.x) the operator supplies that subnet's directed-broadcast
+* address (192.168.20.255). Empty = default local-subnet broadcast.
+*/
+function buildDiscoveryParamsFormSchema() {
+	return { sections: [{
+		id: "scan",
+		title: "Scan options",
+		description: "Leave empty to scan the local subnet. To find air conditioners on a different subnet, enter that subnet’s broadcast address (e.g. 192.168.20.255).",
+		columns: 1,
+		fields: [{
+			type: "text",
+			key: "broadcastAddress",
+			label: "Broadcast address",
+			required: false,
+			placeholder: "192.168.20.255"
+		}, {
+			type: "number",
+			key: "timeoutMs",
+			label: "UDP timeout (ms)",
+			min: 500,
+			max: 3e4,
+			default: 3e3
+		}]
+	}] };
+}
+//#endregion
+//#region ../../node_modules/@apocaliss92/nodegree/dist/index.js
+var GreeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GreeError";
+	}
+};
+var GreeAuthError = class extends GreeError {
+	constructor(message) {
+		super(message);
+		this.name = "GreeAuthError";
+	}
+};
+var GreeTimeoutError = class extends GreeError {
+	constructor(message) {
+		super(message);
+		this.name = "GreeTimeoutError";
+	}
+};
+var GreeTransportError = class extends GreeError {
+	constructor(message) {
+		super(message);
+		this.name = "GreeTransportError";
+	}
+};
+function createDgramSocket() {
+	return new Promise((resolve, reject) => {
+		const socket = createSocket({
+			type: "udp4",
+			reuseAddr: true
+		});
+		socket.once("error", reject);
+		socket.bind(() => {
+			socket.removeListener("error", reject);
+			resolve({
+				send: (data, port, address) => new Promise((res, rej) => socket.send(data, port, address, (err) => err ? rej(err) : res())),
+				onMessage: (handler) => socket.on("message", (data, rinfo) => handler({
+					data,
+					address: rinfo.address,
+					port: rinfo.port
+				})),
+				setBroadcast: (enabled) => socket.setBroadcast(enabled),
+				address: () => socket.address().port,
+				close: () => new Promise((res) => socket.close(() => res()))
+			});
+		});
+	});
+}
+function buildEnvelope(opts) {
+	const env = {
+		t: opts.t,
+		i: opts.bindOrScan ? 1 : 0,
+		uid: 0,
+		cid: "app",
+		pack: opts.pack
+	};
+	if (opts.mac) env.tcid = opts.mac;
+	if (opts.tag) env.tag = opts.tag;
+	return env;
+}
+function packRequest(cipher, opts) {
+	const { pack, tag } = cipher.encrypt(opts.payload);
+	return buildEnvelope({
+		t: opts.t,
+		mac: opts.mac,
+		bindOrScan: opts.bindOrScan,
+		pack,
+		tag
+	});
+}
+function unpackResponse(cipher, raw) {
 	if (typeof raw !== "object" || raw === null) throw new GreeTransportError("malformed response");
 	const obj = raw;
 	if (typeof obj.pack !== "string") throw new GreeTransportError("response missing pack");
@@ -24712,191 +24945,108 @@ var Nodegree = class {
 	}
 };
 //#endregion
-//#region src/config.ts
-/**
-* The AES negotiation modes the wrapped `@apocaliss92/nodegree` client accepts.
-* Mirrors the library's `encryption` 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. `auto` tries V2 (GCM) then V1 (ECB).
-*/
-var GREE_ENCRYPTION_MODES = [
-	"auto",
-	"v1",
-	"v2"
-];
-var GreeEncryptionSchema = _enum(GREE_ENCRYPTION_MODES);
-/**
-* Operator-supplied settings for ONE Gree "broker" (= one LAN discovery scope on
-* one node). Gree is LOCAL-ONLY (UDP broadcast discovery + per-device AES
-* control), so a broker carries no credentials — only the broadcast target and
-* the UDP tuning knobs. Each node running the addon owns its own socket; the
-* `broadcastAddr` lets the operator point discovery at the right subnet
-* (directed broadcast) when the node has multiple interfaces.
-*/
-var greeConfigSchema = object({
-	/** Directed broadcast address for discovery (e.g. `192.168.1.255`). Empty =
-	*  the library's default global broadcast. */
-	broadcastAddr: string().default("").describe("Directed broadcast address for discovery"),
-	/** UDP request timeout in ms. */
-	timeoutMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(500).max(3e4).default(3e3)).describe("UDP request timeout (ms)"),
-	/** Retry count per UDP request. */
-	retries: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(0).max(10).default(3)).describe("Retries per UDP request"),
-	/** AES negotiation mode. */
-	encryption: GreeEncryptionSchema.default("auto").describe("AES cipher negotiation")
-});
-/**
-* Build the `NodegreeOptions` the wrapped client constructor expects from the
-* validated addon config. Pure: same config in → same options out. The
-* `broadcastAddr` is NOT a constructor option — it is passed to `discover()` per
-* scan — so it is intentionally omitted here.
-*/
-function toNodegreeOptions(config) {
-	return {
-		timeoutMs: config.timeoutMs,
-		retries: config.retries,
-		encryption: config.encryption
-	};
-}
-/** Top-level addon config — an ordered list of broker entries (default empty). */
-var greeAddonConfigSchema = object({ brokers: array(object({
-	/** Stable opaque identifier — e.g. 'gree_001', 'gree_002'. */
-	id: string().min(1),
-	/** Human-readable label shown in the admin UI. */
-	name: string().min(1),
-	/** Validated discovery-scope settings. */
-	connection: greeConfigSchema,
-	/** 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 settingsToGreeConfig(settings) {
-	return greeConfigSchema.parse(settings ?? {});
-}
-/**
-* Hand-written settings 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 Gree scope" modal.
-*/
-function buildConnectionFormSchema() {
-	return { sections: [{
-		id: "discovery",
-		title: "Gree discovery scope",
-		description: "Gree air conditioners are controlled directly over your LAN (no cloud). Optionally point discovery at a specific subnet broadcast address.",
-		columns: 1,
-		fields: [{
-			type: "text",
-			key: "broadcastAddr",
-			label: "Broadcast address (optional)",
-			required: false,
-			placeholder: "192.168.1.255"
-		}]
-	}, {
-		id: "advanced",
-		title: "Advanced (UDP)",
-		columns: 2,
-		fields: [
-			{
-				type: "number",
-				key: "timeoutMs",
-				label: "UDP timeout (ms)",
-				min: 500,
-				max: 3e4,
-				default: 3e3
-			},
-			{
-				type: "number",
-				key: "retries",
-				label: "Retries",
-				min: 0,
-				max: 10,
-				default: 3
-			},
-			{
-				type: "select",
-				key: "encryption",
-				label: "Encryption",
-				default: "auto",
-				options: GREE_ENCRYPTION_MODES.map((m) => ({
-					value: m,
-					label: m.toUpperCase()
-				}))
-			}
-		]
-	}] };
-}
-//#endregion
 //#region src/gree-gateway.ts
 /** Lowercase a MAC for stable map keying (Gree echoes mixed-case MACs). */
-function macKey$2(mac) {
+function macKey(mac) {
 	return mac.toLowerCase();
 }
 /**
-* Per-broker registry that device classes use to reach a bound Gree AC handle
-* (and the discovery rows) for a given discovery scope.
+* Per-connection registry that device classes use to reach a bound Gree AC handle
+* (and the bind-scan rows) for a given AC device (standalone mode — the
+* connection lives on the AC device, not a broker).
 *
 * 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 broker and publishes it here;
-* device classes resolve their live `AcDevice` handle by `(brokerId, mac)`.
+* thread the handle in as a constructor arg. Like the Ecowitt / Dreame addon's
+* facade resolver, we keep it simple and in-process: the AC device's integration
+* manager owns the connection surface per `connectionKey` (the device's own
+* stableId) and publishes it here; the AC's accessory children resolve their live
+* `AcDevice` handle by `(connectionKey, mac)`.
 */
 var GreeConnectionResolver = class {
 	#surfaces = /* @__PURE__ */ new Map();
-	/** Publish or remove the connection surface for a broker id. `null` removes. */
-	set(brokerId, surface) {
+	/**
+	* Per-connection "surface (re)published" subscribers. An AC accessory child
+	* activates from `restoreDevices` BEFORE its parent's manager finishes the
+	* async bind, so `getDevice` is null at `onActivate` time and its
+	* `stateChanged` listener never attaches → the climate slice stays frozen at
+	* cold-start (`lastFetchedAt: 0`, no temperature). Children subscribe here and
+	* (re)attach + recompute once the handle is published. A plain `Set` has no
+	* listener cap. Mirrors the Ecowitt facade-resolver fan-out.
+	*/
+	#subs = /* @__PURE__ */ new Map();
+	/** Publish or remove the connection surface for a connection key. `null` removes. */
+	set(connectionKey, surface) {
 		if (surface === null) {
-			this.#surfaces.delete(brokerId);
+			this.#surfaces.delete(connectionKey);
 			return;
 		}
-		this.#surfaces.set(brokerId, surface);
+		this.#surfaces.set(connectionKey, surface);
+		const subs = this.#subs.get(connectionKey);
+		if (subs) for (const cb of subs) try {
+			cb();
+		} catch {}
+	}
+	/** Subscribe to surface (re)publish for a connection key. Returns unsubscribe. */
+	onSurface(connectionKey, cb) {
+		let set = this.#subs.get(connectionKey);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#subs.set(connectionKey, set);
+		}
+		set.add(cb);
+		return () => {
+			const current = this.#subs.get(connectionKey);
+			current?.delete(cb);
+			if (current && current.size === 0) this.#subs.delete(connectionKey);
+		};
 	}
-	/** The discovery rows for a broker id, or empty when unknown. */
-	discovered(brokerId) {
-		return this.#surfaces.get(brokerId)?.discovered ?? [];
+	/** The bind-scan rows for a connection key, or empty when unknown. */
+	discovered(connectionKey) {
+		return this.#surfaces.get(connectionKey)?.discovered ?? [];
 	}
-	/** True when the broker has a published surface (i.e. its scope is active). */
-	has(brokerId) {
-		return this.#surfaces.has(brokerId);
+	/** True when the connection has a published surface (i.e. it is bound). */
+	has(connectionKey) {
+		return this.#surfaces.has(connectionKey);
 	}
-	/** The active broker ids (one entry per published surface). */
+	/** The active connection keys (one entry per published surface). */
 	list() {
 		return Array.from(this.#surfaces.keys()).map((id) => ({ id }));
 	}
 	/**
-	* Resolve the bound {@link AcDevice} handle for a `(brokerId, mac)` pair, or
-	* null when the broker is unknown or the AC has not been bound.
+	* Resolve the bound {@link AcDevice} handle for a `(connectionKey, mac)` pair,
+	* or null when the connection is unknown or the AC has not been bound.
 	*/
-	getDevice(brokerId, mac) {
-		return this.#surfaces.get(brokerId)?.handles.get(macKey$2(mac)) ?? null;
+	getDevice(connectionKey, mac) {
+		return this.#surfaces.get(connectionKey)?.handles.get(macKey(mac)) ?? null;
 	}
 	/** Remove all registered surfaces (called on full shutdown). */
 	clear() {
 		this.#surfaces.clear();
+		this.#subs.clear();
 	}
 };
-/** The single in-process per-broker connection resolver shared between the
-*  manager and device instances. */
+/** The single in-process per-connection resolver shared between the AC device's
+*  manager and its accessory children. */
 var greeConnections = new GreeConnectionResolver();
 //#endregion
 //#region src/gree-integration-manager.ts
 function defaultFacade(config) {
 	return new Nodegree(toNodegreeOptions(config));
 }
-var DEFAULT_POLL_INTERVAL_MS = 3e4;
+var DEFAULT_POLL_INTERVAL_MS = 1e4;
 /**
-* Wraps exactly one `@apocaliss92/nodegree` facade (= one LAN discovery scope)
-* with observable status + lifecycle. {@link start} runs a discovery scan and
-* binds (creates) an {@link AcDevice} handle per found AC, publishing the
-* connection surface on the shared resolver and starting per-AC polling.
-* {@link stop} closes the facade; {@link applyConnection} does both atomically
-* when the operator changes the scope settings.
+* Wraps exactly one `@apocaliss92/nodegree` facade bound to a SINGLE Gree AC
+* (standalone mode — the connection lives on the AC device). {@link start} runs a
+* DIRECTED bind scan aimed at the configured `host` (falling back to the
+* `broadcastAddr` / global broadcast), matches the responder for that host,
+* binds (creates) its {@link AcDevice} handle, publishes the connection surface
+* on the shared resolver keyed by the device's `connectionKey`, and starts
+* polling. {@link stop} closes the facade; {@link applyConnection} does both
+* atomically when the operator changes the connection.
 *
-* Mirrors `DreameIntegrationManager`. Binding is best-effort per AC so one
-* offline unit does not fail the whole scope.
+* {@link bindOnce} is the create-time helper: a static one-shot directed scan
+* that returns the AC's durable identity (MAC/ip/name) WITHOUT holding a handle,
+* so `onCreateDevice` can persist the identity before the device exists.
 */
 var GreeIntegrationManager = class {
 	#id;
@@ -24908,6 +25058,8 @@ var GreeIntegrationManager = class {
 	#surfaceSink;
 	#pollIntervalMs;
 	#makeFacade;
+	/** When set, only the responder for this MAC is bound (standalone: one AC). */
+	#expectMac;
 	#facade = null;
 	#handles = /* @__PURE__ */ new Map();
 	#status = "disconnected";
@@ -24924,6 +25076,7 @@ var GreeIntegrationManager = class {
 		this.#surfaceSink = options.surfaceSink;
 		this.#pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
 		this.#makeFacade = options.makeFacade ?? defaultFacade;
+		this.#expectMac = options.expectMac !== void 0 ? macKey(options.expectMac) : null;
 	}
 	/** The connection settings the manager is currently configured with. */
 	getConnection() {
@@ -24937,6 +25090,7 @@ var GreeIntegrationManager = class {
 			kind: "gree",
 			status: this.#status,
 			info: {
+				host: this.#connection.host,
 				broadcastAddr: this.#connection.broadcastAddr,
 				deviceCount: this.#deviceCount
 			},
@@ -24945,14 +25099,14 @@ var GreeIntegrationManager = class {
 		};
 	}
 	/**
-	* Build the facade, run a discovery scan, and bind one handle per found AC
-	* (starting per-AC polling). Publishes the connection surface. Sets `connected`
-	* on success (even with zero ACs — an empty subnet is not an error). Surfaces a
-	* clear bind error on {@link GreeAuthError}.
+	* Build the facade, run a DIRECTED bind scan (aimed at `host`), bind the
+	* responder for the expected AC, and publish the connection surface. Sets
+	* `connected` on a successful bind. Surfaces a clear bind error on
+	* {@link GreeAuthError}.
 	*/
 	async start() {
 		if (this.#facade !== null) {
-			this.#logger.warn("GreeIntegrationManager: start() called while running — stop first", { tags: { brokerId: this.#id } });
+			this.#logger.warn("GreeIntegrationManager: start() called while running — stop first", { tags: { connectionKey: this.#id } });
 			return;
 		}
 		this.#status = "connecting";
@@ -24961,18 +25115,19 @@ var GreeIntegrationManager = class {
 		this.#facade = facade;
 		try {
 			const discovered = await facade.discover(this.#discoverOpts());
+			const matched = this.#selectResponders(discovered);
 			const handles = /* @__PURE__ */ new Map();
-			for (const dev of discovered) try {
+			for (const dev of matched) try {
 				const ac = await facade.createAc({
 					ip: dev.ip,
 					port: dev.port,
 					mac: dev.mac
 				});
 				if (this.#pollIntervalMs > 0) ac.startPolling(this.#pollIntervalMs);
-				handles.set(macKey$2(dev.mac), ac);
+				handles.set(macKey(dev.mac), ac);
 			} catch (err) {
 				this.#logger.warn("GreeIntegrationManager: bind (createAc) failed", {
-					tags: { brokerId: this.#id },
+					tags: { connectionKey: this.#id },
 					meta: {
 						mac: dev.mac,
 						ip: dev.ip,
@@ -24982,22 +25137,24 @@ var GreeIntegrationManager = class {
 			}
 			this.#handles = handles;
 			const surface = {
-				discovered,
+				discovered: matched,
 				handles
 			};
 			this.#surfaceSink.set(this.#id, surface);
 			this.#deviceCount = handles.size;
-			this.#status = "connected";
-			this.#error = null;
+			this.#status = handles.size > 0 ? "connected" : "error";
+			this.#error = handles.size > 0 ? null : "AC not reachable — bind returned no handle";
 			this.#lastCheckedAt = Date.now();
-			this.#onConnected(this.#id);
-			this.#logger.info("GreeIntegrationManager: connected", {
-				tags: { brokerId: this.#id },
-				meta: {
-					discovered: discovered.length,
-					bound: handles.size
-				}
-			});
+			if (handles.size > 0) {
+				this.#onConnected(this.#id);
+				this.#logger.info("GreeIntegrationManager: connected", {
+					tags: { connectionKey: this.#id },
+					meta: {
+						discovered: discovered.length,
+						bound: handles.size
+					}
+				});
+			} else this.#onDisconnected(this.#id);
 		} catch (err) {
 			this.#status = "error";
 			this.#error = err instanceof GreeAuthError ? "device bind failed — check the AC is reachable" : errMsg(err);
@@ -25005,7 +25162,7 @@ var GreeIntegrationManager = class {
 			this.#surfaceSink.set(this.#id, null);
 			this.#onDisconnected(this.#id);
 			this.#logger.warn("GreeIntegrationManager: scan failed", {
-				tags: { brokerId: this.#id },
+				tags: { connectionKey: this.#id },
 				meta: { error: this.#error }
 			});
 			throw err;
@@ -25025,7 +25182,7 @@ var GreeIntegrationManager = class {
 			await facade.close();
 		} catch (err) {
 			this.#logger.warn("GreeIntegrationManager: facade close failed", {
-				tags: { brokerId: this.#id },
+				tags: { connectionKey: this.#id },
 				meta: { error: errMsg(err) }
 			});
 		}
@@ -25037,534 +25194,108 @@ var GreeIntegrationManager = class {
 		this.#connection = conn;
 		await this.start();
 	}
+	/** Keep only the responder(s) this manager should bind: the one matching the
+	*  expected MAC when set, else the one matching the configured host, else all. */
+	#selectResponders(discovered) {
+		if (this.#expectMac !== null) return discovered.filter((d) => macKey(d.mac) === this.#expectMac);
+		const host = this.#connection.host.trim();
+		if (host.length > 0) {
+			const byHost = discovered.filter((d) => d.ip === host);
+			if (byHost.length > 0) return byHost;
+		}
+		return [...discovered];
+	}
 	#discoverOpts() {
 		const out = { timeoutMs: this.#connection.timeoutMs };
-		if (this.#connection.broadcastAddr.length > 0) out.broadcastAddr = this.#connection.broadcastAddr;
+		const broadcast = resolveBroadcastTarget(this.#connection);
+		if (broadcast.length > 0) out.broadcastAddr = broadcast;
 		return out;
 	}
 };
-/** True when two configs are the "same connection" (no facade rebuild needed). */
-function sameConnection(a, b) {
-	if (a === null || b === null) return false;
-	return a.broadcastAddr === b.broadcastAddr && a.timeoutMs === b.timeoutMs && a.retries === b.retries && a.encryption === b.encryption;
+/**
+* Resolve the directed-scan target for a connection: the explicit
+* `broadcastAddr` when set, else the AC `host` (unicast-directed scan), else the
+* empty string (library default global broadcast).
+*/
+function resolveBroadcastTarget(connection) {
+	const broadcast = connection.broadcastAddr.trim();
+	if (broadcast.length > 0) return broadcast;
+	return connection.host.trim();
 }
-//#endregion
-//#region src/gree-broker-registry.ts
 /**
-* Manages N live Gree discovery scopes ("brokers"), each backed by a
-* {@link GreeIntegrationManager}. Allocates stable ids (`gree_001`, …), supports
-* CRUD, an integration FK index for cascade-delete, and lifecycle helpers.
-* Mirrors `DreoBrokerRegistry`.
+* Create-time one-shot directed bind: build a throwaway facade, run a directed
+* scan (aimed at the connection's `host`/`broadcastAddr`), bind the matching
+* responder to prove the AC is reachable and learn its durable identity, then
+* close the facade. Returns the AC's identity (MAC/ip/name/model). Throws when no
+* AC responds or the bind fails — surfaced to the operator in the Add modal.
+*
+* The returned identity is what {@link import('./config.js').greeAcDeviceSchema}
+* persists on the new device; the live per-device manager re-binds on activate.
+*/
+/**
+* One-shot LAN broadcast scan for Gree ACs — the network-discovery pass. Builds a
+* throwaway facade from default (or provided) UDP settings, runs the broadcast,
+* and returns every responder. No bind, no persistence. The provider's
+* `discoverDevices()` maps the responders to adoption candidates.
 */
-var GreeBrokerRegistry = class {
-	#logger;
-	#onBrokerConnected;
-	#onBrokerDisconnected;
-	#makeManager;
-	#managers = /* @__PURE__ */ new Map();
-	#integrationToBroker = /* @__PURE__ */ new Map();
-	#nextId = 1;
-	constructor(logger, deps = {}) {
-		this.#logger = logger;
-		this.#onBrokerConnected = deps.onBrokerConnected ?? (() => void 0);
-		this.#onBrokerDisconnected = deps.onBrokerDisconnected ?? (() => void 0);
-		this.#makeManager = deps.makeManager ?? ((opts) => new GreeIntegrationManager({
-			id: opts.id,
-			name: opts.name,
-			connection: opts.connection,
-			logger: opts.logger,
-			onConnected: opts.onConnected,
-			onDisconnected: opts.onDisconnected,
-			surfaceSink: greeConnections
-		}));
+async function discoverGreeDevices(input) {
+	const connection = settingsToGreeConfig({
+		...input.broadcastAddress ? { broadcastAddr: input.broadcastAddress } : {},
+		...input.timeoutMs ? { timeoutMs: input.timeoutMs } : {}
+	});
+	const facade = (input.makeFacade ?? defaultFacade)(connection);
+	try {
+		const broadcast = resolveBroadcastTarget(connection);
+		const opts = { timeoutMs: connection.timeoutMs };
+		if (broadcast.length > 0) opts.broadcastAddr = broadcast;
+		return await facade.discover(opts);
+	} finally {
+		await facade.close().catch(() => void 0);
 	}
-	/** 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("GreeBrokerRegistry: failed to restore manager", {
-				tags: { brokerId: entry.id },
-				meta: { error: errMsg(err) }
-			});
-		}
-	}
-	/** Stop all managers and clear state. */
-	async shutdown() {
-		const ids = Array.from(this.#managers.keys());
-		await Promise.all(ids.map(async (id) => {
-			try {
-				await this.#managers.get(id)?.stop();
-			} catch (err) {
-				this.#logger.warn("GreeBrokerRegistry: shutdown stop failed", {
-					tags: { brokerId: id },
-					meta: { error: errMsg(err) }
-				});
-			}
-		}));
-		this.#managers.clear();
-		this.#integrationToBroker.clear();
-		greeConnections.clear();
-	}
-	setOnBrokerConnected(cb) {
-		this.#onBrokerConnected = cb;
-	}
-	setOnBrokerDisconnected(cb) {
-		this.#onBrokerDisconnected = cb;
-	}
-	async createEntry(name, connection, opts = {}) {
-		const id = this.#allocateId();
-		const entry = {
-			id,
-			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(`GreeBrokerRegistry: unknown broker id "${id}"`);
-		for (const [integrationId, brokerId] of this.#integrationToBroker.entries()) if (brokerId === id) this.#integrationToBroker.delete(integrationId);
-		this.#managers.delete(id);
+}
+async function bindOnce(input) {
+	const { connection, logger } = input;
+	const facade = (input.makeFacade ?? defaultFacade)(connection);
+	try {
+		const broadcast = resolveBroadcastTarget(connection);
+		const opts = { timeoutMs: connection.timeoutMs };
+		if (broadcast.length > 0) opts.broadcastAddr = broadcast;
+		const discovered = await facade.discover(opts);
+		const host = connection.host.trim();
+		const target = host.length > 0 ? discovered.find((d) => d.ip === host) ?? discovered[0] : discovered[0];
+		if (target === void 0) throw new Error(host.length > 0 ? `no Gree AC responded at ${host}` : "no Gree AC responded to the discovery scan");
+		const ac = await facade.createAc({
+			ip: target.ip,
+			port: target.port,
+			mac: target.mac
+		});
 		try {
-			await mgr.stop();
-		} catch (err) {
-			this.#logger.warn("GreeBrokerRegistry: removeEntry stop failed", {
-				tags: { brokerId: id },
-				meta: { error: errMsg(err) }
-			});
-		}
-	}
-	async updateEntry(id, connection) {
-		const mgr = this.#managers.get(id);
-		if (!mgr) throw new Error(`GreeBrokerRegistry: unknown broker id "${id}"`);
-		await mgr.applyConnection(connection);
+			ac.stopPolling();
+		} catch {}
 		return {
-			id,
-			name: mgr.getInfo().name,
-			connection
+			mac: target.mac,
+			ip: target.ip,
+			port: target.port,
+			name: target.name.length > 0 ? target.name : target.mac,
+			...target.model !== void 0 ? { model: target.model } : {}
 		};
-	}
-	linkIntegration(integrationId, brokerId) {
-		this.#integrationToBroker.set(integrationId, brokerId);
-	}
-	getBrokerIdByIntegrationId(integrationId) {
-		const brokerId = this.#integrationToBroker.get(integrationId);
-		if (brokerId === void 0) throw new Error(`GreeBrokerRegistry: no broker linked for integration id "${integrationId}"`);
-		return brokerId;
-	}
-	list() {
-		return Array.from(this.#managers.values()).map((m) => m.getInfo());
-	}
-	get(id) {
-		return this.#managers.get(id)?.getInfo() ?? null;
-	}
-	getConnection(id) {
-		return this.#managers.get(id)?.getConnection() ?? null;
-	}
-	size() {
-		return this.#managers.size;
-	}
-	connectedCount() {
-		let count = 0;
-		for (const mgr of this.#managers.values()) if (mgr.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 = `gree_${String(this.#nextId).padStart(3, "0")}`;
-		this.#nextId++;
-		return id;
-	}
-	#seedCounter(id) {
-		const match = /^gree_(\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/gree-broker-provider.ts
-/** Kind tag registered by this provider — matches the `listProviders` entry. */
-var GREE_KIND = "gree";
-/**
-* Construct the `broker` cap provider for the Gree addon. Pure builder: all
-* side-effecting deps are injected so the returned object is unit-testable.
-* Mirrors `buildDreoBrokerProvider`.
-*
-* Gree carries no secret — a "broker" is just a LAN discovery scope — so the
-* settings getters expose the connection verbatim (no password redaction).
-*/
-function buildGreeBrokerProvider(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 !== GREE_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: GREE_KIND,
-				label: "Gree"
-			}]
-		}],
-		add: async ({ kind, name, settings }) => {
-			if (kind !== GREE_KIND) throw new Error(`provider-gree: only kind '${GREE_KIND}' is handled here (got '${kind}')`);
-			const entry = await registry.createEntry(name, settingsToGreeConfig(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("gree: 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 };
-		},
-		setSettings: async ({ id, settings }) => {
-			if (!owns(id)) return;
-			if (!getBrokers().find((b) => b.id === id)) return;
-			const parsed = settingsToGreeConfig(settings);
-			const updated = await registry.updateEntry(id, parsed);
-			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 };
-		},
-		getSettingsSchema: async ({ kind }) => {
-			if (kind !== GREE_KIND) return null;
-			return buildConnectionFormSchema();
-		},
-		testSettings: async ({ kind, settings }) => {
-			if (kind !== GREE_KIND) return {
-				ok: false,
-				error: `unsupported kind: ${kind}`
-			};
-			try {
-				settingsToGreeConfig(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/gree-discovery.ts
-/** Lowercase a MAC for stable keying (Gree echoes mixed-case MACs). */
-function macKey$1(mac) {
-	return mac.toLowerCase();
-}
-/**
-* Map Gree discovery rows to adoption candidates — one Thermostat-type candidate
-* per AC. Every discovered AC is a valid candidate (there is no "unsupported"
-* sub-kind — they are all air conditioners). Pure: no network I/O, no side
-* effects. Mirrors `buildDreoCandidates`.
-*/
-function buildGreeCandidates(input) {
-	const out = [];
-	for (const device of input.devices) {
-		const adoptedId = input.adopted.get(macKey$1(device.mac)) ?? null;
-		out.push({
-			childNativeId: macKey$1(device.mac),
-			name: device.name.length > 0 ? device.name : device.mac,
-			type: DeviceType.Thermostat,
-			status: "online",
-			metadata: {
-				serialNumber: device.mac,
-				...device.model !== void 0 ? { model: device.model } : {}
-			},
-			alreadyAdopted: adoptedId !== null,
-			adoptedDeviceId: adoptedId,
-			capabilities: ["climate-control", "fan-control"]
-		});
-	}
-	return out;
-}
-//#endregion
-//#region src/gree-adoption-provider.ts
-/** The single granularity this provider advertises: whole-device adoption. */
-var DEVICES_FILTER = {
-	id: "devices",
-	label: "Devices",
-	isDefault: true
-};
-function macKey(mac) {
-	return mac.toLowerCase();
-}
-/** Build a `mac → CamStack deviceId` map for a single broker. */
-async function adoptedMapForBroker(brokerId, listAdoptedGree) {
-	const all = await listAdoptedGree();
-	const map = /* @__PURE__ */ new Map();
-	for (const device of all) if (device.config["system"] === "gree" && device.config["brokerId"] === brokerId) {
-		const mac = device.config["greeMac"];
-		if (typeof mac === "string") map.set(macKey(mac), device.id);
-	}
-	return map;
-}
-/**
-* Construct the `device-adoption` cap provider for the Gree addon. Pure builder:
-* all side-effecting deps are injected. Mirrors `buildDreoAdoptionProvider` with
-* a single `devices` granularity (one Container per discovered AC).
-*/
-function buildGreeAdoptionProvider(deps) {
-	const { registry, getBrokerIdForIntegration, listAdoptedGree, adoptDevice, removeDevice, findDeviceConfig, logger } = deps;
-	async function allCandidatesForBroker(brokerId) {
-		return buildGreeCandidates({
-			devices: registry.discovered(brokerId),
-			adopted: await adoptedMapForBroker(brokerId, listAdoptedGree)
-		});
-	}
-	function applyCandidateTextFilter(cands, filterText) {
-		let filtered = [...cands];
-		if (filterText === void 0) return filtered;
-		const { search, adoptedOnly, unadoptedOnly } = filterText;
-		if (search !== void 0 && search.length > 0) {
-			const lower = search.toLowerCase();
-			filtered = filtered.filter((c) => c.name.toLowerCase().includes(lower) || (c.metadata.model?.toLowerCase().includes(lower) ?? false) || c.childNativeId.toLowerCase().includes(lower));
-		}
-		if (adoptedOnly === true) filtered = filtered.filter((c) => c.alreadyAdopted);
-		if (unadoptedOnly === true) filtered = filtered.filter((c) => !c.alreadyAdopted);
-		return filtered;
-	}
-	return {
-		listCandidateFilters: async () => ({ filters: [DEVICES_FILTER] }),
-		listCandidates: async ({ integrationId, page, pageSize, filterText }) => {
-			const filtered = applyCandidateTextFilter(await allCandidatesForBroker(await getBrokerIdForIntegration(integrationId)), filterText);
-			const start = (page - 1) * pageSize;
-			return {
-				candidates: filtered.slice(start, start + pageSize),
-				totalCount: filtered.length,
-				page,
-				pageSize
-			};
-		},
-		getCandidate: async ({ integrationId, childNativeId }) => {
-			return (await allCandidatesForBroker(await getBrokerIdForIntegration(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;
-				const adoptedCount = (await listAdoptedGree()).filter((d) => d.config["system"] === "gree").length;
-				return {
-					lastDiscoveryAt: Date.now(),
-					candidateCount,
-					adoptedCount,
-					lastError: null
-				};
-			} catch (err) {
-				logger.warn("gree adoption: getStatus failed", { meta: { error: errMsg(err) } });
-				return {
-					lastDiscoveryAt: null,
-					candidateCount: 0,
-					adoptedCount: 0,
-					lastError: errMsg(err)
-				};
-			}
-		},
-		refresh: async ({ integrationId }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			const candidateCount = (await allCandidatesForBroker(brokerId)).length;
-			const adoptedCount = (await listAdoptedGree()).filter((d) => d.config["system"] === "gree" && d.config["brokerId"] === brokerId).length;
-			return {
-				lastDiscoveryAt: Date.now(),
-				candidateCount,
-				adoptedCount,
-				lastError: null
-			};
-		},
-		adopt: async ({ integrationId, childNativeIds, perCandidate }) => {
-			const brokerId = await getBrokerIdForIntegration(integrationId);
-			if (!registry.has(brokerId)) throw new Error(`gree adopt: broker ${brokerId} not active`);
-			const devices = registry.discovered(brokerId);
-			const adopted = [];
-			let failures = 0;
-			for (const childNativeId of childNativeIds) try {
-				const dev = devices.find((d) => macKey(d.mac) === macKey(childNativeId));
-				if (dev === void 0) {
-					logger.warn("gree adopt: device not found on broker — skipping", { meta: {
-						childNativeId,
-						brokerId
-					} });
-					failures++;
-					continue;
-				}
-				const name = perCandidate?.[childNativeId]?.name ?? dev.name ?? dev.mac;
-				const candidate = buildGreeCandidates({
-					devices: [dev],
-					adopted: /* @__PURE__ */ new Map()
-				})[0];
-				if (candidate === void 0) {
-					failures++;
-					continue;
-				}
-				const { deviceId, accessoryDeviceIds } = await adoptDevice({
-					greeMac: dev.mac,
-					greeIp: dev.ip,
-					brokerId,
-					integrationId,
-					type: candidate.type,
-					name
-				});
-				adopted.push({
-					childNativeId: macKey(childNativeId),
-					parentDeviceId: deviceId,
-					accessoryDeviceIds
-				});
-			} catch (err) {
-				logger.warn("gree adopt: failed to adopt device", { meta: {
-					childNativeId,
-					brokerId,
-					error: errMsg(err)
-				} });
-				failures++;
-			}
-			if (adopted.length === 0 && failures > 0) throw new Error(`gree adopt: all ${failures} adopt(s) failed`);
-			return { adopted };
-		},
-		release: async ({ camDeviceId }) => {
-			await removeDevice(camDeviceId);
-		},
-		resync: async ({ camDeviceId }) => {
-			const cfg = await findDeviceConfig(camDeviceId);
-			if (cfg === null) throw new Error(`gree resync: device ${camDeviceId} not found`);
-			if (cfg["system"] !== "gree") throw new Error(`gree resync: device ${camDeviceId} is not a Gree device`);
-			const brokerId = String(cfg["brokerId"]);
-			const greeMac = String(cfg["greeMac"]);
-			if (!registry.discovered(brokerId).some((d) => macKey(d.mac) === macKey(greeMac))) throw new Error(`gree resync: device ${greeMac} no longer present on broker ${brokerId}`);
-			return {
-				changed: false,
-				rebuiltChildren: 0
-			};
-		}
-	};
-}
-//#endregion
-//#region src/gree-broker-device-cascade.ts
-/**
-* Remove every adopted Gree PARENT device (children cascade via the kernel)
-* whose persisted config carries `{ system: 'gree', 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
-* Dreo cascade helper.
-*/
-async function cascadeRemoveDevicesForBroker(input) {
-	const { reg, devices, addonId, brokerId, 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"] !== "gree" || cfg["brokerId"] !== brokerId) continue;
+	} catch (err) {
+		const message = err instanceof GreeAuthError ? "device bind failed — check the AC is reachable and the encryption mode" : errMsg(err);
+		logger.warn("gree bindOnce failed", { meta: {
+			host: connection.host,
+			error: message
+		} });
+		throw new Error(message);
+	} finally {
 		try {
-			await devices.remove(d.id);
-			removed += 1;
-		} catch (err) {
-			logger.warn("gree: broker cascade-remove failed", {
-				tags: { deviceId: d.id },
-				meta: {
-					brokerId,
-					error: errMsg(err)
-				}
-			});
-		}
+			await facade.close();
+		} catch {}
 	}
-	return removed;
 }
-//#endregion
-//#region src/gree-broker-offline.ts
-/**
-* Set every Gree device belonging to `brokerId` to the requested online state.
-* `devices` is the addon-scoped device list; every Gree top-level Container
-* carries `{ system: 'gree', brokerId }` in its config blob.
-*
-* Churn-free: skips any device already in the target state. Returns the count of
-* devices actually transitioned. Mirrors the Dreo offline helper.
-*/
-function setBrokerDevicesOnline(devices, brokerId, online) {
-	let count = 0;
-	for (const dev of devices) {
-		if (dev.config.get("system") !== "gree") continue;
-		if (dev.config.get("brokerId") !== brokerId) continue;
-		if (dev.online === online) continue;
-		dev.markOnline(online);
-		count += 1;
-	}
-	return count;
+/** True when two configs are the "same connection" (no facade rebuild needed). */
+function sameConnection(a, b) {
+	if (a === null || b === null) return false;
+	return a.host === b.host && a.broadcastAddr === b.broadcastAddr && a.timeoutMs === b.timeoutMs && a.retries === b.retries && a.encryption === b.encryption;
 }
 //#endregion
 //#region src/gree-domain-mapping.ts
@@ -25812,14 +25543,27 @@ var FAN_COLD_START = {
 };
 /**
 * Persisted config every Gree AC accessory child carries. `greeMac` resolves the
-* bound handle from the connection resolver; `brokerId` selects the discovery
-* scope; `system`/`integrationId` are provenance.
+* bound handle from the connection resolver; `connectionKey` selects the parent
+* AC device's live connection (its own stableId); `system`/`integrationId` are
+* provenance.
 */
 var greeAcSchema = object({
 	greeMac: string().min(1).describe("Gree AC MAC address"),
-	brokerId: string().min(1).describe("Registry broker id"),
+	connectionKey: string().min(1).describe("Per-device connection resolver key"),
 	system: literal("gree").optional(),
-	integrationId: string().optional()
+	integrationId: string().optional(),
+	/** Operator filter — HVAC modes exposed in the control UI (subset of the
+	*  model's supported modes). Empty / omitted ⇒ expose all. `off` is always
+	*  exposed (power). */
+	enabledModes: array(string()).optional(),
+	/** Operator filter — fan speeds exposed in the control UI (subset of
+	*  `GREE_FAN_MODES`). Empty / omitted ⇒ expose all. */
+	enabledFanModes: array(string()).optional(),
+	/** Operator filter — expose the vertical-swing toggle. Default true. */
+	exposeVerticalSwing: boolean().optional(),
+	/** Operator filter — expose the horizontal-swing toggle (model-permitting).
+	*  Default true. */
+	exposeHorizontalSwing: boolean().optional()
 });
 /**
 * One Gree air conditioner as a CamStack `Thermostat`-type accessory child.
@@ -25859,22 +25603,21 @@ var GreeAcDevice = class extends BaseDevice$1 {
 	*/
 	get features() {
 		const caps = this.resolveAc()?.capabilities ?? getAcCapabilities();
-		const flags = [
-			DeviceFeature.ClimateFanMode,
-			DeviceFeature.ClimatePreset,
-			DeviceFeature.ClimateSwingVertical
-		];
-		if (caps.horizontalSwing) flags.push(DeviceFeature.ClimateSwingHorizontal);
+		const cfg = this.config.values;
+		const flags = [DeviceFeature.ClimateFanMode, DeviceFeature.ClimatePreset];
+		if (cfg.exposeVerticalSwing ?? true) flags.push(DeviceFeature.ClimateSwingVertical);
+		if (caps.horizontalSwing && (cfg.exposeHorizontalSwing ?? true)) flags.push(DeviceFeature.ClimateSwingHorizontal);
 		return flags;
 	}
 	greeMac;
-	brokerId;
+	connectionKey;
 	stateChangedUnsub = null;
+	surfaceUnsub = null;
 	constructor(ctx) {
 		const persisted = greeAcSchema.parse(ctx.persistedConfig ?? {});
 		super(ctx, greeAcSchema, { type: ctx.deviceMeta.type });
 		this.greeMac = persisted.greeMac;
-		this.brokerId = persisted.brokerId;
+		this.connectionKey = persisted.connectionKey;
 		this.online = true;
 		this.updateSourceInfo({
 			id: this.greeMac,
@@ -25882,7 +25625,7 @@ var GreeAcDevice = class extends BaseDevice$1 {
 		});
 	}
 	resolveAc() {
-		return greeConnections.getDevice(this.brokerId, this.greeMac);
+		return greeConnections.getDevice(this.connectionKey, this.greeMac);
 	}
 	requireAc() {
 		const ac = this.resolveAc();
@@ -25894,8 +25637,21 @@ var GreeAcDevice = class extends BaseDevice$1 {
 		this.registerCaps();
 		this.attachStateListener();
 		this.recomputeSlices();
+		this.surfaceUnsub = greeConnections.onSurface(this.connectionKey, () => {
+			this.attachStateListener();
+			this.recomputeSlices();
+		});
 	}
 	async removeDevice() {
+		this.detachStateListener();
+		if (this.surfaceUnsub) {
+			try {
+				this.surfaceUnsub();
+			} catch {}
+			this.surfaceUnsub = null;
+		}
+	}
+	detachStateListener() {
 		if (this.stateChangedUnsub) {
 			try {
 				this.stateChangedUnsub();
@@ -25903,12 +25659,16 @@ var GreeAcDevice = class extends BaseDevice$1 {
 			this.stateChangedUnsub = null;
 		}
 	}
+	/** Attach the live `stateChanged` listener to the bound AC handle. Idempotent:
+	*  drops any prior listener first, so it is safe to call on every surface
+	*  (re)publish. No-op until the handle is actually bound. */
 	attachStateListener() {
 		const ac = this.resolveAc();
 		if (!ac) {
 			this.ctx.logger.debug("GreeAcDevice: handle not present; no live listener yet", { meta: { greeMac: this.greeMac } });
 			return;
 		}
+		this.detachStateListener();
 		const onState = () => {
 			try {
 				this.recomputeSlices();
@@ -25926,7 +25686,7 @@ var GreeAcDevice = class extends BaseDevice$1 {
 	}
 	registerCaps() {
 		this.ctx.registerNativeCap(climateControlCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CLIMATE_CAP) ?? CLIMATE_COLD_START,
+			getStatus: async () => this.runtimeState.getCapState(CLIMATE_CAP) ?? this.applyClimateFilters(CLIMATE_COLD_START),
 			setMode: async ({ mode }) => {
 				const ac = this.requireAc();
 				const libMode = capModeToLibMode(mode);
@@ -25973,7 +25733,7 @@ var GreeAcDevice = class extends BaseDevice$1 {
 				await ac.setSwingHorizontal(boolToHorizontalSwing(on));
 			}
 		});
-		this.runtimeState.setCapState(CLIMATE_CAP, CLIMATE_COLD_START);
+		this.runtimeState.setCapState(CLIMATE_CAP, this.applyClimateFilters(CLIMATE_COLD_START));
 		this.ctx.registerNativeCap(fanControlCapability, {
 			getStatus: async () => this.runtimeState.getCapState(FAN_CAP) ?? FAN_COLD_START,
 			setPercentage: async ({ percentage }) => {
@@ -26020,7 +25780,7 @@ var GreeAcDevice = class extends BaseDevice$1 {
 			swingHorizontal: ac.capabilities.horizontalSwing ? horizontalSwingToBool(ac.swingHorizontal) : null,
 			lastFetchedAt: now
 		};
-		this.runtimeState.setCapState(CLIMATE_CAP, climateSlice);
+		this.runtimeState.setCapState(CLIMATE_CAP, this.applyClimateFilters(climateSlice));
 		const fanSlice = {
 			percentage: fanSpeedToPercentage(ac.fanSpeed),
 			percentageStep: GREE_FAN_PERCENTAGE_STEP,
@@ -26032,7 +25792,97 @@ var GreeAcDevice = class extends BaseDevice$1 {
 		};
 		this.runtimeState.setCapState(FAN_CAP, fanSlice);
 	}
+	/**
+	* Apply the operator's per-AC exposure filters to a climate slice: narrow
+	* `availableModes` / `availableFanModes` to the enabled subsets (empty ⇒ all;
+	* `off` is always kept) and null out a swing axis the operator has hidden.
+	* Pure — returns a new slice, never mutates the input.
+	*/
+	applyClimateFilters(slice) {
+		const cfg = this.config.values;
+		const enabledModes = cfg.enabledModes;
+		const enabledFanModes = cfg.enabledFanModes;
+		const exposeV = cfg.exposeVerticalSwing ?? true;
+		const exposeH = cfg.exposeHorizontalSwing ?? true;
+		const availableModes = enabledModes && enabledModes.length > 0 ? slice.availableModes.filter((m) => m === "off" || enabledModes.includes(m)) : slice.availableModes;
+		const availableFanModes = enabledFanModes && enabledFanModes.length > 0 ? slice.availableFanModes.filter((f) => enabledFanModes.includes(f)) : slice.availableFanModes;
+		return {
+			...slice,
+			availableModes,
+			availableFanModes,
+			swingVertical: exposeV ? slice.swingVertical : null,
+			swingHorizontal: exposeH ? slice.swingHorizontal : null
+		};
+	}
+	/**
+	* Per-AC exposure form (device-details settings). Lets the operator pick
+	* which modes / fan speeds / swing axes appear in the AC control UI. An empty
+	* multiselect means "expose all". The horizontal-swing toggle is only offered
+	* when the model advertises horizontal swing.
+	*/
+	getSettingsUISchema() {
+		const supportsHSwing = (this.resolveAc()?.capabilities ?? getAcCapabilities()).horizontalSwing;
+		const cfg = this.config.values;
+		const fields = [
+			{
+				type: "multiselect",
+				key: "enabledModes",
+				label: "Modes",
+				description: "Modes shown in the control UI. Empty = all. “Off” is always available.",
+				options: SUPPORTED_CAP_MODES.map((m) => ({
+					value: m,
+					label: titleCase(m)
+				}))
+			},
+			{
+				type: "multiselect",
+				key: "enabledFanModes",
+				label: "Fan speeds",
+				description: "Fan speeds shown in the control UI. Empty = all.",
+				options: GREE_FAN_MODES.map((f) => ({
+					value: f,
+					label: titleCase(f)
+				}))
+			},
+			{
+				type: "boolean",
+				style: "switch",
+				key: "exposeVerticalSwing",
+				label: "Vertical swing",
+				default: true
+			}
+		];
+		if (supportsHSwing) fields.push({
+			type: "boolean",
+			style: "switch",
+			key: "exposeHorizontalSwing",
+			label: "Horizontal swing",
+			default: true
+		});
+		return hydrateSchema({ sections: [{
+			id: "exposure",
+			title: "Exposed controls",
+			description: "Choose which modes, fan speeds and swing axes appear in the air-conditioner control UI.",
+			fields
+		}] }, {
+			enabledModes: cfg.enabledModes ?? [],
+			enabledFanModes: cfg.enabledFanModes ?? [],
+			exposeVerticalSwing: cfg.exposeVerticalSwing ?? true,
+			exposeHorizontalSwing: cfg.exposeHorizontalSwing ?? true
+		});
+	}
+	async applySettingsPatch(patch) {
+		const typed = greeAcSchema.partial().parse(patch);
+		await this.config.setAll(typed);
+		this.recomputeSlices();
+		await this.refreshFeatures();
+	}
 };
+/** 'fan_only' → 'Fan only', 'medium_low' → 'Medium low'. Pure. */
+function titleCase(value) {
+	const spaced = value.replace(/_/g, " ");
+	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
 //#endregion
 //#region src/devices/gree-toggle-device.ts
 var SWITCH_CAP = "switch";
@@ -26042,9 +25892,10 @@ var SWITCH_COLD_START = {
 };
 /**
 * Persisted config every Gree toggle accessory child carries. Mirrors
-* {@link greeAcSchema}: `greeMac` resolves the bound handle, `brokerId` selects
-* the discovery scope, `system`/`integrationId` are provenance. `toggle` selects
-* which of the four boolean device flags this child drives.
+* {@link greeAcSchema}: `greeMac` resolves the bound handle, `connectionKey`
+* selects the parent AC device's live connection, `system`/`integrationId` are
+* provenance. `toggle` selects which of the four boolean device flags this child
+* drives.
 */
 var greeToggleSchema = object({
 	toggle: _enum([
@@ -26054,7 +25905,7 @@ var greeToggleSchema = object({
 		"freshAir"
 	]).describe("Which Gree boolean flag"),
 	greeMac: string().min(1).describe("Gree AC MAC address"),
-	brokerId: string().min(1).describe("Registry broker id"),
+	connectionKey: string().min(1).describe("Per-device connection resolver key"),
 	system: literal("gree").optional(),
 	integrationId: string().optional()
 });
@@ -26072,14 +25923,15 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 	features = [];
 	toggle;
 	greeMac;
-	brokerId;
+	connectionKey;
 	stateChangedUnsub = null;
+	surfaceUnsub = null;
 	constructor(ctx) {
 		const persisted = greeToggleSchema.parse(ctx.persistedConfig ?? {});
 		super(ctx, greeToggleSchema, { type: ctx.deviceMeta.type });
 		this.toggle = persisted.toggle;
 		this.greeMac = persisted.greeMac;
-		this.brokerId = persisted.brokerId;
+		this.connectionKey = persisted.connectionKey;
 		this.online = true;
 		this.updateSourceInfo({
 			id: `${this.greeMac}:${this.toggle}`,
@@ -26087,7 +25939,7 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 		});
 	}
 	resolveAc() {
-		return greeConnections.getDevice(this.brokerId, this.greeMac);
+		return greeConnections.getDevice(this.connectionKey, this.greeMac);
 	}
 	requireAc() {
 		const ac = this.resolveAc();
@@ -26125,8 +25977,21 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 		this.registerCap();
 		this.attachStateListener();
 		this.recomputeSlice();
+		this.surfaceUnsub = greeConnections.onSurface(this.connectionKey, () => {
+			this.attachStateListener();
+			this.recomputeSlice();
+		});
 	}
 	async removeDevice() {
+		this.detachStateListener();
+		if (this.surfaceUnsub) {
+			try {
+				this.surfaceUnsub();
+			} catch {}
+			this.surfaceUnsub = null;
+		}
+	}
+	detachStateListener() {
 		if (this.stateChangedUnsub) {
 			try {
 				this.stateChangedUnsub();
@@ -26143,6 +26008,7 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 			} });
 			return;
 		}
+		this.detachStateListener();
 		const onState = () => {
 			try {
 				this.recomputeSlice();
@@ -26187,61 +26053,129 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 //#endregion
 //#region src/devices/gree-container-device.ts
 /**
-* Persisted config for a Gree Container (the parent of one AC). `greeMac`
-* resolves the bound handle from the connection resolver; `greeIp` is the last
-* known LAN address (re-bound on each scope start); `brokerId` selects the
-* discovery scope; `integrationId` is stamped onto the child; `system`/`name`
-* are provenance.
-*/
-var greeContainerSchema = object({
-	greeMac: string().min(1).describe("Gree AC MAC address"),
-	greeIp: string().optional().describe("Last known LAN IP"),
-	brokerId: string().min(1).describe("Registry broker id"),
-	integrationId: string().optional(),
-	system: literal("gree").optional(),
-	name: string().optional()
-});
-/**
-* Parent Container device for a single Gree AC. Owns no control caps itself — it
-* declares `getAccessoryChildren()` so the kernel auto-spawns the single
-* {@link GreeAcDevice} accessory child (Thermostat) and reconciles it across
-* reboots. Mirrors `DreoContainerDevice`.
+* Standalone-mode parent Container device for a single Gree AC (Reolink /
+* Ecowitt pattern). The operator-supplied CONNECTION lives on THIS device's
+* config; the device OWNS exactly one live `@apocaliss92/nodegree` client (via a
+* {@link GreeIntegrationManager}) keyed on its own `connectionKey` and published
+* on the in-process {@link greeConnections} resolver so its AC + toggle accessory
+* children read the live bound handle. There is NO broker and NO device-adoption
+* cap.
 *
-* A Gree AC = one Thermostat child carrying both `climate-control` and
-* `fan-control` caps, plus presence-gated `DeviceType.Switch` children for the
-* panel-light / X-Fan / health / fresh-air boolean flags (mirroring the HA Gree
-* integration's separate switch entities). Capability presence is resolved from
-* the bound handle's `AcCapabilities` (or model defaults when no live handle).
+* It owns no control caps itself — it declares `getAccessoryChildren()` so the
+* kernel auto-spawns the single {@link GreeAcDevice} accessory child (Thermostat,
+* carrying `climate-control` + `fan-control` with the swing entities) plus
+* presence-gated {@link DeviceType.Switch} children for the panel-light / X-Fan /
+* health / fresh-air boolean flags (mirroring the HA Gree integration).
+* Capability presence is resolved from the bound handle's `AcCapabilities` (or
+* model defaults when no live handle).
 */
 var GreeContainerDevice = class extends BaseDevice$1 {
 	features = [DeviceFeature.Resyncable];
 	greeMac;
-	brokerId;
+	connectionKey;
 	integrationId;
+	connection;
+	manager = null;
 	constructor(ctx) {
-		const cfg = greeContainerSchema.parse(ctx.persistedConfig ?? {});
-		super(ctx, greeContainerSchema, { type: DeviceType.Container });
+		const cfg = greeAcDeviceSchema.parse(ctx.persistedConfig ?? {});
+		super(ctx, greeAcDeviceSchema, { type: DeviceType.Container });
 		this.greeMac = cfg.greeMac;
-		this.brokerId = cfg.brokerId;
+		this.connectionKey = cfg.connectionKey;
 		this.integrationId = cfg.integrationId;
-		this.online = greeConnections.getDevice(this.brokerId, this.greeMac) !== null;
+		this.connection = cfg.connection;
+		this.online = greeConnections.getDevice(this.connectionKey, this.greeMac) !== null;
 		this.updateSourceInfo({
 			id: this.greeMac,
 			system: "gree"
 		});
 	}
+	/** Adopt a pre-built manager (created by `onCreateDevice` so the live client
+	*  binds once at create time) — mirrors `EcowittGatewayDevice.adoptManager`. */
+	adoptManager(manager) {
+		this.manager = manager;
+	}
+	async onActivate() {
+		await super.onActivate();
+		if (this.manager === null) this.ensureManager().catch((err) => {
+			this.ctx.logger.warn("Gree AC initial bind failed", { meta: {
+				greeMac: this.greeMac,
+				error: errMsg(err)
+			} });
+		});
+	}
+	async removeDevice() {
+		const mgr = this.manager;
+		this.manager = null;
+		if (mgr) try {
+			await mgr.stop();
+		} catch (err) {
+			this.ctx.logger.warn("Gree AC: client stop failed", { meta: {
+				greeMac: this.greeMac,
+				error: errMsg(err)
+			} });
+		}
+	}
+	async applySettingsPatch(patch) {
+		if (!("connection" in patch)) return;
+		const parsed = greeAcDeviceSchema.shape.connection.parse(patch["connection"]);
+		await this.config.setAll({ connection: parsed });
+		this.connection = parsed;
+		const mgr = this.manager;
+		if (mgr) try {
+			await mgr.applyConnection(parsed);
+		} catch (err) {
+			this.ctx.logger.warn("Gree AC: applyConnection failed", { meta: {
+				greeMac: this.greeMac,
+				error: errMsg(err)
+			} });
+		}
+		else await this.ensureManager().catch((err) => {
+			this.ctx.logger.warn("Gree AC re-bind after settings change failed", { meta: {
+				greeMac: this.greeMac,
+				error: errMsg(err)
+			} });
+		});
+	}
+	/** Build + start the per-device nodegree client (if not already running). */
+	async ensureManager() {
+		if (this.manager !== null) return;
+		const mgr = new GreeIntegrationManager({
+			id: this.connectionKey,
+			name: this.name,
+			connection: this.connection,
+			logger: this.ctx.logger,
+			onConnected: () => this.setAcOnline(true),
+			onDisconnected: () => this.setAcOnline(false),
+			surfaceSink: greeConnections,
+			expectMac: this.greeMac
+		});
+		this.manager = mgr;
+		await mgr.start();
+	}
+	setAcOnline(online) {
+		if (this.online === online) return;
+		this.markOnline(online);
+		this.setChildrenOnline(online).catch(() => {});
+	}
+	async setChildrenOnline(online) {
+		const children = await this.ctx.devices.getChildren(this.id).catch(() => []);
+		for (const child of children) {
+			if (child.online === online) continue;
+			child.markOnline(online);
+		}
+	}
 	getAccessoryChildren() {
 		return [{
 			stableIdSuffix: "ac",
 			meta: {
-				type: DeviceType.Thermostat,
+				type: DeviceType.Climate,
 				name: this.name,
 				linkDeviceId: this.id,
 				...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
 			},
 			config: {
 				greeMac: this.greeMac,
-				brokerId: this.brokerId,
+				connectionKey: this.connectionKey,
 				system: "gree",
 				...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
 			},
@@ -26255,7 +26189,7 @@ var GreeContainerDevice = class extends BaseDevice$1 {
 	* defaults when no live handle is bound yet).
 	*/
 	toggleChildren() {
-		const caps = greeConnections.getDevice(this.brokerId, this.greeMac)?.capabilities ?? DEFAULT_AC_CAPABILITIES;
+		const caps = greeConnections.getDevice(this.connectionKey, this.greeMac)?.capabilities ?? DEFAULT_AC_CAPABILITIES;
 		return [
 			{
 				toggle: "light",
@@ -26291,7 +26225,7 @@ var GreeContainerDevice = class extends BaseDevice$1 {
 			const childConfig = {
 				toggle: d.toggle,
 				greeMac: this.greeMac,
-				brokerId: this.brokerId,
+				connectionKey: this.connectionKey,
 				system: "gree",
 				...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
 			};
@@ -26306,284 +26240,135 @@ var GreeContainerDevice = class extends BaseDevice$1 {
 };
 //#endregion
 //#region src/addon.ts
-/** Default multi-broker config — a fresh install starts with no scopes. */
-var DEFAULTS = { brokers: [] };
 /**
-* Gree device-provider addon (multi-scope).
+* Gree air-conditioner device-provider addon — `mode: standalone` (the Reolink /
+* Ecowitt pattern). No broker, no device-adoption cap. An AC is added as a DEVICE
+* via the manual-creation form: the CONNECTION (host IP + optional broadcastAddr
+* + UDP tuning) lives on the AC DEVICE config. `onCreateDevice` runs a DIRECTED
+* bind against the given host to learn the AC's durable identity (MAC) and prove
+* reachability, then creates a {@link GreeContainerDevice} that OWNS its own live
+* `@apocaliss92/nodegree` client and fans out its Thermostat + toggle accessory
+* children (climate-control with swing entities + the panel-light / X-Fan /
+* health / fresh-air switches — all preserved from the broker model).
 *
-* Wraps the `@apocaliss92/nodegree` local-UDP client. One registered LAN
-* discovery scope = one "broker"; each adopted AC becomes a
-* {@link DeviceType.Container} parent that fans out a single {@link DeviceType.Thermostat}
-* accessory child carrying `climate-control` + `fan-control`. Modelled directly
-* on the Dreo / 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 (`greeConnections`) the device
-* classes read.
+* `instanceMode: multiple` — many ACs may be added. Placement: any-node — Gree is
+* LOCAL UDP; the addon runs on whichever node shares the AC's subnet.
 *
-* Placement: any-node — Gree is LOCAL UDP. Discovery (broadcast) and per-AC AES
-* control packets must reach the AC on the LAN, so the addon is eligible to run
-* on whichever node shares the AC's subnet (vs hub-only for the cloud providers).
-* The operator points each scope's `broadcastAddr` at the right subnet.
+* LAN UDP-broadcast auto-discovery is implemented via the `device-provider`
+* discovery surface (`supportsDiscovery`/`discoverDevices`/`adoptDiscoveredDevice`)
+* — the same one ONVIF uses and the aggregated "Scan network" modal fans out to.
+* Manual add-one-AC-by-IP (directed bind) remains available in parallel.
 */
 var GreeProviderAddon = class extends BaseDeviceProvider {
 	addonId = "provider-gree";
 	providerName = "Gree";
 	deviceClasses = { [DeviceType.Container]: GreeContainerDevice };
-	registry = null;
 	constructor() {
-		super({ ...DEFAULTS });
+		super({});
 	}
-	async onInitialize() {
-		const regs = await super.onInitialize();
-		this.registry = new GreeBrokerRegistry(this.ctx.logger);
-		this.registry.setOnBrokerConnected((brokerId) => {
-			this.ctx.logger.info("Gree: broker connected", { meta: { brokerId } });
-			this.setBrokerDevicesOnline(brokerId, true);
+	async supportsDiscovery() {
+		return true;
+	}
+	async getDiscoveryParamsSchema() {
+		return buildDiscoveryParamsFormSchema();
+	}
+	async discoverDevices(input) {
+		const broadcastAddress = typeof input?.params?.["broadcastAddress"] === "string" ? input.params["broadcastAddress"].trim() : void 0;
+		const timeoutMs = typeof input?.params?.["timeoutMs"] === "number" ? input.params["timeoutMs"] : void 0;
+		const responders = await discoverGreeDevices({
+			...broadcastAddress ? { broadcastAddress } : {},
+			...timeoutMs ? { timeoutMs } : {}
 		});
-		this.registry.setOnBrokerDisconnected((brokerId) => {
-			this.setBrokerDevicesOnline(brokerId, false);
+		this.ctx.logger.info("Gree discovery complete", { meta: {
+			count: responders.length,
+			broadcastAddress: broadcastAddress ?? "local"
+		} });
+		return responders.map((d) => {
+			const displayName = d.name.length > 0 ? d.name : d.mac;
+			return {
+				stableId: `gree:${macKey(d.mac)}`,
+				type: DeviceType.Container,
+				suggestedName: displayName,
+				prefilledConfig: {
+					name: displayName,
+					host: d.ip,
+					...d.model !== void 0 ? { model: d.model } : {}
+				}
+			};
 		});
-		await this.registry.restore(this.config.brokers);
-		this.ctx.logger.info("Gree: provider initialised", { meta: { brokerCount: this.config.brokers.length } });
-		await this.reconcileIntegrationsToBrokers();
-		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 Dreo 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("Gree 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("Gree 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("Gree onConfigChanged: failed to start new broker", { meta: {
-					brokerName: entry.name,
-					error: errMsg(err)
-				} });
-			}
-		}
+	async adoptDiscoveredDevice(input) {
+		return this.createDevice({
+			type: DeviceType.Container,
+			config: input.candidate.prefilledConfig
+		});
 	}
-	async onShutdown() {
-		try {
-			await this.registry?.shutdown();
-		} catch (err) {
-			this.ctx.logger.warn("Gree: provider shutdown error", { meta: { error: errMsg(err) } });
-		}
-		this.registry = null;
-		await super.onShutdown();
+	async supportsManualCreation() {
+		return true;
 	}
-	/** Stable id, broker-scoped so two scopes exposing the same MAC don't collide. */
-	generateStableId(_type, config) {
-		return `gree:${String(config?.["brokerId"] ?? "unknown")}:${String(config?.["greeMac"] ?? Date.now())}`;
-	}
-	buildBrokerProvider() {
-		return buildGreeBrokerProvider({
-			ownerAddonId: this.ctx.id,
-			registry: this.requireRegistry(),
-			getBrokers: () => this.config.brokers,
-			persistBrokers: (brokers) => this.updateGlobalSettings({ brokers: [...brokers] }),
-			cascadeRemoveDevices: (brokerId) => this.cascadeRemoveDevicesForBroker(brokerId),
+	async onGetCreationSchema(type) {
+		if (type !== DeviceType.Container) return null;
+		return buildConnectionFormSchema();
+	}
+	async onCreateDevice(type, config) {
+		if (type !== DeviceType.Container) throw new Error(`Gree provider does not support device type: ${type}`);
+		const name = typeof config["name"] === "string" ? config["name"].trim() : "";
+		if (!name) throw new Error("Air conditioner name is required");
+		const connection = settingsToGreeConfig(config);
+		if (connection.host.trim().length === 0) throw new Error("Air conditioner IP address is required");
+		const bound = await bindOnce({
+			connection,
 			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
+		const connectionKey = `gree:${macKey(bound.mac)}`;
+		const deviceConfig = {
+			greeMac: macKey(bound.mac),
+			greeIp: bound.ip,
+			connectionKey,
+			connection,
+			system: "gree",
+			name
+		};
+		const manager = new GreeIntegrationManager({
+			id: connectionKey,
+			name,
+			connection,
+			logger: this.ctx.logger,
+			onConnected: () => void 0,
+			onDisconnected: () => void 0,
+			surfaceSink: greeConnections,
+			expectMac: bound.mac
 		});
-	}
-	/**
-	* Link each surviving integration (carrying `{ brokerId }` in its settings) to
-	* its broker so the generic `device-adoption` cap resolves the scope, 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.
-	*/
-	async reconcileIntegrationsToBrokers() {
 		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("Gree integration→broker: linked broker not found", { meta: {
-						integrationId: integration.id,
-						brokerId
-					} });
-					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);
-			} catch (err) {
-				this.ctx.logger.warn("Gree integration→broker: broker cleanup failed", { meta: {
-					brokerId: id,
-					error: errMsg(err)
-				} });
-			}
-			const nextBrokers = this.config.brokers.filter((b) => !toRemove.includes(b.id));
-			await this.updateGlobalSettings({ brokers: nextBrokers });
+			await manager.start();
 		} catch (err) {
-			this.ctx.logger.warn("Gree integration→broker reconcile failed", { meta: { error: errMsg(err) } });
+			this.ctx.logger.warn("Gree create: initial client start failed — device kept", { meta: {
+				connectionKey,
+				error: errMsg(err)
+			} });
 		}
-	}
-	subscribeIntegrationLifecycle() {
-		const handler = (event) => {
-			const addonId = event.data["addonId"];
-			if (typeof addonId === "string" && addonId !== this.ctx.id) return;
-			this.reconcileIntegrationsToBrokers();
-		};
-		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationEnabled }, handler);
-		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDisabled }, handler);
-		this.ctx.eventBus.subscribe({ category: EventCategory.IntegrationDeleted }, handler);
-	}
-	buildAdoptionProvider() {
-		return buildGreeAdoptionProvider({
-			registry: greeConnections,
-			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;
-			},
-			listAdoptedGree: async () => {
-				const reg = this.ctx.kernel.deviceRegistry;
-				const devices = this.ctx.kernel.devices;
-				if (!reg || !devices) return [];
-				const out = [];
-				for (const d of reg.getAllForAddon(this.addonId)) {
-					if (d.parentDeviceId !== null) continue;
-					const config = await devices.loadConfig(d.id).catch(() => ({}));
-					out.push({
-						id: d.id,
-						config
-					});
-				}
-				return out;
-			},
-			adoptDevice: async ({ greeMac, greeIp, brokerId, integrationId, name }) => {
-				const devices = this.ctx.kernel.devices;
-				if (!devices) throw new Error("gree adopt: kernel.devices unavailable");
-				const config = {
-					greeMac,
-					greeIp,
-					brokerId,
-					system: "gree",
-					integrationId,
-					name
-				};
-				const stableId = this.generateStableId(DeviceType.Container, config);
-				const device = await devices.create(stableId, GreeContainerDevice, config, null, {
-					type: DeviceType.Container,
-					name,
-					integrationId
-				});
-				const children = await devices.getChildren(device.id);
-				return {
-					deviceId: device.id,
-					accessoryDeviceIds: children.map((c) => c.id)
-				};
-			},
-			removeDevice: async (id) => {
-				await this.ctx.kernel.devices?.remove(id);
+		return {
+			meta: {
+				type: DeviceType.Container,
+				name
 			},
-			findDeviceConfig: async (id) => {
-				const devices = this.ctx.kernel.devices;
-				if (!devices) return null;
-				return devices.loadConfig(id).catch(() => null);
+			config: deviceConfig,
+			onAfterCreate: async (device) => {
+				if (device instanceof GreeContainerDevice) device.adoptManager(manager);
 			}
-		});
-	}
-	globalSettingsSchema() {
-		return this.schema({ sections: [{
-			id: "gree-broker",
-			title: "Gree discovery scope",
-			description: "Gree scopes are managed in the External systems → Brokers tab.",
-			columns: 1,
-			fields: [{
-				type: "info",
-				key: "brokerHelp",
-				label: "Scopes are managed separately",
-				content: "This integration links to a Gree LAN discovery scope. Add, edit, or remove scopes from External systems → Brokers. Gree is local-only (UDP) — no cloud account is needed; a scope just stores the broadcast address + UDP settings."
-			}]
-		}] });
-	}
-	async supportsManualCreation() {
-		return false;
-	}
-	async onGetCreationSchema(_type) {
-		return null;
-	}
-	async onCreateDevice(_type, _config) {
-		throw new Error("Gree devices are adopted via LAN discovery, not created manually");
-	}
-	setBrokerDevicesOnline(brokerId, 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("Gree: broker devices " + (online ? "online" : "offline"), { meta: {
-			brokerId,
-			count: n
-		} });
+		};
 	}
-	requireRegistry() {
-		if (!this.registry) throw new Error("Gree provider not initialised");
-		return this.registry;
+	/**
+	* AC stableId — derived from the AC's durable MAC identity (resolved by the
+	* create-time bind), NOT a broker id. Re-adding the same physical AC reuses its
+	* persisted row. Falls back to a timestamp only when no MAC is resolvable
+	* (should not happen — `onCreateDevice` binds first).
+	*/
+	generateStableId(_type, config) {
+		const mac = config?.["greeMac"];
+		if (typeof mac === "string" && mac.length > 0) return `gree:${macKey(mac)}`;
+		return `gree:${Date.now()}`;
 	}
 };
 //#endregion
-export { GreeProviderAddon, greeAddonConfigSchema as _, boolToVerticalSwing as a, horizontalSwingToBool as c, oscillatingToVerticalSwing as d, percentageToFanSpeed as f, buildConnectionFormSchema as g, buildGreeCandidates as h, boolToHorizontalSwing as i, isAutoFan as l, verticalSwingToBool as m, GREE_FAN_PERCENTAGE_STEP as n, capModeToLibMode as o, swingToOscillating as p, SUPPORTED_CAP_MODES as r, fanSpeedToPercentage as s, ADVERTISED_CAP_MODES as t, libModeToCapMode as u, greeConfigSchema as v, toNodegreeOptions as y };
+export { DeviceType as C, GreeProviderAddon, toNodegreeOptions as S, sameConnection as _, boolToVerticalSwing as a, greeConfigSchema as b, horizontalSwingToBool as c, oscillatingToVerticalSwing as d, percentageToFanSpeed as f, resolveBroadcastTarget as g, bindOnce as h, boolToHorizontalSwing as i, isAutoFan as l, verticalSwingToBool as m, GREE_FAN_PERCENTAGE_STEP as n, capModeToLibMode as o, swingToOscillating as p, SUPPORTED_CAP_MODES as r, fanSpeedToPercentage as s, ADVERTISED_CAP_MODES as t, libModeToCapMode as u, buildConnectionFormSchema as v, settingsToGreeConfig as x, greeAcDeviceSchema as y };