@camstack/addon-provider-dreame 0.2.70 → 0.2.71

package/dist/addon.js

@@ -695,7 +695,7 @@ var require_util$9 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols$4();
 	var { IncomingMessage } = require("node:http");
 	var stream$1 = require("node:stream");
-	var net$5 = require("node:net");
+	var net$7 = require("node:net");
 	var { Blob: Blob$3 } = require("node:buffer");
 	var nodeUtil$3 = require("node:util");
 	var { stringify } = require("node:querystring");
@@ -800,7 +800,7 @@ var require_util$9 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (!host) return null;
 		assert$27(typeof host === "string");
 		const servername = getHostname(host);
-		if (net$5.isIP(servername)) return "";
+		if (net$7.isIP(servername)) return "";
 		return servername;
 	}
 	function deepClone(obj) {
@@ -1967,7 +1967,7 @@ var require_timers = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/@apocaliss92/nodedreame/node_modules/undici/lib/core/connect.js
 var require_connect$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var net$4 = require("node:net");
+	var net$6 = require("node:net");
 	var assert$25 = require("node:assert");
 	var util = require_util$9();
 	var { InvalidArgumentError, ConnectTimeoutError } = require_errors$1();
@@ -2047,7 +2047,7 @@ var require_connect$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			} else {
 				assert$25(!httpSocket, "httpSocket can only be sent on TLS update");
 				port = port || 80;
-				socket = net$4.connect({
+				socket = net$6.connect({
 					highWaterMark: 64 * 1024,
 					...options,
 					localAddress,
@@ -6264,7 +6264,7 @@ var require_redirect_interceptor = /* @__PURE__ */ __commonJSMin(((exports, modu
 //#region ../../node_modules/@apocaliss92/nodedreame/node_modules/undici/lib/dispatcher/client.js
 var require_client$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var assert$17 = require("node:assert");
-	var net$3 = require("node:net");
+	var net$5 = require("node:net");
 	var http$2 = require("node:http");
 	var util = require_util$9();
 	var { channels } = require_diagnostics();
@@ -6308,7 +6308,7 @@ var require_client$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (connect != null && typeof connect !== "function" && typeof connect !== "object") throw new InvalidArgumentError("connect must be a function or an object");
 			if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) throw new InvalidArgumentError("maxRedirections must be a positive number");
 			if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) throw new InvalidArgumentError("maxRequestsPerClient must be a positive number");
-			if (localAddress != null && (typeof localAddress !== "string" || net$3.isIP(localAddress) === 0)) throw new InvalidArgumentError("localAddress must be valid string IP address");
+			if (localAddress != null && (typeof localAddress !== "string" || net$5.isIP(localAddress) === 0)) throw new InvalidArgumentError("localAddress must be valid string IP address");
 			if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) throw new InvalidArgumentError("maxResponseSize must be a positive number");
 			if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) throw new InvalidArgumentError("autoSelectFamilyAttemptTimeout must be a positive number");
 			if (allowH2 != null && typeof allowH2 !== "boolean") throw new InvalidArgumentError("allowH2 must be a valid boolean value");
@@ -6449,7 +6449,7 @@ var require_client$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const idx = hostname.indexOf("]");
 			assert$17(idx !== -1);
 			const ip = hostname.substring(1, idx);
-			assert$17(net$3.isIP(ip));
+			assert$17(net$5.isIP(ip));
 			hostname = ip;
 		}
 		client[kConnecting] = true;
@@ -36633,7 +36633,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var EventEmitter$2 = require("events");
 	var https = require("https");
 	var http$1 = require("http");
-	var net$2 = require("net");
+	var net$4 = require("net");
 	var tls = require("tls");
 	var { randomBytes: randomBytes$1, createHash: createHash$2 } = require("crypto");
 	var { Duplex: Duplex$2, Readable } = require("stream");
@@ -37379,7 +37379,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function netConnect(options) {
 		options.path = options.socketPath;
-		return net$2.connect(options);
+		return net$4.connect(options);
 	}
 	/**
 	* Create a `tls.TLSSocket` and initiate a connection.
@@ -37390,7 +37390,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function tlsConnect(options) {
 		options.path = void 0;
-		if (!options.servername && options.servername !== "") options.servername = net$2.isIP(options.host) ? "" : options.host;
+		if (!options.servername && options.servername !== "") options.servername = net$4.isIP(options.host) ? "" : options.host;
 		return tls.connect(options);
 	}
 	/**
@@ -41473,7 +41473,7 @@ var require_helpers = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var constants_1 = require_constants$3();
 	var stream = require("stream");
 	var ip_address_1 = require_ip_address();
-	var net$1 = require("net");
+	var net$3 = require("net");
 	/**
 	* Validates the provided SocksClientOptions
 	* @param options { SocksClientOptions }
@@ -41551,10 +41551,10 @@ var require_helpers = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.int32ToIpv4 = int32ToIpv4;
 	function ipToBuffer(ip) {
-		if (net$1.isIPv4(ip)) {
+		if (net$3.isIPv4(ip)) {
 			const address = new ip_address_1.Address4(ip);
 			return Buffer.from(address.toArray());
-		} else if (net$1.isIPv6(ip)) {
+		} else if (net$3.isIPv6(ip)) {
 			const address = new ip_address_1.Address6(ip);
 			return Buffer.from(address.canonicalForm().split(":").map((segment) => segment.padStart(4, "0")).join(""), "hex");
 		} else throw new Error("Invalid IP address format");
@@ -41633,7 +41633,7 @@ var require_socksclient = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.SocksClientError = exports.SocksClient = void 0;
 	var events_1 = require("events");
-	var net = require("net");
+	var net$2 = require("net");
 	var smart_buffer_1 = require_smartbuffer();
 	var constants_1 = require_constants$3();
 	var helpers_1 = require_helpers();
@@ -41745,10 +41745,10 @@ var require_socksclient = /* @__PURE__ */ __commonJSMin(((exports) => {
 			const buff = new smart_buffer_1.SmartBuffer();
 			buff.writeUInt16BE(0);
 			buff.writeUInt8(options.frameNumber || 0);
-			if (net.isIPv4(options.remoteHost.host)) {
+			if (net$2.isIPv4(options.remoteHost.host)) {
 				buff.writeUInt8(constants_1.Socks5HostType.IPv4);
 				buff.writeUInt32BE((0, helpers_1.ipv4ToInt32)(options.remoteHost.host));
-			} else if (net.isIPv6(options.remoteHost.host)) {
+			} else if (net$2.isIPv6(options.remoteHost.host)) {
 				buff.writeUInt8(constants_1.Socks5HostType.IPv6);
 				buff.writeBuffer((0, helpers_1.ipToBuffer)(options.remoteHost.host));
 			} else {
@@ -41801,7 +41801,7 @@ var require_socksclient = /* @__PURE__ */ __commonJSMin(((exports) => {
 			const timer = setTimeout(() => this.onEstablishedTimeout(), this.options.timeout || constants_1.DEFAULT_TIMEOUT);
 			if (timer.unref && typeof timer.unref === "function") timer.unref();
 			if (existingSocket) this.socket = existingSocket;
-			else this.socket = new net.Socket();
+			else this.socket = new net$2.Socket();
 			this.socket.once("close", this.onClose);
 			this.socket.once("error", this.onError);
 			this.socket.once("connect", this.onConnect);
@@ -41913,7 +41913,7 @@ var require_socksclient = /* @__PURE__ */ __commonJSMin(((exports) => {
 			buff.writeUInt8(4);
 			buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
 			buff.writeUInt16BE(this.options.destination.port);
-			if (net.isIPv4(this.options.destination.host)) {
+			if (net$2.isIPv4(this.options.destination.host)) {
 				buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
 				buff.writeStringNT(userId);
 			} else {
@@ -42072,10 +42072,10 @@ var require_socksclient = /* @__PURE__ */ __commonJSMin(((exports) => {
 			buff.writeUInt8(5);
 			buff.writeUInt8(constants_1.SocksCommand[this.options.command]);
 			buff.writeUInt8(0);
-			if (net.isIPv4(this.options.destination.host)) {
+			if (net$2.isIPv4(this.options.destination.host)) {
 				buff.writeUInt8(constants_1.Socks5HostType.IPv4);
 				buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
-			} else if (net.isIPv6(this.options.destination.host)) {
+			} else if (net$2.isIPv6(this.options.destination.host)) {
 				buff.writeUInt8(constants_1.Socks5HostType.IPv6);
 				buff.writeBuffer((0, helpers_1.ipToBuffer)(this.options.destination.host));
 			} else {
@@ -44955,6 +44955,38 @@ async function postForToken(ctx, body) {
 	if (typeof data.refresh_token === "string") session.refreshToken = data.refresh_token;
 	return session;
 }
+var str = (v) => typeof v === "string" && v.length > 0 ? v : null;
+var numOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+function parseBroker(bindDomain) {
+	const s = str(bindDomain);
+	if (!s) return null;
+	const idx = s.lastIndexOf(":");
+	if (idx < 0) return {
+		host: s,
+		port: null
+	};
+	const port = Number(s.slice(idx + 1));
+	return {
+		host: s.slice(0, idx),
+		port: Number.isFinite(port) ? port : null
+	};
+}
+function parseConnectivity(raw) {
+	const deviceInfo = raw["deviceInfo"] ?? {};
+	return {
+		online: raw["online"] === true,
+		connectionType: str(deviceInfo["scType"]),
+		mac: str(raw["mac"]),
+		broker: parseBroker(raw["bindDomain"]),
+		region: str(raw["region"]),
+		cloudVendor: str(raw["vendor"]),
+		firmwareVersion: str(raw["ver"]),
+		serialNumber: str(raw["sn"]),
+		subModel: str(raw["subModel"]),
+		battery: numOrNull(raw["battery"]),
+		statusCode: numOrNull(raw["latestStatus"])
+	};
+}
 async function listDevices(input) {
 	const ctx = input.ctx ?? RequestContext.from({
 		...input,
@@ -44994,7 +45026,8 @@ function toDevice(rawIn) {
 		name,
 		online: rawIn.online === true || rawIn.lwt === 1 || lwtFlag === 1,
 		raw,
-		cloudState: parseCloudState(raw)
+		cloudState: parseCloudState(raw),
+		connectivity: parseConnectivity(raw)
 	};
 	if (rawIn.mac) device.mac = String(rawIn.mac);
 	if (typeof raw["ver"] === "string") device.firmwareVersion = raw["ver"];
@@ -46611,6 +46644,953 @@ var VacuumCapabilityResolver = class {
 		return new VacuumCapabilitySet(model, tokensFor(getVacuumCapabilities(model)));
 	}
 };
+objectType({
+	code: numberType().optional(),
+	msg: stringType().nullish(),
+	data: objectType({ data: objectType({
+		token: stringType(),
+		userId: unionType([stringType(), numberType()]).optional(),
+		expireAt: numberType().optional()
+	}).passthrough() }).passthrough()
+}).passthrough();
+var AuthCodeResponseSchema = objectType({
+	code: numberType().optional(),
+	msg: stringType().nullish(),
+	data: stringType()
+}).passthrough();
+objectType({
+	code: numberType().optional(),
+	msg: stringType().nullish(),
+	data: objectType({ data: objectType({ familyId: stringType() }).passthrough() }).passthrough()
+}).passthrough();
+var DeviceVideoInfoSchema = objectType({
+	model: stringType().optional(),
+	displayName: stringType().optional(),
+	permit: stringType().optional(),
+	videoDynamicVendor: booleanType().optional(),
+	defaultVendors: arrayType(stringType()).optional(),
+	productId: unionType([stringType(), numberType()]).optional()
+}).passthrough();
+var DeviceInfoRecordSchema = objectType({
+	did: unionType([stringType(), numberType()]).optional(),
+	model: stringType().optional(),
+	customName: stringType().optional(),
+	vendor: stringType().optional(),
+	online: booleanType().optional(),
+	lwt: numberType().optional(),
+	property: stringType().optional(),
+	bindDomain: stringType().optional(),
+	deviceInfo: DeviceVideoInfoSchema.optional()
+}).passthrough();
+var DeviceInfoResponseSchema = objectType({
+	code: numberType().optional(),
+	msg: stringType().nullish(),
+	data: DeviceInfoRecordSchema
+}).passthrough();
+var KNOWN_VENDORS = ["tx", "ali"];
+function asVendor(v) {
+	return v === "tx" || v === "ali" ? v : null;
+}
+function parseProperty(property) {
+	if (!property) return {
+		iotId: null,
+		lwt: null
+	};
+	try {
+		const p = JSON.parse(property);
+		return {
+			iotId: typeof p.iotId === "string" && p.iotId.length > 0 ? p.iotId : null,
+			lwt: typeof p.lwt === "number" ? p.lwt : null
+		};
+	} catch {
+		return {
+			iotId: null,
+			lwt: null
+		};
+	}
+}
+function toVideoProfile(record) {
+	const info = record.deviceInfo ?? {};
+	const supportedVendors = (info.defaultVendors ?? []).filter((v) => KNOWN_VENDORS.includes(v));
+	const prop = parseProperty(record.property);
+	const online = record.online === true || record.lwt === 1 || prop.lwt === 1;
+	return {
+		did: String(record.did ?? ""),
+		model: String(record.model ?? info.model ?? ""),
+		displayName: info.displayName ?? null,
+		videoCapable: info.permit === "video" || supportedVendors.length > 0,
+		currentVendor: asVendor(record.vendor),
+		supportedVendors,
+		dynamicVendor: info.videoDynamicVendor === true,
+		iotId: prop.iotId,
+		online
+	};
+}
+var P_SMARTHOME = "/dreame-smarthome";
+var P_USER_IOT = "/dreame-user-iot";
+var DEFAULT_OS = "android";
+function resolveCtx(input) {
+	return input.ctx ?? RequestContext.from({
+		...input,
+		host: input.apiHost
+	});
+}
+function passthrough(input) {
+	return {
+		accessToken: input.session.accessToken,
+		...input.signal !== void 0 ? { signal: input.signal } : {},
+		...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+	};
+}
+async function getAliyunAuthCode(input) {
+	const raw = await httpPostJsonBody({
+		ctx: resolveCtx(input),
+		path: `${P_SMARTHOME}/aliIot/getAuthCodeV3`,
+		body: { os: DEFAULT_OS },
+		context: "aliyun authCode",
+		...passthrough(input)
+	});
+	return AuthCodeResponseSchema.parse(raw).data;
+}
+async function getDeviceVideoProfile(input) {
+	const raw = await httpPostJsonBody({
+		ctx: resolveCtx(input),
+		path: `${P_USER_IOT}/iotuserbind/device/info`,
+		body: { did: input.did },
+		context: "device video info",
+		...passthrough(input)
+	});
+	return toVideoProfile(DeviceInfoResponseSchema.parse(raw).data);
+}
+var ALIYUN_APP_KEY = "33974273";
+var ALIYUN_APP_SECRET = "65a62f03ae5eda97af962fecc2e3efa6";
+var ALIYUN_REGION_ID = {
+	eu: "eu-central-1",
+	de: "eu-central-1",
+	us: "us-east-1",
+	cn: "cn-shanghai",
+	ru: "eu-central-1",
+	sg: "ap-southeast-1",
+	in: "ap-southeast-1",
+	tw: "cn-shanghai"
+};
+function livingAccountHost(regionId) {
+	return `living-account.${regionId}.aliyuncs.com`;
+}
+function apiIotHost(regionId) {
+	return `${regionId}.api-iot.aliyuncs.com`;
+}
+var VISION_STREAM_QUERY = "/vision/customer/stream/query";
+var CT_JSON = "application/json; charset=UTF-8";
+var CT_FORM = "application/x-www-form-urlencoded; charset=UTF-8";
+function md5Base64(s) {
+	return (0, crypto$1.createHash)("md5").update(s, "utf8").digest("base64");
+}
+function signApiGatewayRequest(input) {
+	const accept = CT_JSON;
+	const contentType = input.json !== void 0 ? CT_JSON : CT_FORM;
+	const date = input.date ?? (/* @__PURE__ */ new Date()).toUTCString();
+	let body;
+	let contentMd5 = "";
+	let formParams;
+	if (input.json !== void 0) {
+		body = JSON.stringify(input.json);
+		contentMd5 = md5Base64(body);
+	} else {
+		const form = input.form ?? {};
+		body = Object.entries(form).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+		formParams = form;
+	}
+	const caHeaders = {
+		"X-Ca-Key": input.appKey,
+		"X-Ca-Nonce": input.nonce ?? crypto.randomUUID().toUpperCase(),
+		"X-Ca-Timestamp": String(input.timestamp ?? Date.now()),
+		"X-Ca-Version": "1",
+		...input.extraCaHeaders ?? {}
+	};
+	const signedHeaderNames = Object.keys(caHeaders).sort((a, b) => a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0);
+	const headerBlock = signedHeaderNames.map((k) => `${k}:${caHeaders[k]}
+`).join("");
+	let resource = input.path;
+	if (formParams && Object.keys(formParams).length > 0) {
+		const sorted = Object.keys(formParams).sort();
+		resource += "?" + sorted.map((k) => `${k}=${formParams[k]}`).join("&");
+	}
+	const stringToSign = `${input.method}
+${accept}
+${contentMd5}
+${contentType}
+${date}
+${headerBlock}${resource}`;
+	const headers = {
+		"Content-Type": contentType,
+		Accept: accept,
+		Date: date,
+		"X-Ca-Signature": (0, crypto$1.createHmac)("sha1", input.appSecret).update(stringToSign, "utf8").digest("base64"),
+		"X-Ca-Signature-Method": "HmacSHA1",
+		"X-Ca-Signature-Headers": signedHeaderNames.join(","),
+		...caHeaders
+	};
+	if (contentMd5) headers["Content-MD5"] = contentMd5;
+	return {
+		headers,
+		body
+	};
+}
+var LoginByOauthSchema = objectType({ data: objectType({ data: objectType({ loginSuccessResult: objectType({
+	sid: stringType(),
+	refreshToken: stringType().optional(),
+	token: stringType().optional(),
+	openAccount: objectType({ openId: stringType().optional() }).passthrough().optional()
+}).passthrough() }).passthrough() }).passthrough() }).passthrough();
+var CreateSessionSchema = objectType({
+	code: numberType().optional(),
+	message: stringType().nullish(),
+	data: objectType({
+		iotToken: stringType(),
+		refreshToken: stringType().optional(),
+		identityId: stringType().optional(),
+		iotTokenExpire: numberType().optional()
+	}).passthrough()
+}).passthrough();
+async function postJson(url, headers, body, fetchImpl, ctx) {
+	const res = await fetchImpl(url, {
+		method: "POST",
+		headers,
+		body
+	});
+	const text = await res.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new DreameApiError(`${ctx} returned non-JSON (status ${res.status})`, res.status);
+	}
+}
+async function loginByOauth(input) {
+	const host = livingAccountHost(input.regionId);
+	const riskControlInfo = {
+		createIfNotExist: "true",
+		sdkVersion: "3.4.0.27",
+		openaccountVersion: "3.4.0.27",
+		platformName: "iOS",
+		netType: "wifi",
+		brand: "Apple",
+		USE_H5_NC: "true",
+		deviceId: input.deviceId ?? (0, crypto$1.randomUUID)(),
+		locale: "en-US",
+		platformVersion: "26.5.2",
+		platform: "iPhone",
+		appKey: ALIYUN_APP_KEY,
+		USE_OA_PWD_ENCRYPT: "true",
+		model: "iPhone16,2",
+		utdid: input.utdid ?? (0, crypto$1.randomUUID)().replace(/-/g, "").slice(0, 20),
+		appVersion: "1895"
+	};
+	const signed = signApiGatewayRequest({
+		method: "POST",
+		host,
+		path: "/api/prd/loginbyoauth.json",
+		appKey: ALIYUN_APP_KEY,
+		appSecret: ALIYUN_APP_SECRET,
+		form: { loginByOauthRequest: JSON.stringify({
+			riskControlInfo,
+			oauthPlateform: 23,
+			oauthAppKey: ALIYUN_APP_KEY,
+			authCode: input.authCode
+		}) }
+	});
+	const json = await postJson(`https://${host}/api/prd/loginbyoauth.json`, signed.headers, signed.body, input.fetchImpl ?? defaultFetch, "loginbyoauth");
+	const r = LoginByOauthSchema.parse(json).data.data.loginSuccessResult;
+	return {
+		sid: r.sid,
+		refreshToken: r.refreshToken ?? "",
+		openId: r.openAccount?.openId ?? ""
+	};
+}
+async function createIotSession(input) {
+	const host = apiIotHost(input.regionId);
+	const path = "/account/createSessionByAuthCode";
+	const signed = signApiGatewayRequest({
+		method: "POST",
+		host,
+		path,
+		appKey: ALIYUN_APP_KEY,
+		appSecret: ALIYUN_APP_SECRET,
+		json: {
+			id: (0, crypto$1.randomUUID)().toUpperCase(),
+			params: { request: {
+				appKey: ALIYUN_APP_KEY,
+				authCode: input.sid,
+				accountType: "OA_SESSION"
+			} },
+			request: {
+				apiVer: "1.0.4",
+				language: "en-US",
+				appKey: ALIYUN_APP_KEY
+			},
+			version: "1.0.0"
+		},
+		extraCaHeaders: { "X-Ca-Stage": "RELEASE" }
+	});
+	const json = await postJson(`https://${host}${path}`, signed.headers, signed.body, input.fetchImpl ?? defaultFetch, "createSessionByAuthCode");
+	const parsed = CreateSessionSchema.parse(json);
+	if (parsed.code !== 200 && parsed.code !== 0) throw new DreameApiError(`createSession rejected: code=${parsed.code} msg=${parsed.message ?? "?"}`, 200, parsed);
+	const d = parsed.data;
+	return {
+		iotToken: d.iotToken,
+		refreshToken: d.refreshToken ?? "",
+		identityId: d.identityId ?? "",
+		expiresAt: Date.now() + (d.iotTokenExpire ?? 72e3) * 1e3
+	};
+}
+var VISION_DEVICE_OFFLINE = 9201;
+var StreamQueryResponseSchema = objectType({
+	code: numberType().optional(),
+	message: stringType().nullish(),
+	data: objectType({
+		typeList: arrayType(stringType()).optional(),
+		relayUrl: stringType().optional(),
+		relayDecryptKey: objectType({
+			iv: stringType().optional(),
+			key: stringType().optional()
+		}).passthrough().optional(),
+		p2pInfo: objectType({
+			stunUrl: stringType().optional(),
+			alterStunUrl: stringType().optional(),
+			signalUrl: stringType().optional(),
+			portDetectStunUrlList: arrayType(stringType()).optional()
+		}).passthrough().optional(),
+		supportVisionPtz: booleanType().optional()
+	}).passthrough().optional()
+}).passthrough();
+async function streamQuery(input) {
+	const appKey = input.appKey ?? ALIYUN_APP_KEY;
+	const appSecret = input.appSecret ?? ALIYUN_APP_SECRET;
+	const host = apiIotHost(input.regionId);
+	const signed = signApiGatewayRequest({
+		method: "POST",
+		host,
+		path: VISION_STREAM_QUERY,
+		appKey,
+		appSecret,
+		json: {
+			id: crypto.randomUUID().toUpperCase(),
+			params: {
+				streamType: input.streamType ?? 0,
+				needDomainName: true,
+				relayEncryptType: 0,
+				clientType: "iOS",
+				iotId: input.iotId,
+				enablePortPredict: true,
+				enableWebSocket: true,
+				forceIFrame: true,
+				cacheDuration: 3e3,
+				relayEncrypted: input.relayEncrypted ?? false
+			},
+			request: {
+				language: "en-US",
+				appKey,
+				iotToken: input.iotToken,
+				apiVer: "2.2.0"
+			},
+			version: "1.0.0"
+		},
+		extraCaHeaders: { "X-Ca-Stage": "RELEASE" }
+	});
+	const res = await (input.fetchImpl ?? defaultFetch)(`https://${host}${VISION_STREAM_QUERY}`, {
+		method: "POST",
+		headers: signed.headers,
+		body: signed.body,
+		...input.signal ? { signal: input.signal } : {}
+	});
+	const text = await res.text();
+	let json;
+	try {
+		json = JSON.parse(text);
+	} catch {
+		throw new DreameApiError(`stream/query returned non-JSON (status ${res.status})`, res.status);
+	}
+	const parsed = StreamQueryResponseSchema.parse(json);
+	if (parsed.code === VISION_DEVICE_OFFLINE) throw new DreameDeviceOfflineError(`stream/query: device video agent offline (code ${VISION_DEVICE_OFFLINE}) \u2014 retry to wake`, res.status, parsed);
+	if (parsed.code !== 200 && parsed.code !== 0) throw new DreameApiError(`stream/query rejected: code=${parsed.code} msg=${parsed.message ?? "?"}`, res.status, parsed);
+	const d = parsed.data ?? {};
+	const dk = d.relayDecryptKey;
+	const hasKey = dk && dk.iv && dk.key;
+	const p = d.p2pInfo;
+	const p2pInfo = p ? {
+		...p.stunUrl !== void 0 ? { stunUrl: p.stunUrl } : {},
+		...p.alterStunUrl !== void 0 ? { alterStunUrl: p.alterStunUrl } : {},
+		...p.signalUrl !== void 0 ? { signalUrl: p.signalUrl } : {},
+		...p.portDetectStunUrlList !== void 0 ? { portDetectStunUrlList: p.portDetectStunUrlList } : {}
+	} : null;
+	return {
+		typeList: d.typeList ?? [],
+		relayUrl: d.relayUrl ?? null,
+		relayDecryptKey: hasKey ? {
+			iv: dk.iv,
+			key: dk.key
+		} : null,
+		p2pInfo,
+		...d.supportVisionPtz !== void 0 ? { supportVisionPtz: d.supportVisionPtz } : {}
+	};
+}
+var DEFAULT_WAKE_TIMEOUT_MS = 3e4;
+var DEFAULT_WAKE_POLL_MS = 2e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var REFRESH_LEEWAY_MS = 6e4;
+var DreameVideoSession = class {
+	#session;
+	#region;
+	#regionId;
+	#fetchImpl;
+	#iot = null;
+	#inFlight = null;
+	constructor(input) {
+		this.#session = input.session;
+		this.#region = input.region;
+		this.#regionId = ALIYUN_REGION_ID[input.region];
+		this.#fetchImpl = input.fetchImpl;
+	}
+	/** The resolved Aliyun IoT region id (e.g. `eu-central-1`). */
+	get regionId() {
+		return this.#regionId;
+	}
+	/** Mint (or reuse) a valid Aliyun IoT session, refreshing before expiry. */
+	async ensureIotSession() {
+		const cur = this.#iot;
+		if (cur && Date.now() < cur.expiresAt - REFRESH_LEEWAY_MS) return cur;
+		if (this.#inFlight) return this.#inFlight;
+		this.#inFlight = this.#mint();
+		try {
+			this.#iot = await this.#inFlight;
+			return this.#iot;
+		} finally {
+			this.#inFlight = null;
+		}
+	}
+	async #mint() {
+		return createIotSession({
+			sid: (await loginByOauth({
+				authCode: await getAliyunAuthCode({
+					session: this.#session,
+					region: this.#region,
+					...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+				}),
+				regionId: this.#regionId,
+				...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+			})).sid,
+			regionId: this.#regionId,
+			...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+		});
+	}
+	/**
+	* Mint a fresh LinkVisual stream descriptor for a device. `encrypted:false`
+	* (default) yields a plain RTMP relay URL directly playable by ffmpeg.
+	*
+	* A camera that has been idle reports "device offline" until the query wakes
+	* its video agent via the LinkVisual cloud. This transparently retries on that
+	* (up to `wakeTimeoutMs`, default 30s) so a single call returns a live stream;
+	* pass `wakeTimeoutMs: 0` to fail fast instead.
+	*/
+	async getStreamInfo(iotId, opts) {
+		const deadline = Date.now() + (opts?.wakeTimeoutMs ?? DEFAULT_WAKE_TIMEOUT_MS);
+		const pollMs = opts?.pollMs ?? DEFAULT_WAKE_POLL_MS;
+		for (;;) {
+			const iot = await this.ensureIotSession();
+			try {
+				return await streamQuery({
+					regionId: this.#regionId,
+					iotToken: iot.iotToken,
+					iotId,
+					relayEncrypted: opts?.encrypted ?? false,
+					...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+				});
+			} catch (err) {
+				if (err instanceof DreameDeviceOfflineError && Date.now() + pollMs < deadline) {
+					await sleep(pollMs);
+					continue;
+				}
+				throw err;
+			}
+		}
+	}
+	/**
+	* Convenience: mint a fresh plain RTMP relay URL for a device, or `null` when
+	* the device is not currently streaming (no relay available).
+	*/
+	async getRtmpUrl(iotId) {
+		return (await this.getStreamInfo(iotId, { encrypted: false })).relayUrl;
+	}
+};
+var MONITOR_SIID = 10001;
+var MONITOR_AIID = {
+	/** Stream lifecycle + keep-alive (monitor start/end, keep_alive). */
+	CAMERA_OPERATE: 1,
+	/** Two-way intercom start/end. */
+	VOICE_OPERATE: 2,
+	/** Generic property-scoped operations. */
+	PROPERTY_OPERATE: 3,
+	/** Privacy access-code gate (launch/verify/set/reset). */
+	ACCESS_CODE_OPERATE: 4,
+	/** Video-vendor SDK init / switch. */
+	VIDEO_VENDOR: 7
+};
+var MONITOR_PIID = {
+	MONITOR_STATUS: 1,
+	MONITOR_AUDIO_STATUS: 2,
+	MONITOR_RECORD_STATUS: 4,
+	TAKE_PHOTO: 5,
+	KEEP_ALIVE: 6,
+	MONITOR_FAULTS: 7,
+	FILL_LIGHT_SET: 9,
+	CAMERA_LIGHT_SWITCH: 10,
+	VIDEO_VENDOR_STATUS: 11,
+	GET_PROPERTY: 99,
+	PERSON_DATA: 110,
+	VIDEO_OBSTACLE_SWITCH: 111,
+	VIDEO_OBSTACLE_DATA: 112,
+	MONITOR_TASK_STATUS: 103,
+	UPLOAD_STATUS: 1003,
+	GET_ACCESS_CODE: 1100,
+	SET_ACCESS_CODE: 1101,
+	VERIFY_ACCESS_CODE: 1102,
+	MONITOR_REST_MODE: 1103,
+	SET_ACCESS_HOT_STATUS: 1104,
+	MONITOR_SPACE: 2003
+};
+var MONITOR_VENDOR_TOKEN = {
+	ali: "alify",
+	tx: "tx"
+};
+var VACUUM_MOVE = {
+	/** Remote-drive state property (set_properties), sent ~1 Hz while held. */
+	REMOTE_STATE_PIID: 15,
+	/** Work-mode action instance (go-to-point, cruise, person-follow start). */
+	WORK_AIID: 1,
+	/** Work-mode stop action instance (person-follow stop). */
+	STOP_AIID: 2,
+	/** piid carrying the work-mode selector value in the WORK action. */
+	MODE_PIID: 1,
+	/** piid carrying the point-info JSON in the WORK action. */
+	POINT_PIID: 10,
+	/** Work-mode selector values. */
+	MODE_SPOT: 23,
+	MODE_CRUISE: 22,
+	MODE_PERSON_FOLLOW: 26,
+	MODE_SPOT_CLEAN: 20,
+	/** Auto-switch setter property (fill-light auto/full toggle lives here). */
+	AUTO_SWITCH_PIID: 50
+};
+var VACUUM_CHARGE = {
+	siid: 3,
+	aiid: 1
+};
+var VOICE_SIID = 7;
+var VOICE_LOCATE_AIID = 1;
+var VOICE_PLAY_SOUND_AIID = 2;
+var VOICE_SOUND_PIID = 4;
+var VACUUM_LOCATE = {
+	siid: VOICE_SIID,
+	aiid: VOICE_LOCATE_AIID
+};
+var PET_SOUNDS = {
+	meow: 684,
+	bark: 685,
+	footsteps: 686,
+	purring: 687,
+	tickTock: 688
+};
+var VACUUM_ACTIONS = {
+	startClean: {
+		siid: 2,
+		aiid: 1
+	},
+	pauseClean: {
+		siid: 2,
+		aiid: 2
+	},
+	stopClean: {
+		siid: 4,
+		aiid: 2
+	},
+	dockWash: {
+		siid: 4,
+		aiid: 4
+	},
+	autoEmpty: {
+		siid: 15,
+		aiid: 1
+	}
+};
+function makeMonitorSession(accountId, now = Date.now()) {
+	return (0, crypto$1.createHash)("md5").update(`${accountId}_${now}`).digest("hex");
+}
+function hashAccessCode(code) {
+	return (0, crypto$1.createHash)("sha256").update(code).digest("hex");
+}
+function buildActionInput(piid, params, session) {
+	return {
+		piid,
+		value: JSON.stringify({
+			...params ?? {},
+			session
+		})
+	};
+}
+function startMonitorParams(iotId, vendor, area) {
+	return {
+		token: MONITOR_VENDOR_TOKEN[vendor],
+		channelId: iotId,
+		area,
+		operType: "monitor",
+		operation: "start"
+	};
+}
+function stopMonitorParams() {
+	return {
+		operType: "monitor",
+		operation: "end"
+	};
+}
+function keepAliveParams(videoStatus) {
+	return {
+		operType: "keep_alive",
+		videoStatus
+	};
+}
+function accessCodeLaunchParams() {
+	return { open: true };
+}
+function verifyAccessCodeParams(code, lazymode = 0) {
+	return {
+		oldcode: hashAccessCode(code),
+		lazymode
+	};
+}
+function intercomStartParams(opts) {
+	return {
+		operType: "intercom",
+		operation: "start",
+		...opts?.needRecordSound !== void 0 ? { need_record_sound: opts.needRecordSound } : {},
+		...opts?.videoCall ? { phone: 1 } : {}
+	};
+}
+function intercomStopParams() {
+	return {
+		operType: "intercom",
+		operation: "end"
+	};
+}
+function fillLightParams(value) {
+	return { value: String(value) };
+}
+function takePhotoParams() {
+	return {
+		operType: "takephoto",
+		operation: "start"
+	};
+}
+function remoteDriveValue(spdv, spdw, now = Date.now()) {
+	return JSON.stringify({
+		spdv,
+		spdw,
+		audio: "false",
+		random: Math.floor(Math.random() * 1e3),
+		timestamp: now
+	});
+}
+var DRIVE_DIRECTIONS = {
+	forward: [200, 0],
+	left: [0, 45],
+	right: [0, -45],
+	turnAround: [0, 180],
+	stop: [0, 0]
+};
+function actionCode(res) {
+	const r = res;
+	return typeof r?.code === "number" ? r.code : null;
+}
+function firstOutValue(res) {
+	const r = res;
+	const out = r?.out ?? r?.result?.out;
+	return Array.isArray(out) && out.length > 0 ? out[0]?.value : void 0;
+}
+var DEFAULT_KEEP_ALIVE_MS = 1e4;
+var DEFAULT_AREA = "4";
+var DreameCameraController = class {
+	#device;
+	#relay;
+	#iotId;
+	#accountId;
+	#vendor;
+	#accessCode;
+	#area;
+	#keepAliveIntervalMs;
+	#wakeTimeoutMs;
+	#onKeepAliveError;
+	#log;
+	#session = null;
+	#keepAliveTimer = null;
+	#opened = false;
+	constructor(input) {
+		this.#device = input.device;
+		this.#relay = input.relay;
+		this.#iotId = input.iotId;
+		this.#accountId = input.accountId;
+		this.#vendor = input.vendor ?? "ali";
+		this.#accessCode = input.accessCode;
+		this.#area = input.area ?? DEFAULT_AREA;
+		this.#keepAliveIntervalMs = input.keepAliveIntervalMs ?? DEFAULT_KEEP_ALIVE_MS;
+		this.#wakeTimeoutMs = input.wakeTimeoutMs;
+		this.#onKeepAliveError = input.onKeepAliveError;
+		this.#log = input.log ?? (() => {});
+	}
+	#logLine(msg) {
+		this.#log(`[nodedreame:monitor] ${msg}`);
+	}
+	/** True while a monitor session is active (between {@link open} and {@link close}). */
+	get isOpen() {
+		return this.#opened;
+	}
+	/** Send one camera action, resolving to the raw device reply. */
+	async #action(aiid, piid, params) {
+		if (!this.#session) throw new DreameError("camera controller has no session; call open() first");
+		const input = buildActionInput(piid, params, this.#session);
+		return this.#device.callAction(MONITOR_SIID, aiid, [input]);
+	}
+	/**
+	* Run the full cold-start sequence and return a live relay URL. Starts the
+	* keep-alive loop; the caller MUST {@link close} when done to release the
+	* device. Throws if the monitor cannot be started or no relay comes up.
+	*/
+	async open() {
+		if (this.#opened) throw new DreameError("camera stream already open");
+		this.#session = makeMonitorSession(this.#accountId);
+		this.#logLine(`open: vendor=${this.#vendor} iotId=${this.#iotId} area=${this.#area}`);
+		await this.#tryPrime();
+		const encryptionKey = asString(firstOutValue(await this.#startMonitorWithGate()));
+		this.#logLine(`startMonitor accepted (encryptionKey=${encryptionKey ? "yes" : "no"})`);
+		this.#opened = true;
+		this.#startKeepAlive();
+		let relayUrl;
+		try {
+			relayUrl = (await this.#relay.getStreamInfo(this.#iotId, {
+				encrypted: false,
+				...this.#wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: this.#wakeTimeoutMs } : {}
+			})).relayUrl;
+		} catch (err) {
+			this.#logLine(`relay mint failed: ${err instanceof Error ? err.message : String(err)}`);
+			await this.close();
+			throw err;
+		}
+		if (!relayUrl) {
+			await this.close();
+			throw new DreameError("monitor started but no relay URL was returned");
+		}
+		this.#logLine("relay up");
+		return {
+			rtmpUrl: relayUrl,
+			encryptionKey
+		};
+	}
+	async #tryPrime() {
+		try {
+			await this.#action(MONITOR_AIID.ACCESS_CODE_OPERATE, MONITOR_PIID.GET_ACCESS_CODE, accessCodeLaunchParams());
+		} catch {}
+		try {
+			await this.#action(MONITOR_AIID.VIDEO_VENDOR, MONITOR_PIID.VIDEO_VENDOR_STATUS, null);
+		} catch {}
+	}
+	async #startMonitorWithGate() {
+		const params = startMonitorParams(this.#iotId, this.#vendor, this.#area);
+		let res = await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, params);
+		if (actionCode(res) === 0) return res;
+		this.#logLine(`startMonitor refused (code ${actionCode(res) ?? "?"}); verifying access code`);
+		if (this.#accessCode) {
+			await this.#action(MONITOR_AIID.ACCESS_CODE_OPERATE, MONITOR_PIID.VERIFY_ACCESS_CODE, verifyAccessCodeParams(this.#accessCode));
+			res = await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, params);
+		}
+		if (actionCode(res) !== 0) throw new DreameError(`startMonitor refused (code ${actionCode(res) ?? "?"})` + (this.#accessCode ? "" : "; device likely requires an accessCode"));
+		return res;
+	}
+	#startKeepAlive() {
+		this.#stopKeepAlive();
+		this.#keepAliveTimer = setInterval(() => {
+			this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.KEEP_ALIVE, keepAliveParams("opened")).catch((err) => this.#onKeepAliveError?.(err));
+		}, this.#keepAliveIntervalMs);
+		this.#keepAliveTimer.unref?.();
+	}
+	#stopKeepAlive() {
+		if (this.#keepAliveTimer) {
+			clearInterval(this.#keepAliveTimer);
+			this.#keepAliveTimer = null;
+		}
+	}
+	/**
+	* Mint a FRESH single-use RTMP relay URL for the already-open monitor. Each
+	* consumer needs its own relay URL, so call this once per ffmpeg/consumer.
+	* Throws if the stream is not open.
+	*/
+	async mintRelayUrl() {
+		if (!this.#opened) throw new DreameError("camera stream is not open; call open() first");
+		const info = await this.#relay.getStreamInfo(this.#iotId, {
+			encrypted: false,
+			...this.#wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: this.#wakeTimeoutMs } : {}
+		});
+		if (!info.relayUrl) throw new DreameError("no relay URL available for the open monitor");
+		return info.relayUrl;
+	}
+	/** Start the two-way intercom session (control plane only; see module docs on mic uplink). */
+	async startIntercom(opts) {
+		return this.#action(MONITOR_AIID.VOICE_OPERATE, MONITOR_PIID.MONITOR_AUDIO_STATUS, intercomStartParams(opts));
+	}
+	/** Stop the two-way intercom session. */
+	async stopIntercom() {
+		return this.#action(MONITOR_AIID.VOICE_OPERATE, MONITOR_PIID.MONITOR_AUDIO_STATUS, intercomStopParams());
+	}
+	/** Set the fill-light brightness (40–100 = manual %, below 40 / 101 = auto). */
+	async setFillLight(value) {
+		return this.#action(MONITOR_AIID.PROPERTY_OPERATE, MONITOR_PIID.FILL_LIGHT_SET, fillLightParams(value));
+	}
+	/**
+	* Device-side snapshot: the robot captures a still and uploads it to cloud
+	* storage (read the result back from the `uploadStatus` property). Prefer a
+	* frame-grab from the live stream for an instant image.
+	*/
+	async takePhoto() {
+		return this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.TAKE_PHOTO, takePhotoParams());
+	}
+	/**
+	* Remote-drive the robot ("PTZ" substitute — the camera is fixed, the robot
+	* moves). `spdv` = forward speed, `spdw` = turn; send repeatedly (~1 Hz) while
+	* a direction is held, then `stop`. Only valid while the stream is open.
+	*/
+	async drive(spdv, spdw) {
+		this.#requireSession();
+		if (!this.#device.setProperty) throw new DreameError("device does not support setProperty; cannot remote-drive");
+		return this.#device.setProperty({
+			siid: 4,
+			piid: VACUUM_MOVE.REMOTE_STATE_PIID,
+			value: remoteDriveValue(spdv, spdw)
+		});
+	}
+	/** Remote-drive by named direction (forward/left/right/turnAround/stop). */
+	async driveDirection(direction) {
+		const [spdv, spdw] = DRIVE_DIRECTIONS[direction];
+		return this.drive(spdv, spdw);
+	}
+	/** Start person-follow mode (robot tracks a detected person). */
+	async startPersonFollow() {
+		this.#requireSession();
+		return this.#device.callAction(4, VACUUM_MOVE.WORK_AIID, [{
+			piid: VACUUM_MOVE.MODE_PIID,
+			value: VACUUM_MOVE.MODE_PERSON_FOLLOW
+		}]);
+	}
+	/**
+	* Universal stop for the current work mode — stops person-follow, spot-clean,
+	* go-to-point, cruise, etc. (siid 4 / aiid 2).
+	*/
+	async stopWork() {
+		return this.#device.callAction(4, VACUUM_MOVE.STOP_AIID, []);
+	}
+	/** Stop person-follow mode (alias for {@link stopWork}). */
+	async stopPersonFollow() {
+		return this.stopWork();
+	}
+	/** Spot-clean the robot's current position (WorkMode SpotClean). */
+	async spotClean() {
+		return this.#device.callAction(4, VACUUM_MOVE.WORK_AIID, [{
+			piid: VACUUM_MOVE.MODE_PIID,
+			value: VACUUM_MOVE.MODE_SPOT_CLEAN
+		}]);
+	}
+	/** Play one of the robot's sound clips (e.g. pet sounds) by id. */
+	async playSound(soundId) {
+		return this.#device.callAction(VOICE_SIID, VOICE_PLAY_SOUND_AIID, [{
+			piid: VOICE_SOUND_PIID,
+			value: soundId
+		}]);
+	}
+	/** Play a named pet-teasing sound (meow/bark/footsteps/purring/tickTock). */
+	async playPetSound(sound) {
+		return this.playSound(PET_SOUNDS[sound]);
+	}
+	/** Run a common whole-robot action (startClean/pauseClean/stopClean/dockWash/autoEmpty). */
+	async runVacuumAction(action) {
+		const a = VACUUM_ACTIONS[action];
+		return this.#device.callAction(a.siid, a.aiid, []);
+	}
+	/** Find-pet: cruise the home looking for the pet. */
+	async findPet() {
+		this.#requireSession();
+		return this.#device.callAction(4, VACUUM_MOVE.WORK_AIID, [{
+			piid: VACUUM_MOVE.MODE_PIID,
+			value: VACUUM_MOVE.MODE_CRUISE
+		}, {
+			piid: VACUUM_MOVE.POINT_PIID,
+			value: JSON.stringify({ findpet: "" })
+		}]);
+	}
+	/** Send the robot to a map point (`spoint` current, `tpoint` targets). */
+	async goToPoint(spoint, tpoint) {
+		this.#requireSession();
+		return this.#device.callAction(4, VACUUM_MOVE.WORK_AIID, [{
+			piid: VACUUM_MOVE.MODE_PIID,
+			value: VACUUM_MOVE.MODE_SPOT
+		}, {
+			piid: VACUUM_MOVE.POINT_PIID,
+			value: JSON.stringify({
+				spoint,
+				tpoint
+			})
+		}]);
+	}
+	/** Toggle the fill light between auto (`full=false`) and full-on (`full=true`). */
+	async setFillLightAuto(full) {
+		if (!this.#device.setProperty) throw new DreameError("device does not support setProperty; cannot toggle fill light");
+		return this.#device.setProperty({
+			siid: 4,
+			piid: VACUUM_MOVE.AUTO_SWITCH_PIID,
+			value: JSON.stringify({
+				k: "FillinLight",
+				v: full ? 1 : 0
+			})
+		});
+	}
+	/**
+	* Send the robot back to its dock to charge ("go home"). Works regardless of
+	* stream state — usable as a standalone command or a PTZ "home" preset.
+	*/
+	async returnToDock() {
+		return this.#device.callAction(VACUUM_CHARGE.siid, VACUUM_CHARGE.aiid, []);
+	}
+	/** Locate the robot — it beeps. Works regardless of stream state. */
+	async locate() {
+		return this.#device.callAction(VACUUM_LOCATE.siid, VACUUM_LOCATE.aiid, []);
+	}
+	#requireSession() {
+		if (!this.#opened) throw new DreameError("camera stream is not open; call open() first");
+	}
+	/** Stop the keep-alive loop and release the monitor on the device. Idempotent. */
+	async close() {
+		this.#stopKeepAlive();
+		if (!this.#opened) {
+			this.#session = null;
+			return;
+		}
+		this.#opened = false;
+		this.#logLine("close: stopping monitor");
+		try {
+			await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, stopMonitorParams());
+		} finally {
+			this.#session = null;
+		}
+	}
+};
+function asString(v) {
+	return typeof v === "string" ? v : null;
+}
 var HEADER_SIZE = 27;
 var ANGLE_ABSENT = 32767;
 var FRAME_TYPE = {
@@ -48311,6 +49291,134 @@ function drawLabel(png, cx, cy, text, color, px) {
 		originX += glyphW + gap;
 	}
 }
