@camstack/addon-provider-gree 0.1.8 → 0.1.10

package/dist/addon.js

@@ -4645,7 +4645,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";
@@ -6213,6 +6213,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
@@ -9008,7 +9014,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(),
@@ -13607,10 +13613,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"
@@ -13734,9 +13760,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`);
 	}
@@ -14783,83 +14823,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
@@ -15095,36 +15086,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,
@@ -15647,7 +15621,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, {
@@ -15662,7 +15639,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()
@@ -18314,6 +18308,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
@@ -20774,6 +20779,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",
@@ -20822,12 +20833,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",
@@ -20978,6 +21007,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",
@@ -21194,6 +21235,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",
@@ -24032,77 +24085,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 = (0, dgram.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 = (0, dgram.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");
@@ -24713,191 +24946,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;
@@ -24909,6 +25059,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";
@@ -24925,6 +25077,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() {
@@ -24938,6 +25091,7 @@ var GreeIntegrationManager = class {
 			kind: "gree",
 			status: this.#status,
 			info: {
+				host: this.#connection.host,
 				broadcastAddr: this.#connection.broadcastAddr,
 				deviceCount: this.#deviceCount
 			},
@@ -24946,14 +25100,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";
@@ -24962,18 +25116,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,
@@ -24983,22 +25138,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);
@@ -25006,7 +25163,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;
@@ -25026,7 +25183,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) }
 			});
 		}
@@ -25038,534 +25195,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
@@ -25813,14 +25544,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.
@@ -25860,22 +25604,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,
@@ -25883,7 +25626,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();
@@ -25895,8 +25638,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();
@@ -25904,12 +25660,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();
@@ -25927,7 +25687,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);
@@ -25974,7 +25734,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 }) => {
@@ -26021,7 +25781,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,
@@ -26033,7 +25793,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";
@@ -26043,9 +25893,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([
@@ -26055,7 +25906,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()
 });
@@ -26073,14 +25924,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}`,
@@ -26088,7 +25940,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();
@@ -26126,8 +25978,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();
@@ -26144,6 +26009,7 @@ var GreeToggleDevice = class extends BaseDevice$1 {
 			} });
 			return;
 		}
+		this.detachStateListener();
 		const onState = () => {
 			try {
 				this.recomputeSlice();
@@ -26188,61 +26054,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 } : {}
 			},
@@ -26256,7 +26190,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",
@@ -26292,7 +26226,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 } : {}
 			};
@@ -26307,303 +26241,158 @@ 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
 exports.ADVERTISED_CAP_MODES = ADVERTISED_CAP_MODES;
+exports.DeviceType = DeviceType;
 exports.GREE_FAN_PERCENTAGE_STEP = GREE_FAN_PERCENTAGE_STEP;
 exports.GreeProviderAddon = GreeProviderAddon;
 exports.SUPPORTED_CAP_MODES = SUPPORTED_CAP_MODES;
+exports.bindOnce = bindOnce;
 exports.boolToHorizontalSwing = boolToHorizontalSwing;
 exports.boolToVerticalSwing = boolToVerticalSwing;
 exports.buildConnectionFormSchema = buildConnectionFormSchema;
-exports.buildGreeCandidates = buildGreeCandidates;
 exports.capModeToLibMode = capModeToLibMode;
 exports.fanSpeedToPercentage = fanSpeedToPercentage;
-exports.greeAddonConfigSchema = greeAddonConfigSchema;
+exports.greeAcDeviceSchema = greeAcDeviceSchema;
 exports.greeConfigSchema = greeConfigSchema;
 exports.horizontalSwingToBool = horizontalSwingToBool;
 exports.isAutoFan = isAutoFan;
 exports.libModeToCapMode = libModeToCapMode;
 exports.oscillatingToVerticalSwing = oscillatingToVerticalSwing;
 exports.percentageToFanSpeed = percentageToFanSpeed;
+exports.resolveBroadcastTarget = resolveBroadcastTarget;
+exports.sameConnection = sameConnection;
+exports.settingsToGreeConfig = settingsToGreeConfig;
 exports.swingToOscillating = swingToOscillating;
 exports.toNodegreeOptions = toNodegreeOptions;
 exports.verticalSwingToBool = verticalSwingToBool;