@camstack/addon-provider-ecowitt 0.1.9 → 0.1.10

package/dist/addon.js

@@ -4,6 +4,7 @@ var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).expor
 //#endregion
 let http = require("http");
 let events = require("events");
+let dgram = require("dgram");
 //#region ../../node_modules/zod/v4/core/core.js
 var _a$1;
 function $constructor(name, initializer, params) {
@@ -4647,7 +4648,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";
@@ -6215,6 +6216,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
@@ -9010,7 +9017,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(),
@@ -13609,10 +13616,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"
@@ -13736,9 +13763,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`);
 	}
@@ -15583,7 +15624,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, {
@@ -15598,7 +15642,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()
@@ -20721,6 +20782,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",
@@ -20769,12 +20836,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",
@@ -20925,6 +21010,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",
@@ -21141,6 +21238,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",
@@ -23979,183 +24088,6 @@ object({
 	schemaVersion: literal(1)
 });
 //#endregion
-//#region src/config.ts
-/**
-* Operator-supplied Ecowitt gateway settings for ONE broker (= one station).
-* Two transports behind a `transport` discriminator:
-*
-* - `local` (local-poll): the addon polls the gateway over HTTP (`host`/`port`/
-*   optional `password`, with poll + mapping intervals).
-* - `listener` (push): the addon runs an HTTP server the gateway uploads to
-*   (the gateway's "Customized" upload must point at the hub's LAN IP:port).
-*
-* Local-poll is the recommended default — it has no inbound-IP constraint.
-*/
-var baseFields = { 
-/** Human-overridable station identity used to scope the adopted gateway. */
-stationId: string().default("").describe("Optional stable station id (auto-derived when blank)") };
-var ecowittConfigSchema = discriminatedUnion("transport", [object({
-	transport: literal("local"),
-	host: string().min(1).describe("Ecowitt gateway host name or IP address"),
-	port: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1).max(65535).default(80)).describe("Gateway HTTP port"),
-	password: string().default("").describe("Gateway password (optional — newer firmware)"),
-	pollIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1e3).max(36e5).default(6e4)).describe("Live-data poll interval (ms)"),
-	mappingIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1e4).max(864e5).default(6e5)).describe("Sensor-map refresh interval (ms)"),
-	...baseFields
-}), object({
-	transport: literal("listener"),
-	listenPort: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1).max(65535).default(4199)).describe("Local TCP port the gateway uploads to"),
-	listenHost: string().default("").describe("Optional bind host (blank = all interfaces)"),
-	...baseFields
-})]);
-/**
-* Narrow an `unknown` value to a shallow-cloned plain object record, or an empty
-* record when it is not a plain object. Mirrors the Homematic `toRecord` helper —
-* a cast-free boundary narrowing.
-*/
-function toRecord(value) {
-	if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.fromEntries(Object.entries(value));
-	return {};
-}
-/** Coerce a loose settings blob through the connection schema, applying defaults.
-*  A blob with no `transport` defaults to `local` for back-compat with simple forms. */
-function settingsToEcowittConfig(settings) {
-	const raw = toRecord(settings);
-	if (raw["transport"] !== "local" && raw["transport"] !== "listener") raw["transport"] = "local";
-	return ecowittConfigSchema.parse(raw);
-}
-/**
-* Persisted config for an Ecowitt gateway {@link import('@camstack/types').DeviceType.Hub}
-* device. The operator-supplied CONNECTION lives directly on the device (Reolink
-* pattern) — there is no broker registry. The gateway owns its own live nodewitt
-* client keyed on its own `stableId`; group Container children reference it via
-* their `gatewayId` config field.
-*/
-var ecowittGatewaySchema = object({
-	/** The transport + endpoint the gateway's live client dials / binds. */
-	connection: ecowittConfigSchema,
-	/** Provenance marker used to scope offline / cascade helpers. */
-	system: literal("ecowitt-gateway").optional()
-});
-/**
-* Hand-written connection form for the gateway device-creation UI (standalone
-* mode — Reolink pattern). The connection lives on the gateway DEVICE config,
-* not in a broker registry. A `name` field is included so the operator names
-* the gateway Hub at creation time (mirrors the Reolink creation form).
-*/
-function buildConnectionFormSchema() {
-	return { sections: [
-		{
-			id: "identity",
-			title: "Gateway",
-			columns: 1,
-			fields: [{
-				type: "text",
-				key: "name",
-				label: "Name",
-				required: true,
-				placeholder: "Weather station"
-			}]
-		},
-		{
-			id: "transport",
-			title: "Transport",
-			description: "Choose how CamStack reads the gateway. Local poll connects out to the gateway (recommended). Push listener runs a server the gateway uploads to — configure the gateway \"Customized\" upload to point at this hub.",
-			columns: 1,
-			fields: [{
-				type: "select",
-				key: "transport",
-				label: "Transport",
-				default: "local",
-				options: [{
-					value: "local",
-					label: "Local poll (recommended)"
-				}, {
-					value: "listener",
-					label: "Push listener"
-				}]
-			}]
-		},
-		{
-			id: "local",
-			title: "Local poll settings",
-			columns: 2,
-			fields: [
-				{
-					type: "text",
-					key: "host",
-					label: "Gateway host / IP",
-					placeholder: "192.168.1.50",
-					showWhen: {
-						field: "transport",
-						equals: "local"
-					}
-				},
-				{
-					type: "number",
-					key: "port",
-					label: "HTTP port",
-					min: 1,
-					max: 65535,
-					default: 80,
-					showWhen: {
-						field: "transport",
-						equals: "local"
-					}
-				},
-				{
-					type: "password",
-					key: "password",
-					label: "Password (optional)",
-					showToggle: true,
-					showWhen: {
-						field: "transport",
-						equals: "local"
-					}
-				},
-				{
-					type: "number",
-					key: "pollIntervalMs",
-					label: "Poll interval (ms)",
-					min: 1e3,
-					max: 36e5,
-					default: 6e4,
-					showWhen: {
-						field: "transport",
-						equals: "local"
-					}
-				}
-			]
-		},
-		{
-			id: "listener",
-			title: "Push listener settings",
-			columns: 2,
-			fields: [{
-				type: "number",
-				key: "listenPort",
-				label: "Listen port",
-				min: 1,
-				max: 65535,
-				default: 4199,
-				showWhen: {
-					field: "transport",
-					equals: "listener"
-				}
-			}, {
-				type: "text",
-				key: "listenHost",
-				label: "Bind host (optional)",
-				placeholder: "all interfaces",
-				showWhen: {
-					field: "transport",
-					equals: "listener"
-				}
-			}]
-		}
-	] };
-}
-//#endregion
 //#region node_modules/undici/lib/core/symbols.js
 var require_symbols$4 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
@@ -45073,6 +45005,101 @@ var TypedEmitter = class {
 		return this;
 	}
 };
+var CMD_BROADCAST = 18;
+var DISCOVERY_PORT = 46e3;
+function buildScanPacket() {
+	const size = 3;
+	const checksum = CMD_BROADCAST + size & 255;
+	return Buffer.from([
+		255,
+		255,
+		CMD_BROADCAST,
+		size,
+		checksum
+	]);
+}
+function verifyChecksum(buf) {
+	if (buf.length < 4) return false;
+	let sum = 0;
+	for (let i = 2; i < buf.length - 1; i += 1) sum = sum + (buf[i] ?? 0) & 255;
+	return sum === buf[buf.length - 1];
+}
+function parseBroadcastResponse(buf) {
+	if (buf.length < 18) return null;
+	if (buf[0] !== 255 || buf[1] !== 255 || buf[2] !== CMD_BROADCAST) return null;
+	if (!verifyChecksum(buf)) return null;
+	const mac = macFromBytes(buf.subarray(5, 11));
+	const tcpPort = buf.readUInt16BE(15);
+	const ssidLen = buf[17] ?? 0;
+	const ssidEnd = Math.min(18 + ssidLen, buf.length - 1);
+	const { module, model, firmware } = splitSsid(buf.subarray(18, ssidEnd).toString("ascii").trim());
+	return {
+		mac,
+		module,
+		model,
+		firmware,
+		tcpPort
+	};
+}
+function macFromBytes(bytes) {
+	return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join(":");
+}
+function splitSsid(ssid) {
+	const spaceIdx = ssid.indexOf(" ");
+	const module = spaceIdx >= 0 ? ssid.slice(0, spaceIdx) : ssid;
+	const firmwareRaw = spaceIdx >= 0 ? ssid.slice(spaceIdx + 1).trim() : "";
+	const wifiIdx = module.indexOf("-WIFI");
+	return {
+		module,
+		model: wifiIdx > 0 ? module.slice(0, wifiIdx) : void 0,
+		firmware: firmwareRaw.length > 0 ? firmwareRaw : void 0
+	};
+}
+function discoverGateways(socket, opts) {
+	const port = opts?.port ?? DISCOVERY_PORT;
+	const broadcastAddr = opts?.broadcastAddr ?? "255.255.255.255";
+	const timeoutMs = opts?.timeoutMs ?? 3e3;
+	const byMac = /* @__PURE__ */ new Map();
+	socket.onMessage((m) => {
+		const frame = parseBroadcastResponse(m.data);
+		if (frame === null) return;
+		byMac.set(frame.mac, {
+			ip: m.address,
+			mac: frame.mac,
+			name: frame.module.length > 0 ? frame.module : frame.mac,
+			...frame.model !== void 0 ? { model: frame.model } : {},
+			...frame.firmware !== void 0 ? { firmware: frame.firmware } : {}
+		});
+	});
+	socket.setBroadcast(true);
+	const scan = buildScanPacket();
+	return new Promise((resolve) => {
+		socket.send(scan, port, broadcastAddr);
+		setTimeout(() => resolve([...byMac.values()]), timeoutMs);
+	});
+}
+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),
+				close: () => new Promise((res) => socket.close(() => res()))
+			});
+		});
+	});
+}
 function toError(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
@@ -45097,6 +45124,21 @@ var Ecowitt = class _Ecowitt {
 		return _Ecowitt.#buildListener(defaultListenerBuilder(options));
 	}
 	/**
+	* Discover Ecowitt gateways on the network via the `CMD_BROADCAST` UDP probe (port 46000). Opens a
+	* throwaway UDP socket, sweeps the broadcast address (local subnet by default, or a directed
+	* broadcast passed via {@link DiscoverOptions.broadcastAddr} for another subnet), collects
+	* responders deduped by MAC, and closes the socket. No `Ecowitt` instance or connection is
+	* created — the caller maps the results to whatever onboarding flow it uses.
+	*/
+	static async discover(options) {
+		const socket = await createDgramSocket();
+		try {
+			return await discoverGateways(socket, options);
+		} finally {
+			await socket.close().catch(() => void 0);
+		}
+	}
+	/**
 	* Build a local-transport facade from a transport builder. The wiring closure that hands the
 	* builder its `onReadings`/`onError` callbacks lives HERE, inside the class, so it can call the
 	* `#`-private ingest seams directly — no public method, no cast. `#`-private so it is unreachable
@@ -45302,6 +45344,219 @@ objectType({
 	})
 });
 //#endregion