+var NIBBLE_TO_BARS = {
+	10: 0,
+	11: 1,
+	12: 2,
+	13: 3,
+	14: 4
+};
+var isWifiNibble = (n) => n >= 10 && n <= 14;
+var NIBBLE_RGBA = {
+	2: [
+		176,
+		182,
+		190,
+		255
+	],
+	3: [
+		242,
+		244,
+		247,
+		255
+	],
+	10: [
+		229,
+		234,
+		238,
+		255
+	],
+	11: [
+		217,
+		226,
+		239,
+		255
+	],
+	12: [
+		205,
+		218,
+		239,
+		255
+	],
+	13: [
+		161,
+		189,
+		242,
+		255
+	],
+	14: [
+		129,
+		168,
+		245,
+		255
+	]
+};
+var poseOrNull = (x, y, a) => x === 0 && y === 0 ? null : {
+	x,
+	y,
+	angle: a === ANGLE_ABSENT ? 0 : a
+};
+function decodeWifiSignalMap(input, opts = {}) {
+	const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : looksLikeBase64Zlib(input) ? unwrapEnvelope(input.toString("latin1"), opts) : input;
+	const header = parseMapHeader(inflated);
+	const { width, height, gridSize, left, top } = header;
+	const pixelEnd = HEADER_SIZE + width * height;
+	const grid = inflated.subarray(HEADER_SIZE, pixelEnd);
+	const cells = new Uint8Array(width * height);
+	for (let i = 0; i < cells.length; i++) cells[i] = (grid[i] ?? 0) & 15;
+	const dimensions = {
+		left,
+		top,
+		width,
+		height,
+		gridSize
+	};
+	const robot = poseOrNull(header.robotX, header.robotY, header.robotA);
+	const dock = poseOrNull(header.chargerX, header.chargerY, header.chargerA);
+	const signalAt = (worldX, worldY) => {
+		if (gridSize <= 0) return null;
+		const col = Math.floor((worldX - left) / gridSize);
+		const row = Math.floor((worldY - top) / gridSize);
+		if (col < 0 || col >= width || row < 0 || row >= height) return null;
+		const nibble = cells[row * width + col] ?? 0;
+		return isWifiNibble(nibble) ? NIBBLE_TO_BARS[nibble] : null;
+	};
+	return {
+		dimensions,
+		robot,
+		dock,
+		cells,
+		signalAt,
+		currentSignal: robot ? signalAt(robot.x, robot.y) : null
+	};
+}
+function renderWifiSignalPng(map, opts = {}) {
+	const scale = Math.max(1, Math.floor(opts.scale ?? 4));
+	const { width, height, left, top, gridSize } = map.dimensions;
+	const png = new import_png.PNG({
+		width: width * scale,
+		height: height * scale,
+		colorType: 6
+	});
+	for (let row = 0; row < height; row++) for (let col = 0; col < width; col++) {
+		const rgba = NIBBLE_RGBA[map.cells[row * width + col] ?? 0];
+		if (!rgba) continue;
+		for (let dy = 0; dy < scale; dy++) for (let dx = 0; dx < scale; dx++) {
+			const o = col * scale + dx + (row * scale + dy) * width * scale << 2;
+			png.data[o] = rgba[0];
+			png.data[o + 1] = rgba[1];
+			png.data[o + 2] = rgba[2];
+			png.data[o + 3] = rgba[3];
+		}
+	}
+	if ((opts.markRobot ?? true) && map.robot && gridSize > 0) {
+		const cx = Math.floor((map.robot.x - left) / gridSize) * scale + Math.floor(scale / 2);
+		const cy = Math.floor((map.robot.y - top) / gridSize) * scale + Math.floor(scale / 2);
+		const r = Math.max(2, scale);
+		for (let dy = -r; dy <= r; dy++) for (let dx = -r; dx <= r; dx++) {
+			if (dx * dx + dy * dy > r * r) continue;
+			const x = cx + dx;
+			const y = cy + dy;
+			if (x < 0 || y < 0 || x >= width * scale || y >= height * scale) continue;
+			const o = x + y * width * scale << 2;
+			png.data[o] = 255;
+			png.data[o + 1] = 69;
+			png.data[o + 2] = 0;
+			png.data[o + 3] = 255;
+		}
+	}
+	return import_png.PNG.sync.write(png);
+}
 var OSS_DOWNLOAD_PATH = "/dreame-user-iot/iotfile/getDownloadUrl";
 var DEFAULT_TTL_MS = 1800 * 1e3;
 var OssFetcher = class {
@@ -48789,11 +49897,11 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice$1 {
 		if (zones.length === 0) throw new RangeError("cleanZones: zones must not be empty");
 		this.#requireCap(this.#caps.canCleanPerRoom, "cleanZones", "per-room cleaning");
 		const { repeats, fan, water } = this.#resolveCleanOpts(opts);
-		const areas = zones.map((z4) => [
-			Math.round(z4.x0),
-			Math.round(z4.y0),
-			Math.round(z4.x1),
-			Math.round(z4.y1),
+		const areas = zones.map((z7) => [
+			Math.round(z7.x0),
+			Math.round(z7.y0),
+			Math.round(z7.x1),
+			Math.round(z7.y1),
 			repeats,
 			fan,
 			water
@@ -48929,6 +50037,60 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice$1 {
 		};
 	}
 	/**
+	* Fetch the robot's Wi-Fi signal map — the last stored coverage heatmap, with
+	* NO robot movement. Requests it (map service `wifiMap` action, siid 6 aiid 4),
+	* polls `PropWifiMap` (6/15) for the OSS object it advertises, fetches + decodes
+	* it into a per-cell signal grid + geometry + robot/dock poses. The signal at
+	* any world point (incl. the robot's own position) is a lookup — see
+	* {@link WifiSignalMap.signalAt} / {@link WifiSignalMap.currentSignal}.
+	*
+	* Pass `requestFresh: false` to skip the request and read whatever is already
+	* advertised. Throws if no Wi-Fi map exists yet (never run on this device).
+	*/
+	async getWifiSignalMap(input = {}) {
+		if (input.requestFresh !== false) try {
+			await this.callAction(6, 4, []);
+		} catch {}
+		const pollMs = input.pollMs ?? 2500;
+		const deadline = Date.now() + (input.maxWaitMs ?? 2e4);
+		let objectName = "";
+		for (;;) {
+			const val = (await this.refreshProperties([{
+				siid: 6,
+				piid: 15
+			}]))[0]?.value;
+			if (typeof val === "string" && val.length > 0) {
+				objectName = val;
+				break;
+			}
+			if (Date.now() + pollMs >= deadline) throw new DreameError("wifi signal map not available (none stored yet, or request timed out)");
+			await new Promise((r) => setTimeout(r, pollMs));
+		}
+		const filename = objectName.replace(/^\d+,/, "");
+		return decodeWifiSignalMap(await this.#fetchMapBlob({
+			filename,
+			...input.fetcher ? { fetcher: input.fetcher } : {},
+			...input.host ? { host: input.host } : {},
+			...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+			...input.signal ? { signal: input.signal } : {}
+		}), this.#decodeOpts(input));
+	}
+	/**
+	* Render the Wi-Fi signal map as a simple PNG heatmap image (weakest→strongest,
+	* unreached grey, robot marker) — ready to display. Convenience over
+	* {@link getWifiSignalMap} + {@link renderWifiSignalPng}.
+	*/
+	async getWifiSignalImage(input = {}) {
+		return renderWifiSignalPng(await this.getWifiSignalMap(input), input);
+	}
+	/**
+	* The one-call "current Wi-Fi signal": fetches the signal map and returns the
+	* bars (1–4, 0 = unreached) at the robot's own position, or null when unknown.
+	*/
+	async getCurrentSignal(input = {}) {
+		return (await this.getWifiSignalMap(input)).currentSignal;
+	}
+	/**
 	* The merge base for live P-frame streaming — always an INFLATED frame buffer.
 	* An I-frame (re)seeds it; each P-frame merge replaces it with the merged
 	* inflated buffer (so further P-frames stack). `null` until the first I-frame
@@ -48994,6 +50156,44 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice$1 {
 		this.emit("map", frame);
 		return frame;
 	}
+	/**
+	* Build a {@link DreameCameraController} for this device's camera, wired to
+	* both planes it needs: the MIoT action transport (this device handle) and a
+	* fresh Aliyun {@link DreameVideoSession} for the relay. Call
+	* `controller.open()` to autonomously cold-start the stream and get a pullable
+	* RTMP URL, then `controller.close()` to release it.
+	*
+	* The camera's per-session privacy gate means a coded camera needs its PIN:
+	* pass `accessCode` (the code set at pairing). `iotId` is resolved from the
+	* device's cloud video profile when not supplied.
+	*/
+	async createCameraController(opts) {
+		const session = this.currentSession();
+		const region = this.region;
+		const relay = opts?.relay ?? new DreameVideoSession({
+			session,
+			region
+		});
+		const iotId = opts?.iotId ?? (await getDeviceVideoProfile({
+			session,
+			region,
+			did: this.deviceId
+		})).iotId;
+		if (!iotId) throw new DreameError("device has no LinkVisual iotId; not a camera device or not provisioned");
+		return new DreameCameraController({
+			device: this,
+			relay,
+			iotId,
+			accountId: session.uid,
+			...opts?.vendor ? { vendor: opts.vendor } : {},
+			...opts?.accessCode !== void 0 ? { accessCode: opts.accessCode } : {},
+			...opts?.area ? { area: opts.area } : {},
+			...opts?.keepAliveIntervalMs !== void 0 ? { keepAliveIntervalMs: opts.keepAliveIntervalMs } : {},
+			...opts?.wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: opts.wakeTimeoutMs } : {},
+			...opts?.onKeepAliveError ? { onKeepAliveError: opts.onKeepAliveError } : {},
+			...opts?.log ? { log: opts.log } : {}
+		});
+	}
 	/** Props worth seeding on start() / polling — exported for the facade. */
 	static DEFAULT_PROPS = [
 		VACUUM_PROP.STATE,
@@ -49554,7 +50754,7 @@ function isRecord3(v) {
 function asNumber(v, fallback) {
 	return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
-function asString(v, fallback) {
+function asString2(v, fallback) {
 	return typeof v === "string" ? v : fallback;
 }
 function mapIdFromIndex(mapIndex) {
@@ -49634,7 +50834,7 @@ function parseZones(list, includeTimes) {
 		out.push({
 			zoneId: asNumber(id, 0),
 			path: extractPathCoords(data["path"]),
-			name: asString(data["name"], ""),
+			name: asString2(data["name"], ""),
 			zoneType: asNumber(data["type"], 0),
 			shapeType: includeTimes ? asNumber(data["shapeType"], 0) : 0,
 			area: includeTimes ? asNumber(data["area"], 0) : 0,
@@ -49653,7 +50853,7 @@ function parseSpotAreas(list) {
 		out.push({
 			areaId: Math.trunc(asNumber(id, 0)),
 			path: extractPathCoords(data["path"]),
-			name: asString(data["name"], ""),
+			name: asString2(data["name"], ""),
 			shapeType: asNumber(data["shapeType"], 0),
 			area: asNumber(data["area"], 0)
 		});
@@ -49712,7 +50912,7 @@ function parseMowerMap(mapJsonStr) {
 		contours: parseContours(parsePolygonList(data["contours"])),
 		boundary: parseBoundary(data["boundary"]),
 		totalArea: asNumber(data["totalArea"], 0),
-		name: asString(data["name"], ""),
+		name: asString2(data["name"], ""),
 		mapIndex,
 		mapId: mapIdFromIndex(mapIndex),
 		mowPaths: [],
@@ -50111,7 +51311,7 @@ var MowerDevice = class _MowerDevice extends BaseDevice$1 {
 	async startMowingZones(zoneIds) {
 		this.#requireCap(this.#caps.canMowZones, "startMowingZones", "zone mowing");
 		if (zoneIds.length === 0) throw new RangeError("startMowingZones: zoneIds must not be empty");
-		return this.#sendTask(buildZonePayload(zoneIds.map((z4) => Math.trunc(z4))));
+		return this.#sendTask(buildZonePayload(zoneIds.map((z7) => Math.trunc(z7))));
 	}
 	/** Edge / contour mowing (2:50 o:101). Contour ids are two-int pairs [[1,0]]. */
 	async startMowingEdges(contourIds) {
@@ -50503,6 +51703,12 @@ objectType({
 		generatedAt: numberType()
 	})
 });
+Buffer.from([
+	0,
+	0,
+	0,
+	1
+]);
 //#endregion
 //#region ../types/dist/event-category-zAv7pMUz.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
@@ -74306,6 +75512,21 @@ var NetworkLinkStatusSchema = object({
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
 	lastUpdated: number()
 });
+/** The slice a provider seeds before its first read: nothing is known yet. */
+var NETWORK_LINK_UNKNOWN = {
+	type: "unknown",
+	signalPercent: null,
+	lastUpdated: 0
+};
+/**
+* Normalise a signal the firmware reports as BARS (0..`maxBars`) to 0..100.
+* Out-of-range or non-finite input is not a reading: `null`.
+*/
+function signalPercentFromBars(bars, maxBars) {
+	if (bars === void 0 || !Number.isFinite(bars) || maxBars <= 0) return null;
+	if (bars < 0 || bars > maxBars) return null;
+	return Math.round(bars / maxBars * 100);
+}
 var networkLinkCapability = {
 	name: "network-link",
 	scope: "device",
@@ -74334,11 +75555,7 @@ onStatusChanged: { data: object({
 	status: {
 		schema: NetworkLinkStatusSchema,
 		kind: "push",
-		empty: {
-			type: "unknown",
-			signalPercent: null,
-			lastUpdated: 0
-		}
+		empty: NETWORK_LINK_UNKNOWN
 	},
 	/**
 	* Runtime-state slice — every provider stores the same shape under
@@ -79336,7 +80553,10 @@ var PtzMoveCommandSchema = object({
 	zoom: number().optional(),
 	speed: number().optional()
 });
-PtzPositionSchema.extend({ autofocus: boolean() });
+/** PTZ status — current position plus the camera's autofocus state.
+*  `getPosition` / `move` still operate on the bare position; the
+*  auto-injected `getStatus` returns this richer block. */
+var PtzStatusSchema = PtzPositionSchema.extend({ autofocus: boolean() });
 /** Per-camera PTZ availability descriptor — drives the UI. */
 var PtzOptionsSchema = object({
 	hasPan: boolean(),
@@ -79349,26 +80569,65 @@ var PtzOptionsSchema = object({
 	*  (boolean `hasX` per the getOptions availability convention). */
 	hasAutofocus: boolean()
 });
-DeviceType.Camera, method(PtzMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(PtzMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), array(PtzPresetSchema)), method(object({
-	deviceId: number(),
-	presetId: string()
-}), _void(), { kind: "mutation" }), method(object({
-	deviceId: number(),
-	presetId: string(),
-	name: string()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number(),
-	presetId: string()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number() }), PtzOptionsSchema), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), PtzPositionSchema), method(object({
-	deviceId: number(),
-	enabled: boolean()
-}), _void(), { kind: "mutation" });
+var ptzCapability = {
+	name: "ptz",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/ptz-panel",
+		tab: "ptz",
+		topTab: true,
+		label: "PTZ",
+		order: 0
+	} },
+	methods: {
+		move: method(PtzMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }),
+		continuousMove: method(PtzMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }),
+		stop: method(object({ deviceId: number() }), _void(), { kind: "mutation" }),
+		getPresets: method(object({ deviceId: number() }), array(PtzPresetSchema)),
+		goToPreset: method(object({
+			deviceId: number(),
+			presetId: string()
+		}), _void(), { kind: "mutation" }),
+		savePreset: method(object({
+			deviceId: number(),
+			presetId: string(),
+			name: string()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deletePreset: method(object({
+			deviceId: number(),
+			presetId: string()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getOptions: method(object({ deviceId: number() }), PtzOptionsSchema),
+		goHome: method(object({ deviceId: number() }), _void(), { kind: "mutation" }),
+		/**
+		* Pull the current PTZ position. Redundant with the auto-injected
+		* `getStatus` method (see `status` below); kept for callers that
+		* haven't migrated. Will be folded into `getStatus` in a future
+		* cleanup pass once all consumers use the typed status surface.
+		*/
+		getPosition: method(object({ deviceId: number() }), PtzPositionSchema),
+		/** Toggle the camera's autofocus. Only meaningful when
+		*  `getOptions().hasAutofocus` is true. */
+		setAutofocus: method(object({
+			deviceId: number(),
+			enabled: boolean()
+		}), _void(), { kind: "mutation" })
+	},
+	status: {
+		schema: PtzStatusSchema,
+		kind: "command-driven"
+	}
+};
 var PtzAutotrackSettingsSchema = object({
 	targetType: string().describe("Vendor target string (people/vehicle/pet); empty = camera default"),
 	stopDelaySeconds: number().int().min(0).max(300),
@@ -79494,6 +80753,424 @@ var ptzAutotrackCapability = {
 	*/
 	durability: "session"
 };
+/**
+* `navigation` — a device-scoped capability that natively expresses the FULL
+* navigation / action surface of a robot that DRIVES ITSELF and carries an
+* on-board camera (the Dreame robot-vacuum camera is the first provider).
+*
+* Why a NEW cap rather than overloading `ptz`:
+*   - `ptz` moves a *gimbal* on a fixed camera (pan/tilt/zoom of the lens). A
+*     robot vacuum has no gimbal — the whole chassis drives, turns and spins.
+*     The two are different physical models: PTZ is absolute-position + presets,
+*     navigation is momentary drive nudges + discrete robot ACTIONS
+*     (dock / spot-clean / follow-pet / go-to-point / …).
+*   - This cap is the SOURCE OF TRUTH. Two consumers adapt from it rather than
+*     the reverse:
+*       1. a native CamStack navigation panel (data-driven from `listActions`
+*          / `getOptions`), and
+*       2. the PTZ surface — a thin adapter mimics `ptz` from `navigation` so a
+*          robot camera shows up in the existing PTZ control path without every
+*          PTZ provider learning about robots. The mapping lives in the adapter,
+*          not here (see the addon design note):
+*            ptz.continuousMove({pan,tilt}) → navigation.move({pan,tilt})
+*            ptz.stop()                      → navigation.stop()
+*            ptz.goHome()                    → navigation.runAction('goHome')
+*            ptz.getPresets()                → navigation.listActions()  (id→preset)
+*            ptz.goToPreset(id)              → navigation.runAction(id)
+*
+* ## Continuous drive
+*
+* `move` is MOMENTARY. Fluid navigation comes from the UI (or the PTZ adapter)
+* sending `move({pan,tilt})` REPEATEDLY at ~1 Hz while a direction is held, and
+* one `stop()` on release — exactly like the robot app's remote-drive joystick.
+* The provider forwards EACH `move` to one drive write; it must NOT debounce or
+* coalesce them. The UI owns the cadence.
+*
+* ## The action dictionary
+*
+* The discrete controls (dock / locate / spot-clean / follow / flash / sounds)
+* are a DATA-DRIVEN dictionary the cap exposes via `listActions()`. Each entry
+* carries `{ id, kind, label, icon }` (plus `soundId` for sound entries) so the
+* native panel AND the PTZ mimic render buttons WITHOUT hardcoding a
+* vendor-specific list. `kind: 'action'` entries are triggered with
+* `runAction({ actionId })`; `kind: 'sound'` entries with `playSound({ soundId })`
+* (the entry carries the `soundId` to pass). The general primitives — `move`,
+* `stop`, `goToPoint` — stay as first-class methods, not dictionary entries.
+*
+* NOTE (provider wiring): the first provider (Dreame) drives this with the RAW
+* `callAction(siid,aiid,in)` / `setProperty({siid,piid,value})` MIoT primitives
+* that the currently-published `@apocaliss92/nodedreame` already exposes on
+* every device handle. A future nodedreame publish adds a typed
+* `DreameCameraController` (drive / playPetSound / spotClean / findPet / …); the
+* provider can then swap the raw calls for the typed methods with no change to
+* THIS contract.
+*/
+/**
+* A momentary drive nudge. The robot MOVES (no gimbal) for as long as the caller
+* keeps sending nudges (~1 Hz); an explicit `stop` (or letting the nudges lapse)
+* halts it.
+*
+*   - `pan`   — turn: negative = left, positive = right, 0 = straight.
+*   - `tilt`  — throttle: positive = forward, negative = spin / turn-around.
+*   - `speed` — optional intensity hint [0, 1]; the provider may scale the drive
+*               vector by it (drivers without proportional drive ignore it).
+*
+* `pan` / `tilt` are normalized [-1, 1]. Both optional so a caller can nudge one
+* axis alone; an all-undefined nudge is a no-op.
+*/
+var NavigationMoveCommandSchema = object({
+	pan: number().min(-1).max(1).optional(),
+	tilt: number().min(-1).max(1).optional(),
+	speed: number().min(0).max(1).optional()
+});
+/**
+* The enumerated discrete actions a navigation-capable robot can perform via
+* `runAction`. This is the CLOSED vocabulary; a given device advertises the
+* subset it supports through `listActions`. Sounds are NOT here — they go through
+* `playSound` (see the `sound` dictionary entries).
+*/
+var NavigationActionIdSchema = _enum([
+	"goHome",
+	"locate",
+	"spotClean",
+	"findPet",
+	"personFollow",
+	"stop",
+	"startClean",
+	"pauseClean",
+	"dockWash",
+	"autoEmpty",
+	"flashOn",
+	"flashOff"
+]);
+/** Whether a dictionary entry is a `runAction` action or a `playSound` sound. */
+var NavigationEntryKindSchema = _enum(["action", "sound"]);
+/**
+* One entry in the navigation action dictionary — the DATA-DRIVEN unit both the
+* native panel and the PTZ mimic render as a button.
+*
+*   - `id`      — stable id. For `kind:'action'` it is a {@link NavigationActionId}
+*                 (pass to `runAction`); for `kind:'sound'` it is a namespaced id
+*                 (`sound:meow`) whose `soundId` is passed to `playSound`.
+*   - `icon`    — icon HINT (lucide-style name; the UI maps it to its own set).
+*   - `label`   — operator-facing English label.
+*   - `soundId` — wire sound id, present only on `kind:'sound'` entries.
+*   - `enabled` — per-device FEATURE FLAG. `listActions` reports it so the UI /
+*                 PTZ render ONLY enabled entries. Data-driven: the provider
+*                 flips it from config, never by editing code.
+*/
+var NavigationActionEntrySchema = object({
+	id: string(),
+	kind: NavigationEntryKindSchema,
+	label: string(),
+	icon: string(),
+	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
+	soundId: number().int().optional(),
+	/** Per-device feature flag — render this entry only when true. */
+	enabled: boolean()
+});
+/**
+* Canonical dictionary of every navigation control (discrete actions + sounds)
+* with its default label + icon hint. A provider filters this to the subset a
+* device supports (and may override a label). Exported so the provider AND the
+* UI share ONE list instead of re-deriving labels / ids independently.
+*
+* Icons are lucide-style hints; the viewer maps them to its own icon set. Every
+* catalog default is `enabled: true`; a provider overrides per-device from
+* config (data-driven — enabling / disabling one later is a config change, not a
+* code change).
+*/
+var NAVIGATION_ACTION_CATALOG = [
+	{
+		id: "startClean",
+		kind: "action",
+		label: "Start cleaning",
+		icon: "play",
+		enabled: true
+	},
+	{
+		id: "pauseClean",
+		kind: "action",
+		label: "Pause cleaning",
+		icon: "pause",
+		enabled: true
+	},
+	{
+		id: "stop",
+		kind: "action",
+		label: "Stop",
+		icon: "hand",
+		enabled: true
+	},
+	{
+		id: "goHome",
+		kind: "action",
+		label: "Return to dock",
+		icon: "home",
+		enabled: true
+	},
+	{
+		id: "locate",
+		kind: "action",
+		label: "Locate",
+		icon: "bell",
+		enabled: true
+	},
+	{
+		id: "spotClean",
+		kind: "action",
+		label: "Spot clean here",
+		icon: "crosshair",
+		enabled: true
+	},
+	{
+		id: "findPet",
+		kind: "action",
+		label: "Find pet",
+		icon: "paw-print",
+		enabled: true
+	},
+	{
+		id: "personFollow",
+		kind: "action",
+		label: "Follow me",
+		icon: "footprints",
+		enabled: true
+	},
+	{
+		id: "dockWash",
+		kind: "action",
+		label: "Wash mop",
+		icon: "droplets",
+		enabled: true
+	},
+	{
+		id: "autoEmpty",
+		kind: "action",
+		label: "Empty dustbin",
+		icon: "trash-2",
+		enabled: true
+	},
+	{
+		id: "flashOn",
+		kind: "action",
+		label: "Flash on",
+		icon: "flashlight",
+		enabled: true
+	},
+	{
+		id: "flashOff",
+		kind: "action",
+		label: "Flash off",
+		icon: "flashlight-off",
+		enabled: true
+	},
+	{
+		id: "sound:meow",
+		kind: "sound",
+		label: "Meow",
+		icon: "cat",
+		soundId: 684,
+		enabled: true
+	},
+	{
+		id: "sound:bark",
+		kind: "sound",
+		label: "Woof",
+		icon: "dog",
+		soundId: 685,
+		enabled: true
+	},
+	{
+		id: "sound:footsteps",
+		kind: "sound",
+		label: "Footsteps",
+		icon: "footprints",
+		soundId: 686,
+		enabled: true
+	},
+	{
+		id: "sound:purring",
+		kind: "sound",
+		label: "Purring",
+		icon: "cat",
+		soundId: 687,
+		enabled: true
+	},
+	{
+		id: "sound:tickTock",
+		kind: "sound",
+		label: "Tick-tock",
+		icon: "clock",
+		soundId: 688,
+		enabled: true
+	}
+];
+/** Coordinates for `goToPoint` — a point on the robot's live map. */
+var NavigationPointSchema = object({
+	x: number(),
+	y: number()
+});
+/**
+* Per-device FEATURE-FLAG report for the general (non-dictionary) primitives.
+* The cap reports which are enabled so the UI / PTZ render only the controls
+* that are turned on for THIS device. Data-driven: the provider derives these
+* from config + probe, never hardcoded in the UI. The per-DICTIONARY-entry flags
+* live on {@link NavigationActionEntrySchema.enabled}; these gate the primitives
+* that are not dictionary entries.
+*
+*   - `move` / `stop`   — the momentary drive joystick.
+*   - `goToPoint`       — send-to-map-coordinate. Ships OFF on Dreame until the
+*                         map-coordinate plumbing is wired.
+*   - `runAction`       — the discrete action buttons (dictionary `kind:'action'`).
+*   - `playSound`       — the sound buttons (dictionary `kind:'sound'`).
+*   - `light`           — the on/off fill-light toggle (works anytime).
+*   - `lightMode`       — the auto/manual selector + manual level slider (a
+*                         camera-service control; needs an active stream).
+*/
+var NavigationFeaturesSchema = object({
+	move: boolean(),
+	stop: boolean(),
+	goToPoint: boolean(),
+	runAction: boolean(),
+	playSound: boolean(),
+	light: boolean(),
+	lightMode: boolean()
+});
+/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
+var NavigationLightModeSchema = _enum(["auto", "manual"]);
+/**
+* Live navigation state so the UI can reflect what the robot is doing:
+*   - `mode`       — coarse activity (idle / cleaning / following / …).
+*   - `following`  — person/pet follow is currently armed.
+*   - `flash`      — the on-camera fill light is on.
+*   - `lightMode`  — auto vs manual fill-light mode.
+*   - `lightLevel` — manual fill-light level (40..100); meaningful when
+*                    `lightMode === 'manual'`.
+*/
+var NavigationStatusSchema = object({
+	mode: _enum([
+		"idle",
+		"cleaning",
+		"spot",
+		"following",
+		"goto",
+		"returning",
+		"paused",
+		"unknown"
+	]),
+	following: boolean(),
+	flash: boolean(),
+	lightMode: NavigationLightModeSchema,
+	lightLevel: number().min(40).max(100),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+/**
+* Runtime-state slice owned by this cap (kernel-managed: validated, mirrored,
+* observable). Adds `lastFetchedAt` on top of the status shape per the
+* convention.
+*/
+var NavigationRuntimeStateSchema = NavigationStatusSchema.extend({ lastFetchedAt: number() });
+var navigationCapability = {
+	name: "navigation",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/navigation-panel",
+		tab: "navigation",
+		topTab: true,
+		label: "Navigation",
+		order: 0
+	} },
+	methods: {
+		/**
+		* Momentary drive nudge (the robot moves). `protected` — mirrors
+		* `ptz.continuousMove` so the Viewer navigation panel (and the PTZ-mimic
+		* path) works for any authenticated user, not admin-only. The UI sends
+		* these at ~1 Hz while a control is held; the provider forwards each one to
+		* a single drive write WITHOUT debouncing.
+		*/
+		move: method(NavigationMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }),
+		/** Halt all motion immediately (zero drive vector). */
+		stop: method(object({ deviceId: number() }), _void(), { kind: "mutation" }),
+		/** Send the robot to a point on its live map. */
+		goToPoint: method(NavigationPointSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }),
+		/**
+		* Enumerate the discrete controls THIS device supports (data-driven UI +
+		* PTZ mimic). Camera-probed subset of {@link NAVIGATION_ACTION_CATALOG}.
+		*/
+		listActions: method(object({ deviceId: number() }), array(NavigationActionEntrySchema)),
+		/**
+		* Run one discrete action (a `kind:'action'` dictionary entry). Invalid /
+		* unsupported action ids are rejected by the provider.
+		*/
+		runAction: method(object({
+			deviceId: number(),
+			actionId: NavigationActionIdSchema
+		}), _void(), { kind: "mutation" }),
+		/** Play a sound by its wire id (the `soundId` of a `kind:'sound'` entry). */
+		playSound: method(object({
+			deviceId: number(),
+			soundId: number().int()
+		}), _void(), { kind: "mutation" }),
+		/**
+		* Turn the on-camera fill light on / off (the `OpenFullLight` control —
+		* works anytime, no active stream required).
+		*/
+		setLightOn: method(object({
+			deviceId: number(),
+			on: boolean()
+		}), _void(), { kind: "mutation" }),
+		/**
+		* Set the fill-light mode (auto vs manual). `manual` optionally carries the
+		* initial `level`. The auto/manual + level control is a CAMERA-service
+		* action that generally needs an active camera stream/monitor session — the
+		* UI shows the manual level slider ONLY when `mode === 'manual'`.
+		*/
+		setLightMode: method(object({
+			deviceId: number(),
+			mode: NavigationLightModeSchema,
+			level: number().min(40).max(100).optional()
+		}), _void(), { kind: "mutation" }),
+		/** Set the MANUAL fill-light level (40..100). Implies `manual` mode. */
+		setLightLevel: method(object({
+			deviceId: number(),
+			level: number().min(40).max(100)
+		}), _void(), { kind: "mutation" }),
+		/**
+		* Per-device FEATURE-FLAG report for the general primitives — drives which
+		* controls the UI shows (the per-entry flags for the dictionary come back on
+		* `listActions`).
+		*/
+		getFeatures: method(object({ deviceId: number() }), NavigationFeaturesSchema)
+	},
+	events: { onStatusChanged: { data: object({
+		deviceId: number(),
+		status: NavigationStatusSchema
+	}) } },
+	status: {
+		schema: NavigationStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice mirrored by the kernel. The navigation panel watches it
+	* for live mode / follow / flash changes.
+	*/
+	runtimeState: NavigationRuntimeStateSchema,
+	/**
+	* Runtime-state durability: **session** — like `vacuum-control`, a restored
+	* `mode: cleaning` / `following: true` is a robot that is not actually doing
+	* that. The live handle re-publishes on connect.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session"
+};
 DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceId: number().int().nonnegative() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -82769,6 +84446,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	motionTrigger: motionTriggerCapability,
 	motionZones: motionZonesCapability,
 	nativeObjectDetection: nativeObjectDetectionCapability,
+	navigation: navigationCapability,
 	networkLink: networkLinkCapability,
 	notifier: notifierCapability,
 	numericSensor: numericSensorCapability,
@@ -86623,6 +88301,66 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"navigation.getFeatures": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"navigation.goToPoint": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.listActions": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"navigation.move": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.playSound": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.runAction": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.setLightLevel": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.setLightMode": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.setLightOn": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"navigation.stop": {
+		capName: "navigation",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"networkAccess.getEndpoint": {
 		capName: "network-access",
 		capScope: "system",
@@ -90718,6 +92456,56 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"navigation.getFeatures": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.goToPoint": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.listActions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.move": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.playSound": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.runAction": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.setLightLevel": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.setLightMode": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.setLightOn": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"navigation.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"networkQuality.getDeviceStats": [{
 		name: "deviceId",
 		form: "single",
@@ -93900,6 +95688,23 @@ var dreameChildSchema = object({
 	mapShowPath: boolean().optional(),
 	mapShowRobot: boolean().optional(),
 	mapShowCharger: boolean().optional(),
+	/**
+	* `navigation` per-device overrides (camera child only): a feature flag set
+	* here wins over the addon defaults, an entry id listed here is switched off.
+	* Data, not code — see `dreame-navigation-config.ts`.
+	*/
+	navigationFeatures: object({
+		move: boolean().optional(),
+		stop: boolean().optional(),
+		goToPoint: boolean().optional(),
+		runAction: boolean().optional(),
+		playSound: boolean().optional(),
+		light: boolean().optional(),
+		lightMode: boolean().optional()
+	}).optional(),
+	navigationDisabledEntryIds: array(string()).optional(),
+	/** Privacy PIN set at pairing — required to wake a coded camera (camera child only). */
+	navigationAccessCode: string().optional(),
 	mapShowNoGo: boolean().optional(),
 	mapShowVirtualWalls: boolean().optional(),
 	mapShowObstacles: boolean().optional(),
@@ -93992,7 +95797,7 @@ var DreameChildDevice = class extends BaseDevice {
 };
 //#endregion
 //#region src/devices/dreame-ai-switch-device.ts
-var CAP_NAME$14 = "switch";
+var CAP_NAME$15 = "switch";
 var COLD$4 = {
 	on: false,
 	lastChangedAt: 0
@@ -94054,26 +95859,26 @@ var DreameAiSwitchDevice = class extends DreameChildDevice {
 	}
 	registerControlCap() {
 		this.ctx.registerNativeCap(switchCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$14) ?? COLD$4,
+			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$15) ?? COLD$4,
 			setState: async ({ on }) => {
 				const vacuum = this.resolveVacuum();
 				if (vacuum === null) throw new Error(`DreameAiSwitchDevice: vacuum handle unavailable (device=${this.dreameDeviceId}, feature=${this.#feature})`);
 				await vacuum.setAiFeature(this.#feature, on);
-				this.runtimeState.setCapState(CAP_NAME$14, {
+				this.runtimeState.setCapState(CAP_NAME$15, {
 					on,
 					lastChangedAt: Date.now()
 				});
 			}
 		});
-		this.runtimeState.setCapState(CAP_NAME$14, COLD$4);
+		this.runtimeState.setCapState(CAP_NAME$15, COLD$4);
 	}
 	recomputeSlice() {
 		const vacuum = this.resolveVacuum();
 		if (vacuum === null) return;
 		const on = vacuum.aiFeature(this.#feature);
 		if (on === null) return;
-		if (this.runtimeState.getCapState(CAP_NAME$14)?.on === on) return;
-		this.runtimeState.setCapState(CAP_NAME$14, {
+		if (this.runtimeState.getCapState(CAP_NAME$15)?.on === on) return;
+		this.runtimeState.setCapState(CAP_NAME$15, {
 			on,
 			lastChangedAt: Date.now()
 		});
@@ -94098,6 +95903,14 @@ function vacuumSupportsAi(caps) {
 	return caps !== null && caps.hasAiObstacleDetection && caps.aiFeatureCount > 0;
 }
 /**
+* Whether a vacuum carries an on-board camera (LinkVisual video) — gates the
+* separate camera + navigation child. `false` when the handle has not resolved
+* (confirmed capability only, never optimistic).
+*/
+function vacuumSupportsCamera(caps) {
+	return caps?.hasCamera === true;
+}
+/**
 * Whether a mower supports a map. `false` when the handle has not resolved.
 */
 function mowerSupportsMap(caps) {
@@ -94131,7 +95944,7 @@ function deriveContainerFeatures(input) {
 }
 //#endregion
 //#region src/devices/dreame-auto-switch-device.ts
-var CAP_NAME$13 = "switch";
+var CAP_NAME$14 = "switch";
 var COLD$3 = {
 	on: false,
 	lastChangedAt: 0
@@ -94179,19 +95992,19 @@ var DreameAutoSwitchDevice = class extends DreameChildDevice {
 	}
 	registerControlCap() {
 		this.ctx.registerNativeCap(switchCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$13) ?? COLD$3,
+			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$14) ?? COLD$3,
 			setState: async ({ on }) => {
 				const vacuum = this.#vacuum();
 				if (vacuum === null) throw new Error(`DreameAutoSwitchDevice: handle unavailable (device=${this.dreameDeviceId}, ${this.#key})`);
 				await vacuum.setAutoSwitchProperty(this.#key, on ? 1 : 0);
-				this.runtimeState.setCapState(CAP_NAME$13, {
+				this.runtimeState.setCapState(CAP_NAME$14, {
 					on,
 					lastChangedAt: Date.now()
 				});
 			}
 		});
 		const on = this.#read();
-		this.runtimeState.setCapState(CAP_NAME$13, on === null ? COLD$3 : {
+		this.runtimeState.setCapState(CAP_NAME$14, on === null ? COLD$3 : {
 			on,
 			lastChangedAt: Date.now()
 		});
@@ -94199,8 +96012,8 @@ var DreameAutoSwitchDevice = class extends DreameChildDevice {
 	recomputeSlice() {
 		const on = this.#read();
 		if (on === null) return;
-		if (this.runtimeState.getCapState(CAP_NAME$13)?.on === on) return;
-		this.runtimeState.setCapState(CAP_NAME$13, {
+		if (this.runtimeState.getCapState(CAP_NAME$14)?.on === on) return;
+		this.runtimeState.setCapState(CAP_NAME$14, {
 			on,
 			lastChangedAt: Date.now()
 		});
@@ -94208,7 +96021,7 @@ var DreameAutoSwitchDevice = class extends DreameChildDevice {
 };
 //#endregion
 //#region src/devices/dreame-auto-select-device.ts
-var CAP_NAME$12 = "control";
+var CAP_NAME$13 = "control";
 var dreameAutoSelectOptionSchema = object({
 	value: number().int(),
 	label: string().min(1)
@@ -94263,7 +96076,7 @@ var DreameAutoSelectDevice = class extends DreameChildDevice {
 	}
 	registerControlCap() {
 		this.ctx.registerNativeCap(controlCapability, {
-			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$12) ?? this.#slice(this.#readLabel() ?? ""),
+			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$13) ?? this.#slice(this.#readLabel() ?? ""),
 			setValue: async ({ control }) => {
 				if (control.kind !== "select") throw new Error(`DreameAutoSelectDevice: expected a select value (device=${this.dreameDeviceId}, ${this.#key})`);
 				const option = this.#options.find((o) => o.label === control.value);
@@ -94271,16 +96084,16 @@ var DreameAutoSelectDevice = class extends DreameChildDevice {
 				const vacuum = this.#vacuum();
 				if (vacuum === null) throw new Error(`DreameAutoSelectDevice: handle unavailable (device=${this.dreameDeviceId}, ${this.#key})`);
 				await vacuum.setAutoSwitchProperty(this.#key, option.value);
-				this.runtimeState.setCapState(CAP_NAME$12, this.#slice(option.label));
+				this.runtimeState.setCapState(CAP_NAME$13, this.#slice(option.label));
 			}
 		});
-		this.runtimeState.setCapState(CAP_NAME$12, this.#slice(this.#readLabel() ?? ""));
+		this.runtimeState.setCapState(CAP_NAME$13, this.#slice(this.#readLabel() ?? ""));
 	}
 	recomputeSlice() {
 		const label = this.#readLabel();
 		if (label === null) return;
-		if (this.runtimeState.getCapState(CAP_NAME$12)?.value === label) return;
-		this.runtimeState.setCapState(CAP_NAME$12, this.#slice(label));
+		if (this.runtimeState.getCapState(CAP_NAME$13)?.value === label) return;
+		this.runtimeState.setCapState(CAP_NAME$13, this.#slice(label));
 	}
 };
 //#endregion
@@ -94323,6 +96136,779 @@ var DreameButtonDevice = class extends DreameChildDevice {
 	recomputeSlice() {}
 };
 //#endregion
+//#region src/dreame-vacuum-decode.ts
+/**
+* Pure decode helpers for the Dreame vacuum. Translate the library's MIoT enum
+* values into the camstack `vacuum-control` slice shape. Unit-tested in
+* isolation (no facade, no network) — mirrors `homematic-decode.ts`.
+*/
+/**
+* Map a Dreame {@link MiotState} (siid 2 piid 1) onto the camstack canonical
+* `VacuumState` lifecycle (`idle` / `cleaning` / `paused` / `returning` /
+* `docked` / `error`). A `null` state (not yet observed) settles on `idle`.
+*
+* The MIoT state space is large (~50 values); we collapse it onto the six
+* canonical states by family. Anything unrecognised falls through to `idle`
+* (the safe neutral) so a firmware-added code never throws.
+*/
+function mapMiotStateToVacuumState(state) {
+	if (state === null) return "idle";
+	switch (state) {
+		case MiotState.Charging:
+		case MiotState.ChargingComplete:
+		case MiotState.IntelligentCharging:
+		case MiotState.CleanWashboardBase:
+		case MiotState.AutoRepairBase:
+		case MiotState.WaterSupplyDrainTest:
+		case MiotState.CleanMopRefillWater:
+		case MiotState.AutoEmptying:
+		case MiotState.Emptying:
+		case MiotState.Draining:
+		case MiotState.AutoWaterDraining:
+		case MiotState.Sanitizing: return "docked";
+		case MiotState.MopDrying:
+		case MiotState.DustBagDrying:
+		case MiotState.SanitizingWithDry: return "drying";
+		case MiotState.ReturningToCharge:
+		case MiotState.ReturningToWash:
+		case MiotState.ReturnInstallMop:
+		case MiotState.ReturnRemoveMop:
+		case MiotState.ReturnToEmpty:
+		case MiotState.ReturningToDrain: return "returning";
+		case MiotState.Paused:
+		case MiotState.PausedAlt:
+		case MiotState.PausedCleaning:
+		case MiotState.DustBagDryingPaused:
+		case MiotState.CameraMonitoringPaused:
+		case MiotState.FindingPetPaused:
+		case MiotState.InitialDeepCleanPaused:
+		case MiotState.ChangingMopPaused:
+		case MiotState.FloorMaintainingPaused: return "paused";
+		case MiotState.Standby:
+		case MiotState.WaitingForTask: return "idle";
+		default: return "cleaning";
+	}
+}
+/**
+* The camstack `fanSpeed` token for a Dreame {@link SuctionLevel} — the enum
+* member NAME, lower-cased (`Quiet` → `'quiet'`). Returns `null` for an
+* unobserved / unknown level.
+*/
+function suctionLevelToken(level) {
+	if (level === null) return null;
+	const name = SuctionLevel[level];
+	return typeof name === "string" ? name.toLowerCase() : null;
+}
+/**
+* Resolve a camstack `fanSpeed` token back to the Dreame {@link SuctionLevel}
+* enum value, validated against the model's `supported` levels. Returns null
+* when the token doesn't match a supported level (the caller rejects the set).
+*/
+function tokenToSuctionLevel(token, supported) {
+	const wanted = token.trim().toLowerCase();
+	for (const level of supported) if (suctionLevelToken(level) === wanted) return level;
+	return null;
+}
+/** The list of accepted `fanSpeed` tokens for a model's supported suction set. */
+function supportedFanSpeedTokens(supported) {
+	const tokens = [];
+	for (const level of supported) {
+		const token = suctionLevelToken(level);
+		if (token !== null) tokens.push(token);
+	}
+	return tokens;
+}
+/**
+* Clamp a raw battery reading (already a 0..100 percentage from the library)
+* to the `vacuum-control` slice's `batteryLevel` field. Returns null for a
+* null/NaN/out-of-band reading so the slice stays valid (the schema rejects
+* a number outside 0..100).
+*/
+function clampBatteryLevel$1(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/** Clamp a 0..100 percentage (progress, coverage, …), null-safe. */
+function clampPercent$1(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* Clean-water tank `status`: prefer the richer clean-water-tank-status (27/1),
+* fall back to the coarser water-tank presence (4/6). `null` when neither maps
+* to a known good/low reading (NOT_INSTALLED / CHECKING / unknown). Pure.
+*/
+function cleanWaterTankStatus(props) {
+	if (props.cleanWaterTankStatus !== null) {
+		if (props.cleanWaterTankStatus === 0) return "ok";
+		if (props.cleanWaterTankStatus === 2) return "low";
+		return null;
+	}
+	if (props.waterTank === 1 || props.waterTank === 10) return "ok";
+	return null;
+}
+/** Detergent tank `status` from detergent-status (27/4). Pure. */
+function detergentTankStatus(value) {
+	if (value === 0) return "ok";
+	if (value === 2) return "low";
+	return null;
+}
+/** Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. Pure. */
+function dustBinTankStatus(value) {
+	if (value === 1) return "ok";
+	if (value === 2) return "full";
+	return null;
+}
+/**
+* The four `vacuum-control` tank fields (clean-water / dirty-water / detergent /
+* dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
+* discrete `status` populated from the live MIoT enum props when supplied. Pure.
+*
+* The nodedreame library exposes NO tank FILL-LEVEL telemetry — the cloud shadow
+* (verified against a real `dreame.vacuum.r2538z`) carries only the water-VOLUME
+* *setting* (a mop-flow level, NOT a tank fill). We therefore never fabricate a
+* `level`; `level` is always `null`. The cap contract is honoured on PRESENCE,
+* with `status` derived from the tank-status enums:
+*
+*   - a field is `null` when the hardware HAS NO such tank (capability flags), and
+*   - `{ level: null, status }` when the tank EXISTS — `status` from the enum
+*     prop ('ok' / 'low' / 'full'), or `null` when the device reports none.
+*
+* Presence is derived from the capability record:
+*   - clean-water  ← `canMop` (a mopping robot carries a clean-water reservoir)
+*   - dirty-water  ← `canMopWash` (a self-wash dock has a recovery/dirty tank)
+*   - detergent    ← `hasDetergentReservoir`
+*   - dust-bin     ← `canAutoEmpty` (an auto-empty robot has an onboard dust bin)
+*/
+function decodeVacuumTanks(caps, props) {
+	const tank = (present, status) => present ? {
+		level: null,
+		status
+	} : null;
+	return {
+		cleanWater: tank(Boolean(caps?.canMop), props ? cleanWaterTankStatus(props) : null),
+		dirtyWater: tank(Boolean(caps?.canMopWash), null),
+		detergent: tank(Boolean(caps?.hasDetergentReservoir), props ? detergentTankStatus(props.detergentStatus) : null),
+		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection) : null)
+	};
+}
+/**
+* Clamp a raw consumable percentage to `[0, 100]`, or return `null` when the
+* value is absent / non-finite. The library reports remaining life as a 0..100
+* integer; we clamp defensively so an out-of-range firmware value never violates
+* the cap schema.
+*/
+function clampConsumablePct(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* Build the `consumables` cap runtime-state slice from a live {@link VacuumDevice}
+* handle. The returned object satisfies the cap's `runtimeState` schema
+* (`ConsumablesStatusSchema.extend({ lastFetchedAt: z.number() })`).
+*
+* PRESENCE-driven (mirrors HA): the library's `supportedConsumables` enumerates
+* ONLY the consumables this model reports (a present MIoT life property) — main/
+* side brush, filter, sensor, tank-filter, mop-pad, silver-ion, detergent,
+* squeegee, dust-bag — each with its remaining-life % and whether a reset action
+* exists. No hardcoded per-model list: a consumable the device does not expose
+* never appears, and a `resettable` item drives the real MIoT reset action.
+*/
+function buildVacuumConsumables(vacuum) {
+	const items = vacuum.supportedConsumables.map((c) => ({
+		key: c.key,
+		label: c.label,
+		level: clampConsumablePct(c.leftPct),
+		status: null,
+		lastResetAt: null,
+		resettable: c.resettable
+	}));
+	const now = Date.now();
+	return {
+		items: [...items],
+		lastChangedAt: now,
+		lastFetchedAt: now
+	};
+}
+//#endregion
+//#region src/devices/dreame-navigation-actions.ts
+/** Forward throttle magnitude for a full-forward nudge (device speed units). */
+var FORWARD_SPEED = 200;
+/** Turn magnitudes: left = +45, right = -45, spin/turn-around = +180. */
+var TURN_LEFT = 45;
+var TURN_RIGHT = -45;
+var SPIN = 180;
+/** The `setFillLight` value that selects auto. */
+var FILL_LIGHT_AUTO$1 = 101;
+/**
+* Map a normalized {@link NavigationMoveCommand} ([-1, 1] per axis) to a discrete
+* Dreame drive vector. The robot has no proportional joystick, so intensity is
+* quantized to the RE'd discrete nudges. Priority: forward, then spin
+* (tilt-down), then turn (pan). An all-zero / empty command is a stop.
+*/
+function driveVector(cmd) {
+	const pan = cmd.pan ?? 0;
+	const tilt = cmd.tilt ?? 0;
+	if (tilt > 0) return {
+		spdv: FORWARD_SPEED,
+		spdw: 0
+	};
+	if (tilt < 0) return {
+		spdv: 0,
+		spdw: SPIN
+	};
+	if (pan < 0) return {
+		spdv: 0,
+		spdw: TURN_LEFT
+	};
+	if (pan > 0) return {
+		spdv: 0,
+		spdw: TURN_RIGHT
+	};
+	return {
+		spdv: 0,
+		spdw: 0
+	};
+}
+function moveCall(cmd) {
+	const { spdv, spdw } = driveVector(cmd);
+	return {
+		method: "drive",
+		spdv,
+		spdw
+	};
+}
+/** The explicit halt: a zero drive vector. */
+function stopCall() {
+	return {
+		method: "drive",
+		spdv: 0,
+		spdw: 0
+	};
+}
+/** Fill light on (full) / off (back to auto) — the control that works anytime. */
+function lightOnCall(on) {
+	return {
+		method: "setFillLightAuto",
+		full: on
+	};
+}
+/** Fill-light mode: auto, or manual at `level` (40..100). Camera-service; needs a stream. */
+function lightModeCall(mode, level) {
+	return {
+		method: "setFillLight",
+		value: mode === "auto" ? FILL_LIGHT_AUTO$1 : level ?? 100
+	};
+}
+function lightLevelCall(level) {
+	return lightModeCall("manual", level);
+}
+function playSoundCall(soundId) {
+	return {
+		method: "playSound",
+		soundId
+	};
+}
+function goToPointCall(point) {
+	return {
+		method: "goToPoint",
+		x: point.x,
+		y: point.y
+	};
+}
+/** A discrete {@link NavigationActionId} → the controller method that performs it. */
+function actionCall(actionId) {
+	switch (actionId) {
+		case "goHome": return { method: "returnToDock" };
+		case "locate": return { method: "locate" };
+		case "spotClean": return { method: "spotClean" };
+		case "findPet": return { method: "findPet" };
+		case "personFollow": return { method: "startPersonFollow" };
+		case "stop": return { method: "stopWork" };
+		case "startClean": return {
+			method: "runVacuumAction",
+			action: "startClean"
+		};
+		case "pauseClean": return {
+			method: "runVacuumAction",
+			action: "pauseClean"
+		};
+		case "dockWash": return {
+			method: "runVacuumAction",
+			action: "dockWash"
+		};
+		case "autoEmpty": return {
+			method: "runVacuumAction",
+			action: "autoEmpty"
+		};
+		case "flashOn": return lightOnCall(true);
+		case "flashOff": return lightOnCall(false);
+	}
+}
+/** Perform one call on a controller. Exhaustive — a new method is a compile error here. */
+async function runControllerCall(controller, call) {
+	switch (call.method) {
+		case "drive":
+			await controller.drive(call.spdv, call.spdw);
+			return;
+		case "stopWork":
+			await controller.stopWork();
+			return;
+		case "startPersonFollow":
+			await controller.startPersonFollow();
+			return;
+		case "spotClean":
+			await controller.spotClean();
+			return;
+		case "findPet":
+			await controller.findPet();
+			return;
+		case "playSound":
+			await controller.playSound(call.soundId);
+			return;
+		case "runVacuumAction":
+			await controller.runVacuumAction(call.action);
+			return;
+		case "goToPoint":
+			await controller.goToPoint([[call.x, call.y]], [[call.x, call.y]]);
+			return;
+		case "setFillLight":
+			await controller.setFillLight(call.value);
+			return;
+		case "setFillLightAuto":
+			await controller.setFillLightAuto(call.full);
+			return;
+		case "returnToDock":
+			await controller.returnToDock();
+			return;
+		case "locate":
+			await controller.locate();
+			return;
+	}
+}
+//#endregion
+//#region src/devices/dreame-navigation-config.ts
+/**
+* DATA-DRIVEN feature flags for the Dreame navigation surface. Keeping these as
+* data (rather than branches in the device class) is what makes enabling /
+* disabling a control later a CONFIG change, not a code change — a future step
+* merges per-device / per-addon overrides on top of these defaults before the
+* cap reports them.
+*
+* `goToPoint` ships OFF: the send-to-map-coordinate path needs map-coordinate
+* plumbing (resolving a tap on the live map to robot coordinates) that is not
+* wired yet. Every other primitive defaults ON.
+*/
+var DREAME_NAVIGATION_DEFAULT_FEATURES = {
+	move: true,
+	stop: true,
+	goToPoint: false,
+	runAction: true,
+	playSound: true,
+	light: true,
+	lightMode: true
+};
+/**
+* Dictionary-entry ids disabled by default for Dreame (data-driven per-entry
+* flags). Empty today — every catalog action / sound is enabled. A future
+* config override drops ids in here (or removes them) without touching code.
+*/
+var DREAME_NAVIGATION_DISABLED_ENTRY_IDS = /* @__PURE__ */ new Set();
+/**
+* The action dictionary as THIS provider reports it: the shared catalog with the
+* per-entry `enabled` flag resolved from {@link DREAME_NAVIGATION_DISABLED_ENTRY_IDS}.
+* Pure — the device method just returns this (a later step layers device config
+* on top).
+*/
+function dreameNavigationCatalog(disabledEntryIds = DREAME_NAVIGATION_DISABLED_ENTRY_IDS) {
+	return NAVIGATION_ACTION_CATALOG.map((entry) => ({
+		...entry,
+		enabled: entry.enabled && !disabledEntryIds.has(entry.id)
+	}));
+}
+/** The feature flags in force for ONE device: defaults, then its overrides. */
+function resolveNavigationFeatures(overrides) {
+	return {
+		...DREAME_NAVIGATION_DEFAULT_FEATURES,
+		...overrides?.features ?? {}
+	};
+}
+/** The disabled entry ids in force for ONE device: the addon set plus its own. */
+function resolveDisabledEntryIds(overrides) {
+	return new Set([...DREAME_NAVIGATION_DISABLED_ENTRY_IDS, ...overrides?.disabledEntryIds ?? []]);
+}
+//#endregion
+//#region src/devices/dreame-navigation-ptz-adapter.ts
+/** A gimbal descriptor for a robot: the joystick is pan/tilt, there is no lens. */
+function ptzOptionsFromFeatures(features) {
+	return {
+		hasPan: features.move,
+		hasTilt: features.move,
+		hasZoom: false,
+		supportsPresets: features.runAction || features.playSound,
+		hasAutofocus: false
+	};
+}
+/** Every ENABLED dictionary entry is a preset; the label is the preset name. */
+function presetsFromCatalog(entries, features) {
+	return entries.filter((entry) => entry.enabled).filter((entry) => entry.kind === "action" ? features.runAction : features.playSound).map((entry) => ({
+		id: entry.id,
+		name: entry.label
+	}));
+}
+/**
+* Resolve a preset id back to the navigation call. `null` when the id names
+* nothing enabled — the caller rejects rather than guessing an action.
+*/
+function presetTarget(entries, presetId) {
+	const entry = entries.find((candidate) => candidate.id === presetId && candidate.enabled);
+	if (!entry) return null;
+	if (entry.kind === "sound") return entry.soundId === void 0 ? null : {
+		kind: "sound",
+		soundId: entry.soundId
+	};
+	const parsed = NavigationActionIdSchema.safeParse(entry.id);
+	return parsed.success ? {
+		kind: "action",
+		actionId: parsed.data
+	} : null;
+}
+function clampAxis(value) {
+	if (value === void 0 || !Number.isFinite(value)) return void 0;
+	return Math.max(-1, Math.min(1, value));
+}
+/**
+* A PTZ move is a navigation nudge: pan turns, tilt drives, zoom has no
+* meaning on a chassis and is dropped. Axes are clamped to the cap's [-1, 1].
+*/
+function ptzMoveToNavigation(cmd) {
+	const pan = clampAxis(cmd.pan);
+	const tilt = clampAxis(cmd.tilt);
+	const speed = cmd.speed === void 0 || !Number.isFinite(cmd.speed) ? void 0 : Math.max(0, Math.min(1, cmd.speed));
+	return {
+		...pan !== void 0 ? { pan } : {},
+		...tilt !== void 0 ? { tilt } : {},
+		...speed !== void 0 ? { speed } : {}
+	};
+}
+/** The camera-service fill-light mode/level property. */
+var FILL_LIGHT_SET_SIID = 10001;
+/** The wire value that means "auto" on `fillinLightSet`. */
+var FILL_LIGHT_AUTO = 101;
+function asRecord(raw) {
+	if (typeof raw === "string") try {
+		const parsed = JSON.parse(raw);
+		return parsed !== null && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+	return raw !== null && typeof raw === "object" ? raw : null;
+}
+/** `4/50` → `{ flash }`, only when the packed key is the fill light. */
+function decodeFillLight(raw) {
+	const record = asRecord(raw);
+	if (!record || record["k"] !== "FillinLight") return {};
+	const v = record["v"];
+	if (v === 1 || v === "1" || v === true) return { flash: true };
+	if (v === 0 || v === "0" || v === false) return { flash: false };
+	return {};
+}
+/** `10001/9` → `{ lightMode, lightLevel? }`: 101 is auto, 40..100 a manual level. */
+function decodeFillLightSet(raw) {
+	const n = typeof raw === "string" ? Number(raw) : typeof raw === "number" ? raw : NaN;
+	if (!Number.isFinite(n)) return {};
+	if (n === FILL_LIGHT_AUTO) return { lightMode: "auto" };
+	if (n >= 40 && n <= 100) return {
+		lightMode: "manual",
+		lightLevel: n
+	};
+	return {};
+}
+/** `true` while the robot's own state says it is following; `null` state = not known. */
+function decodeFollowing(state) {
+	if (state === null || state === void 0 || !Number.isFinite(state)) return null;
+	return state === 26;
+}
+/** Everything the robot currently says about its light, as one patch. */
+function decodeNavigationReadback(read) {
+	return {
+		...decodeFillLight(read(4, 50)),
+		...decodeFillLightSet(read(FILL_LIGHT_SET_SIID, 9))
+	};
+}
+//#endregion
+//#region src/devices/dreame-camera-device.ts
+var CAP_NAME$12 = "navigation";
+var NAV_COLD_START = {
+	mode: "unknown",
+	following: false,
+	flash: false,
+	lightMode: "auto",
+	lightLevel: 100,
+	lastChangedAt: 0
+};
+/**
+* Dreame CAMERA + NAVIGATION device — a SEPARATE camstack device from the
+* `DreameVacuumDevice`, spawned only for camera-capable vacuums (those whose
+* `vacuumCapabilities.hasCamera` is true, i.e. a LinkVisual video surface). It
+* owns the `navigation` cap (drive joystick + discrete robot actions + sounds +
+* fill light); the vacuum device keeps `vacuum-control` / `consumables` / maps.
+*
+* PREBUFFER OFF: this is a BATTERY robot whose camera is expensive to cold-start,
+* so the device advertises {@link DeviceFeature.BatteryOperated} — the SAME flag
+* the Reolink battery-camera path uses. The stream-broker's
+* `getEffectivePreBufferSec` battery rule then sets `preBufferSec = 0`, so the
+* stream opens on demand and is never continuously prebuffered.
+*
+* The whole navigation surface goes through nodedreame's typed
+* `DreameCameraController` (1.12+, built lazily from the vacuum handle with the
+* pairing PIN when the camera is coded), mapped by `dreame-navigation-actions.ts`.
+* The controller is never `open()`ed here — the stream is the broker's; drive is
+* valid only while a stream is open, which is when the panel is used.
+*
+* STATUS: `mode` is mapped from the shared vacuum state; `flash` / `lightMode`
+* / `lightLevel` are decoded from the robot's own properties on every push
+* (`dreame-navigation-status.ts`: `4/50` and `10001/9`) and, until the first
+* read-back lands, from the commands this device issued. `following` has no
+* confirmed read-back yet and stays command-driven.
+*
+* PTZ MIMIC: the same device also registers `ptz`, projected from `navigation`
+* through `dreame-navigation-ptz-adapter.ts` (pure, tested) — the joystick is
+* pan/tilt, the enabled actions and sounds are the presets, there is no zoom
+* and no autofocus. `navigation` stays the source of truth; nothing is stored
+* on the PTZ side.
+*/
+var DreameCameraDevice = class extends DreameChildDevice {
+	features = [DeviceFeature.BatteryOperated];
+	constructor(ctx) {
+		super(ctx);
+	}
+	registerControlCap() {
+		const provider = this.buildNavigationProvider();
+		this.ctx.registerNativeCap(navigationCapability, provider);
+		this.runtimeState.setCapState(CAP_NAME$12, NAV_COLD_START);
+		this.ctx.registerNativeCap(ptzCapability, this.buildPtzMimic(provider));
+	}
+	buildNavigationProvider() {
+		return {
+			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$12) ?? NAV_COLD_START,
+			listActions: async () => dreameNavigationCatalog(resolveDisabledEntryIds(this.overrides())),
+			getFeatures: async () => this.buildFeatures(),
+			move: async ({ pan, tilt, speed }) => {
+				await this.dispatch(moveCall({
+					pan,
+					tilt,
+					speed
+				}));
+			},
+			stop: async () => {
+				await this.dispatch(stopCall());
+			},
+			goToPoint: async ({ x, y }) => {
+				await this.dispatch(goToPointCall({
+					x,
+					y
+				}));
+			},
+			runAction: async ({ actionId }) => {
+				await this.dispatch(actionCall(actionId));
+				this.applyOptimisticAction(actionId);
+			},
+			playSound: async ({ soundId }) => {
+				await this.dispatch(playSoundCall(soundId));
+			},
+			setLightOn: async ({ on }) => {
+				await this.dispatch(lightOnCall(on));
+				this.patchStatus({ flash: on });
+			},
+			setLightMode: async ({ mode, level }) => {
+				await this.dispatch(lightModeCall(mode, level));
+				this.patchStatus(mode === "manual" && level !== void 0 ? {
+					lightMode: mode,
+					lightLevel: level
+				} : { lightMode: mode });
+			},
+			setLightLevel: async ({ level }) => {
+				await this.dispatch(lightLevelCall(level));
+				this.patchStatus({
+					lightMode: "manual",
+					lightLevel: level
+				});
+			}
+		};
+	}
+	/**
+	* `ptz` projected from `navigation` (the PTZ-mimic adapter). Every call
+	* forwards to the navigation provider through the pure mapping; a preset
+	* that names nothing enabled is rejected, never guessed.
+	*/
+	buildPtzMimic(nav) {
+		const deviceId = this.id;
+		const noGimbal = (what) => {
+			throw new Error(`DreameCameraDevice: a robot camera has no ${what}`);
+		};
+		return {
+			getStatus: async () => ({
+				pan: 0,
+				tilt: 0,
+				zoom: 0,
+				autofocus: false
+			}),
+			getPosition: async () => ({
+				pan: 0,
+				tilt: 0,
+				zoom: 0
+			}),
+			getOptions: async () => ptzOptionsFromFeatures(await nav.getFeatures({ deviceId })),
+			move: async (cmd) => {
+				await nav.move({
+					deviceId,
+					...ptzMoveToNavigation(cmd)
+				});
+			},
+			continuousMove: async (cmd) => {
+				await nav.move({
+					deviceId,
+					...ptzMoveToNavigation(cmd)
+				});
+			},
+			stop: async () => {
+				await nav.stop({ deviceId });
+			},
+			goHome: async () => {
+				await nav.runAction({
+					deviceId,
+					actionId: "goHome"
+				});
+			},
+			getPresets: async () => presetsFromCatalog(await nav.listActions({ deviceId }), await nav.getFeatures({ deviceId })),
+			goToPreset: async ({ presetId }) => {
+				const target = presetTarget(await nav.listActions({ deviceId }), presetId);
+				if (target === null) throw new Error(`DreameCameraDevice: unknown or disabled navigation preset "${presetId}"`);
+				if (target.kind === "sound") await nav.playSound({
+					deviceId,
+					soundId: target.soundId
+				});
+				else await nav.runAction({
+					deviceId,
+					actionId: target.actionId
+				});
+			},
+			savePreset: async () => noGimbal("saved preset — its presets are its actions"),
+			deletePreset: async () => noGimbal("deletable preset — its presets are its actions"),
+			setAutofocus: async () => noGimbal("autofocus")
+		};
+	}
+	recomputeSlice() {
+		const handle = this.resolveHandle();
+		if (handle === null) return;
+		const prev = this.runtimeState.getCapState(CAP_NAME$12) ?? NAV_COLD_START;
+		const readback = handle instanceof VacuumDevice ? decodeNavigationReadback((siid, piid) => handle.getProperty(siid, piid)?.value) : {};
+		const following = handle instanceof VacuumDevice ? decodeFollowing(handle.status) : null;
+		this.runtimeState.setCapState(CAP_NAME$12, {
+			...prev,
+			...readback,
+			...following !== null ? { following } : {},
+			mode: following === true ? "following" : this.deriveMode(handle),
+			lastChangedAt: Date.now()
+		});
+	}
+	controller = null;
+	controllerHandle = null;
+	/**
+	* The typed controller, built once per live handle (the build resolves the
+	* cloud video profile, so it is a promise shared by every caller); rebuilt
+	* if the handle changes. Never `open()`ed here.
+	*/
+	requireController() {
+		const handle = this.requireHandle();
+		if (!(handle instanceof VacuumDevice)) throw new Error("DreameCameraDevice: the robot handle is not a vacuum — no camera controller");
+		if (this.controller === null || this.controllerHandle !== handle) {
+			const accessCode = this.config.get("navigationAccessCode");
+			this.controllerHandle = handle;
+			this.controller = handle.createCameraController(accessCode !== void 0 && accessCode !== "" ? { accessCode } : {}).catch((err) => {
+				this.controller = null;
+				this.controllerHandle = null;
+				throw err;
+			});
+		}
+		return this.controller;
+	}
+	/** Perform a translated navigation call on the typed controller. */
+	async dispatch(call) {
+		await runControllerCall(await this.requireController(), call);
+	}
+	async removeDevice() {
+		await super.removeDevice();
+		const pending = this.controller;
+		this.controller = null;
+		this.controllerHandle = null;
+		if (pending !== null) await pending.then((controller) => controller.close()).catch(() => void 0);
+	}
+	/** Per-device general-primitive feature flags: the defaults, then this device's overrides. */
+	buildFeatures() {
+		return resolveNavigationFeatures(this.overrides());
+	}
+	/** This device's navigation overrides, straight from its persisted config. */
+	overrides() {
+		const features = this.config.get("navigationFeatures");
+		const disabledEntryIds = this.config.get("navigationDisabledEntryIds");
+		return {
+			...features !== void 0 ? { features } : {},
+			...disabledEntryIds !== void 0 ? { disabledEntryIds } : {}
+		};
+	}
+	/** Map the shared vacuum lifecycle state to a coarse navigation mode. */
+	deriveMode(handle) {
+		if (!(handle instanceof VacuumDevice)) return "unknown";
+		switch (mapMiotStateToVacuumState(handle.status)) {
+			case "cleaning": return "cleaning";
+			case "paused": return "paused";
+			case "returning": return "returning";
+			case "idle":
+			case "docked":
+			case "drying": return "idle";
+			default: return "unknown";
+		}
+	}
+	/**
+	* Optimistically reflect a just-issued action in the status slice so the UI
+	* updates immediately (there is no confirmed read-back yet).
+	*/
+	applyOptimisticAction(actionId) {
+		switch (actionId) {
+			case "flashOn":
+				this.patchStatus({ flash: true });
+				return;
+			case "flashOff":
+				this.patchStatus({ flash: false });
+				return;
+			case "personFollow":
+				this.patchStatus({
+					following: true,
+					mode: "following"
+				});
+				return;
+			case "stop":
+				this.patchStatus({ following: false });
+				return;
+			default: return;
+		}
+	}
+	/**
+	* Merge a patch into the status slice. Written THROUGH `runtimeState` — never a
+	* parallel private cache (CLAUDE.md).
+	*/
+	patchStatus(patch) {
+		const prev = this.runtimeState.getCapState(CAP_NAME$12) ?? NAV_COLD_START;
+		this.runtimeState.setCapState(CAP_NAME$12, {
+			...prev,
+			...patch,
+			lastChangedAt: Date.now()
+		});
+	}
+};
+//#endregion
 //#region src/devices/dreame-enum-sensor-device.ts
 var CAP_NAME$11 = "enum-sensor";
 /** One persisted enum option: the MIoT int value + its display label. */
@@ -94547,12 +97133,12 @@ function mapMowerStatusToActivity(status) {
 	}
 }
 /** Clamp a raw battery reading (0..100 from the library) to the slice field. */
-function clampBatteryLevel$1(value) {
+function clampBatteryLevel(value) {
 	if (value === null || !Number.isFinite(value)) return null;
 	return Math.max(0, Math.min(100, value));
 }
 /** Clamp a 0..100 percentage (mowing progress), null-safe. */
-function clampPercent$1(value) {
+function clampPercent(value) {
 	if (value === null || !Number.isFinite(value)) return null;
 	return Math.max(0, Math.min(100, value));
 }
@@ -94726,11 +97312,11 @@ var DreameMowerDevice = class extends DreameChildDevice {
 		if (mower === null) return;
 		const status = mower.status;
 		const code = mower.faultRaw;
-		const livePct = clampPercent$1(mower.mowingProgressPct);
+		const livePct = clampPercent(mower.mowingProgressPct);
 		const prevPct = this.runtimeState.getCapState(CAP_NAME$9)?.progressPercent;
 		const slice = {
 			activity: mapMowerStatusToActivity(status),
-			batteryLevel: clampBatteryLevel$1(mower.battery),
+			batteryLevel: clampBatteryLevel(mower.battery),
 			progressPercent: livePct ?? prevPct ?? null,
 			currentCode: code,
 			currentCodeLabel: code !== null ? MowerFault[code] ?? null : null,
@@ -95373,204 +97959,21 @@ var DreameSwitchDevice = class extends DreameChildDevice {
 		});
 	}
 };
-//#endregion
-//#region src/dreame-vacuum-decode.ts
-/**
-* Pure decode helpers for the Dreame vacuum. Translate the library's MIoT enum
-* values into the camstack `vacuum-control` slice shape. Unit-tested in
-* isolation (no facade, no network) — mirrors `homematic-decode.ts`.
-*/
-/**
-* Map a Dreame {@link MiotState} (siid 2 piid 1) onto the camstack canonical
-* `VacuumState` lifecycle (`idle` / `cleaning` / `paused` / `returning` /
-* `docked` / `error`). A `null` state (not yet observed) settles on `idle`.
-*
-* The MIoT state space is large (~50 values); we collapse it onto the six
-* canonical states by family. Anything unrecognised falls through to `idle`
-* (the safe neutral) so a firmware-added code never throws.
-*/
-function mapMiotStateToVacuumState(state) {
-	if (state === null) return "idle";
-	switch (state) {
-		case MiotState.Charging:
-		case MiotState.ChargingComplete:
-		case MiotState.IntelligentCharging:
-		case MiotState.CleanWashboardBase:
-		case MiotState.AutoRepairBase:
-		case MiotState.WaterSupplyDrainTest:
-		case MiotState.CleanMopRefillWater:
-		case MiotState.AutoEmptying:
-		case MiotState.Emptying:
-		case MiotState.Draining:
-		case MiotState.AutoWaterDraining:
-		case MiotState.Sanitizing: return "docked";
-		case MiotState.MopDrying:
-		case MiotState.DustBagDrying:
-		case MiotState.SanitizingWithDry: return "drying";
-		case MiotState.ReturningToCharge:
-		case MiotState.ReturningToWash:
-		case MiotState.ReturnInstallMop:
-		case MiotState.ReturnRemoveMop:
-		case MiotState.ReturnToEmpty:
-		case MiotState.ReturningToDrain: return "returning";
-		case MiotState.Paused:
-		case MiotState.PausedAlt:
-		case MiotState.PausedCleaning:
-		case MiotState.DustBagDryingPaused:
-		case MiotState.CameraMonitoringPaused:
-		case MiotState.FindingPetPaused:
-		case MiotState.InitialDeepCleanPaused:
-		case MiotState.ChangingMopPaused:
-		case MiotState.FloorMaintainingPaused: return "paused";
-		case MiotState.Standby:
-		case MiotState.WaitingForTask: return "idle";
-		default: return "cleaning";
-	}
-}
-/**
-* The camstack `fanSpeed` token for a Dreame {@link SuctionLevel} — the enum
-* member NAME, lower-cased (`Quiet` → `'quiet'`). Returns `null` for an
-* unobserved / unknown level.
-*/
-function suctionLevelToken(level) {
-	if (level === null) return null;
-	const name = SuctionLevel[level];
-	return typeof name === "string" ? name.toLowerCase() : null;
-}
-/**
-* Resolve a camstack `fanSpeed` token back to the Dreame {@link SuctionLevel}
-* enum value, validated against the model's `supported` levels. Returns null
-* when the token doesn't match a supported level (the caller rejects the set).
-*/
-function tokenToSuctionLevel(token, supported) {
-	const wanted = token.trim().toLowerCase();
-	for (const level of supported) if (suctionLevelToken(level) === wanted) return level;
-	return null;
-}
-/** The list of accepted `fanSpeed` tokens for a model's supported suction set. */
-function supportedFanSpeedTokens(supported) {
-	const tokens = [];
-	for (const level of supported) {
-		const token = suctionLevelToken(level);
-		if (token !== null) tokens.push(token);
-	}
-	return tokens;
-}
-/**
-* Clamp a raw battery reading (already a 0..100 percentage from the library)
-* to the `vacuum-control` slice's `batteryLevel` field. Returns null for a
-* null/NaN/out-of-band reading so the slice stays valid (the schema rejects
-* a number outside 0..100).
-*/
-function clampBatteryLevel(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/** Clamp a 0..100 percentage (progress, coverage, …), null-safe. */
-function clampPercent(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/**
-* Clean-water tank `status`: prefer the richer clean-water-tank-status (27/1),
-* fall back to the coarser water-tank presence (4/6). `null` when neither maps
-* to a known good/low reading (NOT_INSTALLED / CHECKING / unknown). Pure.
-*/
-function cleanWaterTankStatus(props) {
-	if (props.cleanWaterTankStatus !== null) {
-		if (props.cleanWaterTankStatus === 0) return "ok";
-		if (props.cleanWaterTankStatus === 2) return "low";
-		return null;
-	}
-	if (props.waterTank === 1 || props.waterTank === 10) return "ok";
-	return null;
-}
-/** Detergent tank `status` from detergent-status (27/4). Pure. */
-function detergentTankStatus(value) {
-	if (value === 0) return "ok";
-	if (value === 2) return "low";
-	return null;
-}
-/** Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. Pure. */
-function dustBinTankStatus(value) {
-	if (value === 1) return "ok";
-	if (value === 2) return "full";
-	return null;
-}
-/**
-* The four `vacuum-control` tank fields (clean-water / dirty-water / detergent /
-* dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
-* discrete `status` populated from the live MIoT enum props when supplied. Pure.
-*
-* The nodedreame library exposes NO tank FILL-LEVEL telemetry — the cloud shadow
-* (verified against a real `dreame.vacuum.r2538z`) carries only the water-VOLUME
-* *setting* (a mop-flow level, NOT a tank fill). We therefore never fabricate a
-* `level`; `level` is always `null`. The cap contract is honoured on PRESENCE,
-* with `status` derived from the tank-status enums:
-*
-*   - a field is `null` when the hardware HAS NO such tank (capability flags), and
-*   - `{ level: null, status }` when the tank EXISTS — `status` from the enum
-*     prop ('ok' / 'low' / 'full'), or `null` when the device reports none.
-*
-* Presence is derived from the capability record:
-*   - clean-water  ← `canMop` (a mopping robot carries a clean-water reservoir)
-*   - dirty-water  ← `canMopWash` (a self-wash dock has a recovery/dirty tank)
-*   - detergent    ← `hasDetergentReservoir`
-*   - dust-bin     ← `canAutoEmpty` (an auto-empty robot has an onboard dust bin)
-*/
-function decodeVacuumTanks(caps, props) {
-	const tank = (present, status) => present ? {
-		level: null,
-		status
-	} : null;
+/** `null` = nothing learned (keep the previous slice). */
+function networkLinkFromBars(bars, now) {
+	if (bars === null || !Number.isFinite(bars)) return null;
 	return {
-		cleanWater: tank(Boolean(caps?.canMop), props ? cleanWaterTankStatus(props) : null),
-		dirtyWater: tank(Boolean(caps?.canMopWash), null),
-		detergent: tank(Boolean(caps?.hasDetergentReservoir), props ? detergentTankStatus(props.detergentStatus) : null),
-		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection) : null)
-	};
-}
-/**
-* Clamp a raw consumable percentage to `[0, 100]`, or return `null` when the
-* value is absent / non-finite. The library reports remaining life as a 0..100
-* integer; we clamp defensively so an out-of-range firmware value never violates
-* the cap schema.
-*/
-function clampConsumablePct(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/**
-* Build the `consumables` cap runtime-state slice from a live {@link VacuumDevice}
-* handle. The returned object satisfies the cap's `runtimeState` schema
-* (`ConsumablesStatusSchema.extend({ lastFetchedAt: z.number() })`).
-*
-* PRESENCE-driven (mirrors HA): the library's `supportedConsumables` enumerates
-* ONLY the consumables this model reports (a present MIoT life property) — main/
-* side brush, filter, sensor, tank-filter, mop-pad, silver-ion, detergent,
-* squeegee, dust-bag — each with its remaining-life % and whether a reset action
-* exists. No hardcoded per-model list: a consumable the device does not expose
-* never appears, and a `resettable` item drives the real MIoT reset action.
-*/
-function buildVacuumConsumables(vacuum) {
-	const items = vacuum.supportedConsumables.map((c) => ({
-		key: c.key,
-		label: c.label,
-		level: clampConsumablePct(c.leftPct),
-		status: null,
-		lastResetAt: null,
-		resettable: c.resettable
-	}));
-	const now = Date.now();
-	return {
-		items: [...items],
-		lastChangedAt: now,
-		lastFetchedAt: now
+		type: "wifi",
+		signalPercent: bars === 0 ? null : signalPercentFromBars(bars, 4),
+		lastUpdated: now
 	};
 }
 //#endregion
 //#region src/devices/dreame-vacuum-device.ts
 var CAP_NAME$1 = "vacuum-control";
+var NETWORK_LINK_CAP_NAME = "network-link";
+/** The Wi-Fi signal map is a cloud round trip; the bars at the dock barely move. */
+var NETWORK_LINK_REFRESH_MS = 30 * 6e4;
 var CONSUMABLES_CAP_NAME = "consumables";
 var CONTROL_COLD_START = {
 	state: "idle",
@@ -95626,6 +98029,8 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 	}
 	async onActivate() {
 		await super.onActivate();
+		this.refreshNetworkLink("activate");
+		this.networkLinkTimer = setInterval(() => void this.refreshNetworkLink("periodic"), NETWORK_LINK_REFRESH_MS);
 		const vacuum = this.resolveVacuum();
 		if (vacuum !== null) {
 			vacuum.refreshFromCache().catch((err) => {
@@ -95649,11 +98054,60 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 		}
 	}
 	/** Narrow the generic handle to the library's typed {@link DreameVacuum}, or null. */
+	networkLinkTimer = null;
+	networkLinkReported = false;
+	networkLinkFailureWarned = false;
+	/** `network-link`: the read path serves the slice; `refreshNetworkLink` writes it. */
+	registerNetworkLink() {
+		this.ctx.registerNativeCap(networkLinkCapability, { getStatus: async () => this.runtimeState.getCapState(NETWORK_LINK_CAP_NAME) ?? NETWORK_LINK_UNKNOWN });
+		if (this.runtimeState.getCapState(NETWORK_LINK_CAP_NAME) === null) this.runtimeState.setCapState(NETWORK_LINK_CAP_NAME, NETWORK_LINK_UNKNOWN);
+	}
+	/**
+	* Read the bars at the robot's position off its Wi-Fi signal map. Bounded,
+	* best-effort; a failure keeps the last slice. The first read per device is
+	* said at INFO with the raw bars, the first failure at WARN.
+	*/
+	async refreshNetworkLink(reason) {
+		const vacuum = this.resolveVacuum();
+		if (vacuum === null) return;
+		try {
+			const bars = await vacuum.getCurrentSignal({ maxWaitMs: 2e4 });
+			const next = networkLinkFromBars(bars, Date.now());
+			this.ctx.logger[this.networkLinkReported ? "debug" : "info"]("network link read", {
+				tags: { deviceId: this.id },
+				meta: {
+					reason,
+					rawBars: bars,
+					...next ?? {}
+				}
+			});
+			this.networkLinkReported = true;
+			if (next !== null) this.runtimeState.setCapState(NETWORK_LINK_CAP_NAME, next);
+		} catch (err) {
+			const level = this.networkLinkFailureWarned ? "debug" : "warn";
+			this.networkLinkFailureWarned = true;
+			this.ctx.logger[level]("network link read failed — keeping the last slice", {
+				tags: { deviceId: this.id },
+				meta: {
+					reason,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		}
+	}
+	async removeDevice() {
+		if (this.networkLinkTimer !== null) {
+			clearInterval(this.networkLinkTimer);
+			this.networkLinkTimer = null;
+		}
+		await super.removeDevice();
+	}
 	resolveVacuum() {
 		const handle = this.resolveHandle();
 		return handle instanceof VacuumDevice ? handle : null;
 	}
 	registerControlCap() {
+		this.registerNetworkLink();
 		this.ctx.registerNativeCap(vacuumControlCapability, {
 			getStatus: async () => this.runtimeState.getCapState(CAP_NAME$1) ?? CONTROL_COLD_START,
 			start: async () => {
@@ -95710,14 +98164,14 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 		const tanks = decodeVacuumTanks(vacuum.vacuumCapabilities, this.readTankProps());
 		const controlSlice = {
 			state: mapMiotStateToVacuumState(vacuum.status),
-			batteryLevel: clampBatteryLevel(vacuum.battery),
+			batteryLevel: clampBatteryLevel$1(vacuum.battery),
 			fanSpeed: suctionLevelToken(vacuum.suction),
 			availableFanSpeeds: supportedFanSpeedTokens(vacuum.supportedSuctionLevels),
 			cleanWater: tanks.cleanWater,
 			dirtyWater: tanks.dirtyWater,
 			detergent: tanks.detergent,
 			dustBin: tanks.dustBin,
-			progressPercent: clampPercent(vacuum.taskProgressPct),
+			progressPercent: clampPercent$1(vacuum.taskProgressPct),
 			errorCode: vacuum.errorCode,
 			errorLabel: vacuum.errorCode ? `Error ${vacuum.errorCode}` : null,
 			lastChangedAt: Date.now()
@@ -96043,6 +98497,15 @@ function dreameMowerMapSelectChildFactory(ctx) {
 	return new DreameMowerMapSelectDevice(ctx);
 }
 /**
+* Factory for the CAMERA + NAVIGATION child (a `DeviceType.Camera` grouped under
+* the Container), spawned only for camera-capable vacuums. Owns the `navigation`
+* cap (drive / actions / sounds / fill light). Selected directly by the
+* Container's `getAccessoryChildren()` for the camera child spec.
+*/
+function dreameCameraChildFactory(ctx) {
+	return new DreameCameraDevice(ctx);
+}
+/**
 * Factory for an AI-obstacle Switch child (a `DeviceType.Switch` grouped under
 * the Container). Like {@link dreameMapChildFactory}, selected directly by the
 * Container's `getAccessoryChildren()` — the child config carries the
@@ -96214,6 +98677,20 @@ var DreameContainerDevice = class extends BaseDevice {
 				factory: dreameMapChildFactory
 			});
 		}
+		if (kind === "vacuum" && this.modelSupportsCamera()) {
+			const cameraMeta = {
+				type: DeviceType.Camera,
+				name: this.name.length > 0 ? `${this.name} Camera` : "Camera",
+				linkDeviceId: this.id,
+				...this.integrationId !== void 0 ? { integrationId: this.integrationId } : {}
+			};
+			children.push({
+				stableIdSuffix: "camera",
+				meta: cameraMeta,
+				config,
+				factory: dreameCameraChildFactory
+			});
+		}
 		if (kind === "vacuum") {
 			for (const feature of this.supportedAiFeatures()) {
 				const switchMeta = {
@@ -96647,6 +99124,7 @@ var DreameContainerDevice = class extends BaseDevice {
 		const caps = handle.vacuumCapabilities;
 		return {
 			canMap: caps.canMap,
+			hasCamera: caps.hasCamera,
 			hasAiObstacleDetection: caps.hasAiObstacleDetection,
 			aiFeatureCount: caps.hasAiObstacleDetection ? caps.supportedAiFeatures.length : 0
 		};
@@ -96674,6 +99152,12 @@ var DreameContainerDevice = class extends BaseDevice {
 	modelSupportsMap() {
 		return vacuumSupportsMap(this.resolveVacuumCaps());
 	}
+	/** Whether this vacuum model carries an on-board camera — gates the separate
+	*  camera + navigation child. Gated on the RESOLVED handle's confirmed
+	*  capability (false when the handle is not up, never optimistic). */
+	modelSupportsCamera() {
+		return vacuumSupportsCamera(this.resolveVacuumCaps());
+	}
 	/** Whether this mower model supports a map — gated on the RESOLVED handle's
 	*  confirmed capability (false when the handle is not up, never optimistic). */
 	modelSupportsMowerMap() {