+//#region src/config.ts
+/**
+* Operator-supplied Ecowitt gateway settings for ONE broker (= one station).
+* Two transports behind a `transport` discriminator:
+*
+* - `local` (local-poll): the addon polls the gateway over HTTP (`host`/`port`/
+*   optional `password`, with poll + mapping intervals).
+* - `listener` (push): the addon runs an HTTP server the gateway uploads to
+*   (the gateway's "Customized" upload must point at the hub's LAN IP:port).
+*
+* Local-poll is the recommended default — it has no inbound-IP constraint.
+*/
+var baseFields = { 
+/** Human-overridable station identity used to scope the adopted gateway. */
+stationId: string().default("").describe("Optional stable station id (auto-derived when blank)") };
+var ecowittConfigSchema = discriminatedUnion("transport", [object({
+	transport: literal("local"),
+	host: string().min(1).describe("Ecowitt gateway host name or IP address"),
+	port: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1).max(65535).default(80)).describe("Gateway HTTP port"),
+	password: string().default("").describe("Gateway password (optional — newer firmware)"),
+	pollIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1e3).max(36e5).default(6e4)).describe("Live-data poll interval (ms)"),
+	mappingIntervalMs: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1e4).max(864e5).default(6e5)).describe("Sensor-map refresh interval (ms)"),
+	...baseFields
+}), object({
+	transport: literal("listener"),
+	listenPort: preprocess((v) => v === "" || v === null ? void 0 : v, number().int().min(1).max(65535).default(4199)).describe("Local TCP port the gateway uploads to"),
+	listenHost: string().default("").describe("Optional bind host (blank = all interfaces)"),
+	...baseFields
+})]);
+/**
+* Narrow an `unknown` value to a shallow-cloned plain object record, or an empty
+* record when it is not a plain object. Mirrors the Homematic `toRecord` helper —
+* a cast-free boundary narrowing.
+*/
+function toRecord(value) {
+	if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.fromEntries(Object.entries(value));
+	return {};
+}
+/** Coerce a loose settings blob through the connection schema, applying defaults.
+*  A blob with no `transport` defaults to `local` for back-compat with simple forms. */
+function settingsToEcowittConfig(settings) {
+	const raw = toRecord(settings);
+	if (raw["transport"] !== "local" && raw["transport"] !== "listener") raw["transport"] = "local";
+	return ecowittConfigSchema.parse(raw);
+}
+/**
+* Persisted config for an Ecowitt gateway {@link import('@camstack/types').DeviceType.Hub}
+* device. The operator-supplied CONNECTION lives directly on the device (Reolink
+* pattern) — there is no broker registry. The gateway owns its own live nodewitt
+* client keyed on its own `stableId`; group Container children reference it via
+* their `gatewayId` config field.
+*/
+var ecowittGatewaySchema = object({
+	/** The transport + endpoint the gateway's live client dials / binds. */
+	connection: ecowittConfigSchema,
+	/** Provenance marker used to scope offline / cascade helpers. */
+	system: literal("ecowitt-gateway").optional()
+});
+/**
+* Hand-written connection form for the gateway device-creation UI (standalone
+* mode — Reolink pattern). The connection lives on the gateway DEVICE config,
+* not in a broker registry. A `name` field is included so the operator names
+* the gateway Hub at creation time (mirrors the Reolink creation form).
+*/
+function buildConnectionFormSchema() {
+	return { sections: [
+		{
+			id: "identity",
+			title: "Gateway",
+			columns: 1,
+			fields: [{
+				type: "text",
+				key: "name",
+				label: "Name",
+				required: true,
+				placeholder: "Weather station"
+			}]
+		},
+		{
+			id: "transport",
+			title: "Transport",
+			description: "Choose how CamStack reads the gateway. Local poll connects out to the gateway (recommended). Push listener runs a server the gateway uploads to — configure the gateway \"Customized\" upload to point at this hub.",
+			columns: 1,
+			fields: [{
+				type: "select",
+				key: "transport",
+				label: "Transport",
+				default: "local",
+				options: [{
+					value: "local",
+					label: "Local poll (recommended)"
+				}, {
+					value: "listener",
+					label: "Push listener"
+				}]
+			}]
+		},
+		{
+			id: "local",
+			title: "Local poll settings",
+			columns: 2,
+			fields: [
+				{
+					type: "text",
+					key: "host",
+					label: "Gateway host / IP",
+					placeholder: "192.168.1.50",
+					showWhen: {
+						field: "transport",
+						equals: "local"
+					}
+				},
+				{
+					type: "number",
+					key: "port",
+					label: "HTTP port",
+					min: 1,
+					max: 65535,
+					default: 80,
+					showWhen: {
+						field: "transport",
+						equals: "local"
+					}
+				},
+				{
+					type: "password",
+					key: "password",
+					label: "Password (optional)",
+					showToggle: true,
+					showWhen: {
+						field: "transport",
+						equals: "local"
+					}
+				},
+				{
+					type: "number",
+					key: "pollIntervalMs",
+					label: "Poll interval (ms)",
+					min: 1e3,
+					max: 36e5,
+					default: 6e4,
+					showWhen: {
+						field: "transport",
+						equals: "local"
+					}
+				}
+			]
+		},
+		{
+			id: "listener",
+			title: "Push listener settings",
+			columns: 2,
+			fields: [{
+				type: "number",
+				key: "listenPort",
+				label: "Listen port",
+				min: 1,
+				max: 65535,
+				default: 4199,
+				showWhen: {
+					field: "transport",
+					equals: "listener"
+				}
+			}, {
+				type: "text",
+				key: "listenHost",
+				label: "Bind host (optional)",
+				placeholder: "all interfaces",
+				showWhen: {
+					field: "transport",
+					equals: "listener"
+				}
+			}]
+		}
+	] };
+}
+/**
+* Slugify a host / station id into a readable, stable row-key fragment. Exported so the discovery
+* candidate's `stableId` matches exactly what `generateStableId` derives on adopt (else a re-scan of
+* an already-added gateway would not be detected as onboarded).
+*/
+function slugifyHost(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+* Extra per-scan inputs for Ecowitt network discovery. Mirrors Gree's scan form. On a flat network,
+* leave blank to sweep the addon node's local subnet. Gateways on ANOTHER subnet usually can't be
+* reached by a directed broadcast (most routers don't forward it) — enter the gateway's IP instead:
+* the `CMD_BROADCAST` probe answers a unicast just as well and returns the gateway's identity.
+*/
+function buildDiscoveryParamsFormSchema() {
+	return { sections: [{
+		id: "scan",
+		title: "Scan options",
+		description: "Leave empty to scan the local subnet. To find a gateway on a different subnet, enter that subnet’s broadcast address (e.g. 192.168.20.255) or the gateway’s IP directly (e.g. 192.168.20.181).",
+		columns: 1,
+		fields: [{
+			type: "text",
+			key: "broadcastAddress",
+			label: "Broadcast address or gateway IP",
+			required: false,
+			placeholder: "192.168.20.255"
+		}, {
+			type: "number",
+			key: "timeoutMs",
+			label: "UDP timeout (ms)",
+			min: 500,
+			max: 3e4,
+			default: 3e3
+		}]
+	}] };
+}
+//#endregion
 //#region src/ecowitt-integration-manager.ts
 /** Build the real nodewitt facade for a transport. Pure. */
 function defaultEcowittFacadeFactory(config) {
@@ -45458,6 +45713,15 @@ var EcowittIntegrationManager = class {
 */
 var EcowittFacadeResolver = class {
 	#facades = /* @__PURE__ */ new Map();
+	/**
+	* Per-gateway snapshot fan-out. Container + sensor children subscribe here
+	* instead of attaching directly to the nodewitt facade's EventEmitter — a
+	* station with >10 sensors would otherwise trip Node's default MaxListeners
+	* cap (one listener per child on a single emitter). The gateway device pumps
+	* this bus once per snapshot from its single facade subscription; a plain
+	* `Set` of callbacks has no listener limit.
+	*/
+	#snapshotSubs = /* @__PURE__ */ new Map();
 	/** Publish or remove the client for a gateway id. `null` removes the entry. */
 	set(gatewayId, facade) {
 		if (facade === null) {
@@ -45466,6 +45730,28 @@ var EcowittFacadeResolver = class {
 		}
 		this.#facades.set(gatewayId, facade);
 	}
+	/** Subscribe a child to per-gateway snapshot ticks. Returns an unsubscribe fn. */
+	onSnapshot(gatewayId, cb) {
+		let set = this.#snapshotSubs.get(gatewayId);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#snapshotSubs.set(gatewayId, set);
+		}
+		set.add(cb);
+		return () => {
+			const current = this.#snapshotSubs.get(gatewayId);
+			current?.delete(cb);
+			if (current && current.size === 0) this.#snapshotSubs.delete(gatewayId);
+		};
+	}
+	/** Fan a single facade snapshot out to every subscribed child for a gateway. */
+	emitSnapshot(gatewayId) {
+		const set = this.#snapshotSubs.get(gatewayId);
+		if (!set) return;
+		for (const cb of set) try {
+			cb();
+		} catch {}
+	}
 	/** The live client for a gateway id, or null when unknown / stopped. */
 	get(gatewayId) {
 		return this.#facades.get(gatewayId) ?? null;
@@ -45481,6 +45767,7 @@ var EcowittFacadeResolver = class {
 	/** Remove all registered clients (called on full shutdown). */
 	clear() {
 		this.#facades.clear();
+		this.#snapshotSubs.clear();
 	}
 };
 /** The single in-process per-gateway client resolver shared between the gateway
@@ -45693,13 +45980,14 @@ function deviceGroupForSensor(category, channel) {
 //#endregion
 //#region src/ecowitt-discovery.ts
 /**
-* The native id a group Container candidate is keyed on:
-* `ecowitt:<gatewayId>:<group>`. One physical gateway therefore yields THREE
-* candidates (one per {@link EcowittDeviceGroup}). Mirrors the persisted stable
-* id the group Container's `stableIdSuffix` derives for the same Container.
+* The native id a group Container candidate is keyed on: `<gatewayId>:<group>`.
+* `gatewayId` is the gateway Hub's stableId, which ALREADY carries the `ecowitt:`
+* prefix (see `addon.ts` generateStableId) — so this must NOT re-add it, else the
+* id double-prefixes to `ecowitt:ecowitt:<gw>:<group>`. One physical gateway
+* yields THREE candidates (one per {@link EcowittDeviceGroup}).
 */
 function groupNativeId(gatewayId, group) {
-	return `ecowitt:${gatewayId}:${group}`;
+	return `${gatewayId}:${group}`;
 }
 /** A preview accessory child for one sensor. */
 function sensorChild(sensor) {
@@ -45836,9 +46124,6 @@ var EcowittSensorDevice = class extends BaseDevice {
 			system: "ecowitt"
 		});
 	}
-	get facade() {
-		return ecowittFacades.get(this.gatewayId);
-	}
 	resolveSensor() {
 		return ecowittFacades.getSensor(this.gatewayId, this.sensorId);
 	}
@@ -45857,13 +46142,12 @@ var EcowittSensorDevice = class extends BaseDevice {
 			this.snapshotUnsub = null;
 		}
 	}
-	/** Attach a facade `snapshot` listener that recomputes this sensor's slice. */
+	/** Subscribe to per-gateway snapshot ticks (recompute this sensor's slice).
+	*  Uses the resolver's shared fan-out bus rather than the facade EventEmitter
+	*  directly, so N sensors on one gateway never trip Node's MaxListeners cap.
+	*  Works even before the facade exists — `recomputeSlice` no-ops on a missing
+	*  sensor and replays once the gateway pumps the first snapshot. */
 	attachSnapshotListener() {
-		const facade = this.facade;
-		if (!facade) {
-			this.ctx.logger.debug("EcowittSensorDevice: facade not present; no live listener yet", { meta: { sensorId: this.sensorId } });
-			return;
-		}
 		const onSnapshot = () => {
 			try {
 				this.recomputeSlice();
@@ -45874,10 +46158,7 @@ var EcowittSensorDevice = class extends BaseDevice {
 				} });
 			}
 		};
-		facade.on("snapshot", onSnapshot);
-		this.snapshotUnsub = () => {
-			facade.off("snapshot", onSnapshot);
-		};
+		this.snapshotUnsub = ecowittFacades.onSnapshot(this.gatewayId, onSnapshot);
 	}
 	/** Recompute + write this sensor's typed cap slice (+ battery) from the live reading. */
 	recomputeSlice() {
@@ -46223,6 +46504,7 @@ var EcowittGatewayDevice = class extends BaseDevice {
 		this.reconcileGroupSensors(sensors).catch((err) => {
 			this.ctx.logger.warn("Ecowitt gateway: sensor reconcile failed", { meta: { error: errMsg(err) } });
 		});
+		ecowittFacades.emitSnapshot(this.stableId);
 	}
 	registerDeviceDiscovery() {
 		this.ctx.registerNativeCap(deviceDiscoveryCapability, {
@@ -46429,7 +46711,43 @@ var EcowittProviderAddon = class extends BaseDeviceProvider {
 		super({});
 	}
 	async supportsDiscovery() {
-		return false;
+		return true;
+	}
+	async getDiscoveryParamsSchema() {
+		return buildDiscoveryParamsFormSchema();
+	}
+	async discoverDevices(input) {
+		const broadcastAddr = typeof input?.params?.["broadcastAddress"] === "string" ? input.params["broadcastAddress"].trim() : "";
+		const timeoutMs = typeof input?.params?.["timeoutMs"] === "number" ? input.params["timeoutMs"] : void 0;
+		const gateways = await Ecowitt.discover({
+			...broadcastAddr.length > 0 ? { broadcastAddr } : {},
+			...timeoutMs !== void 0 ? { timeoutMs } : {}
+		});
+		this.ctx.logger.info("Ecowitt discovery complete", { meta: {
+			count: gateways.length,
+			broadcastAddr: broadcastAddr.length > 0 ? broadcastAddr : "local"
+		} });
+		return gateways.map((g) => {
+			const displayName = g.model ?? g.name;
+			return {
+				stableId: `ecowitt:${slugifyHost(g.ip)}`,
+				type: DeviceType.Hub,
+				suggestedName: displayName,
+				prefilledConfig: {
+					name: displayName,
+					connection: {
+						transport: "local",
+						host: g.ip
+					}
+				}
+			};
+		});
+	}
+	async adoptDiscoveredDevice(input) {
+		return this.createDevice({
+			type: DeviceType.Hub,
+			config: input.candidate.prefilledConfig
+		});
 	}
 	async supportsManualCreation() {
 		return true;
@@ -46486,10 +46804,10 @@ var EcowittProviderAddon = class extends BaseDeviceProvider {
 	generateStableId(_type, config) {
 		const connection = extractConnection(config);
 		const station = typeof connection?.stationId === "string" ? connection.stationId.trim() : "";
-		if (station.length > 0) return `ecowitt:${slug(station)}`;
+		if (station.length > 0) return `ecowitt:${slugifyHost(station)}`;
 		if (connection?.transport === "local") {
 			const host = connection.host.trim();
-			if (host.length > 0) return `ecowitt:${slug(host)}`;
+			if (host.length > 0) return `ecowitt:${slugifyHost(host)}`;
 		}
 		if (connection?.transport === "listener") return `ecowitt:listen-${connection.listenPort}`;
 		throw new Error("Ecowitt: gateway resolved neither a station id nor a host/listen endpoint — cannot persist a stable row key.");
@@ -46503,10 +46821,6 @@ function extractConnection(config) {
 	if (transport !== "local" && transport !== "listener") return null;
 	return settingsToEcowittConfig(raw);
 }
-/** Flatten a host / station id into a readable row-key slug. */
-function slug(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
 //#endregion
 exports.ECOWITT_DEVICE_GROUPS = ECOWITT_DEVICE_GROUPS;
 exports.EcowittProviderAddon = EcowittProviderAddon;