@camstack/addon-provider-dreame 0.2.70 → 0.2.72

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID } from "crypto";
 import { EventEmitter } from "events";
 import * as zlib from "zlib";
 //#region \0rolldown/runtime.js
@@ -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 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": 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 ?? 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 ?? 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: 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 createHash("md5").update(`${accountId}_${now}`).digest("hex");
+}
+function hashAccessCode(code) {
+	return 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) {
@@ -55911,6 +57117,12 @@ Object.fromEntries([
 		icon: "move",
 		order: 40
 	},
+	{
+		id: "navigation",
+		label: "Navigation",
+		icon: "compass",
+		order: 41
+	},
 	{
 		id: "consumables",
 		label: "Consumables",
@@ -74306,6 +75518,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 +75561,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
@@ -79494,6 +80717,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 +84410,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	motionTrigger: motionTriggerCapability,
 	motionZones: motionZonesCapability,
 	nativeObjectDetection: nativeObjectDetectionCapability,
+	navigation: navigationCapability,
 	networkLink: networkLinkCapability,
 	notifier: notifierCapability,
 	numericSensor: numericSensorCapability,
@@ -86623,6 +88265,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 +92420,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 +95652,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 +95761,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 +95823,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 +95867,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 +95908,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 +95956,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 +95976,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 +95985,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 +96040,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 +96048,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 +96100,884 @@ 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-camera-stream.ts
+/** The one stream the robot camera offers. Half of the broker id (`<deviceId>/live`). */
+var CAMERA_STREAM_ID = "live";
+/** How often an open monitor asks the broker whether anybody is still watching. */
+var IDLE_CHECK_MS = 6e4;
+/** `ChargingStatus` as the robot reports it (siid 3 piid 2, VERIFIED r2532a). */
+var CHARGING_STATUS_CHARGING = 1;
+function clampLevel(level) {
+	if (level === null || !Number.isFinite(level)) return null;
+	return Math.max(0, Math.min(100, level));
+}
+/**
+* The battery slice the broker reads before a play: `sleeping` decides
+* whether it asks for a wake, `lastContactAt` decides whether it refuses to
+* (`deriveBatteryPresence` calls hours of silence "unreachable"). A contact
+* of 0 would read as "never heard" — the field is omitted instead.
+*/
+function cameraBatterySlice(facts) {
+	const charging = facts.charging === null ? "unknown" : facts.charging === CHARGING_STATUS_CHARGING ? "dc" : "none";
+	return {
+		percentage: clampLevel(facts.level),
+		charging,
+		sleeping: !facts.streamOpen,
+		lastUpdated: facts.now,
+		...facts.contactAt !== null && facts.contactAt > 0 ? { lastContactAt: facts.contactAt } : {}
+	};
+}
+/** One `pull-rtmp` descriptor while the monitor is open; nothing while it is closed. */
+function cameraStreamCatalog(session) {
+	if (session === null) return [];
+	return [{
+		camStreamId: CAMERA_STREAM_ID,
+		kind: "pull-rtmp",
+		url: session.url,
+		codec: "h264",
+		label: "Robot camera",
+		deviceFeatures: ["battery-operated"],
+		autoEligible: true
+	}];
+}
+/**
+* Somebody WATCHING is a reason to keep the monitor open: an RTSP client, a
+* WebRTC session (an `encoded` subscriber), an audio listener. The detection
+* pipeline is deliberately NOT one — it subscribes decoded frames for as long
+* as a stream exists, so counting it would keep the robot's relay open, on
+* its battery and through the cloud, until the battery died. It rides along
+* while a viewer watches and stops when the monitor closes.
+*/
+function isBrokerBusy(clients) {
+	return clients.rtsp.length > 0 || clients.encoded.length > 0 || clients.audio.length > 0;
+}
+/** Consecutive idle checks; a busy check starts the count over. */
+function nextIdleCount(previous, busy) {
+	return busy ? 0 : previous + 1;
+}
+function shouldCloseForIdle(idleCount) {
+	return idleCount >= 3;
+}
+//#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 ?? []]);
+}
+/** 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";
+/**
+* The slice as WRITTEN: the cap's runtime-state shape (status + `lastFetchedAt`).
+* `setCapState` validates against it, so a status-only object throws at
+* activation and registers nothing — which is how the first deploy shipped
+* a camera with no navigation and no PTZ.
+*/
+var NAV_COLD_START = {
+	mode: "unknown",
+	following: false,
+	flash: false,
+	lightMode: "auto",
+	lightLevel: 100,
+	lastChangedAt: 0,
+	lastFetchedAt: 0
+};
+/** The next slice: the previous one, the patch, and both clocks stamped `now`. */
+function navigationSlice(prev, patch, now) {
+	return {
+		...prev,
+		...patch,
+		lastChangedAt: now,
+		lastFetchedAt: now
+	};
+}
+/**
+* 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.
+*
+* `navigation` is its own capability, deliberately NOT projected as `ptz`: a
+* gimbal and a chassis are different physical models, and the operator asked
+* for two separate things (admin UI: two tabs; viewer: one panel that shows the
+* navigation controls when the device has the cap).
+*/
+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.registerBatteryCap();
+		this.registerStreamCatalogCap();
+	}
+	/** The relay the current `open()` handed out; null while the monitor is closed. */
+	session = null;
+	/** A single in-flight `open()` — two plays must not cold-start the robot twice. */
+	opening = null;
+	idleTimer = null;
+	idleCount = 0;
+	/** Last time the robot said anything (a state change) — the wake refusal's evidence. */
+	lastContactAt = null;
+	registerBatteryCap() {
+		this.ctx.registerNativeCap(batteryCapability, { wakeForStream: async ({ timeoutMs }) => this.wakeForStream(timeoutMs) });
+		this.publishBattery();
+		this.runtimeState.subscribeCap(batteryCapability.name, (slice) => {
+			if (!slice) return;
+			this.ctx.eventBus.emit(createEvent(EventCategory.BatteryOnStatusChanged, {
+				type: "device",
+				id: this.stableId
+			}, {
+				deviceId: this.id,
+				status: slice
+			}));
+		});
+	}
+	registerStreamCatalogCap() {
+		this.ctx.registerNativeCap(streamCatalogCapability, { getCatalog: async ({ deviceId }) => deviceId === this.id ? cameraStreamCatalog(this.session) : [] });
+		this.publishCatalog();
+	}
+	publishBattery() {
+		const handle = this.resolveHandle();
+		const vacuum = handle instanceof VacuumDevice ? handle : null;
+		this.setCapSlice(batteryCapability, cameraBatterySlice({
+			level: vacuum?.battery ?? null,
+			charging: vacuum?.charging ?? null,
+			streamOpen: this.session !== null,
+			now: Date.now(),
+			contactAt: this.lastContactAt
+		}));
+	}
+	publishCatalog() {
+		this.runtimeState.setCapState(streamCatalogCapability.name, {
+			descriptors: [...cameraStreamCatalog(this.session)],
+			lastFetchedAt: Date.now()
+		});
+	}
+	/**
+	* `battery.wakeForStream`: open the monitor inside the caller's bound. An
+	* open that outlives the bound keeps running — the next play joins it.
+	*/
+	async wakeForStream(timeoutMs) {
+		const startedAt = Date.now();
+		if (this.session !== null) return {
+			awoke: true,
+			durationMs: 0
+		};
+		const opened = this.openStream().then(() => "open", () => "failed");
+		const bound = new Promise((resolve) => {
+			setTimeout(() => resolve("timeout"), timeoutMs).unref?.();
+		});
+		const outcome = await Promise.race([opened, bound]);
+		if (outcome === "timeout") this.ctx.logger.info("robot camera: the wake outlived its bound — the open keeps running", {
+			tags: { deviceId: this.id },
+			meta: { timeoutMs }
+		});
+		return {
+			awoke: outcome === "open",
+			durationMs: Date.now() - startedAt
+		};
+	}
+	openStream() {
+		if (this.opening !== null) return this.opening;
+		const run = (async () => {
+			const startedAt = Date.now();
+			try {
+				const handle = await (await this.requireController()).open();
+				this.session = { url: handle.rtmpUrl };
+				this.idleCount = 0;
+				this.publishBattery();
+				this.publishCatalog();
+				this.startIdleWatch();
+				this.ctx.logger.info("robot camera: monitor open, relay published to the catalog", {
+					tags: { deviceId: this.id },
+					meta: { openMs: Date.now() - startedAt }
+				});
+			} catch (err) {
+				this.ctx.logger.warn("robot camera: monitor could not be opened", {
+					tags: { deviceId: this.id },
+					meta: {
+						openMs: Date.now() - startedAt,
+						error: errMsg(err)
+					}
+				});
+				throw err;
+			}
+		})();
+		this.opening = run.finally(() => {
+			this.opening = null;
+		});
+		return this.opening;
+	}
+	async closeStream(reason) {
+		this.stopIdleWatch();
+		if (this.session === null) return;
+		this.session = null;
+		this.publishBattery();
+		this.publishCatalog();
+		this.ctx.logger.info("robot camera: monitor closed", {
+			tags: { deviceId: this.id },
+			meta: { reason }
+		});
+		const pending = this.controller;
+		if (pending === null) return;
+		await pending.then((controller) => controller.close()).catch((err) => {
+			this.ctx.logger.debug("robot camera: close reported an error", {
+				tags: { deviceId: this.id },
+				meta: {
+					reason,
+					error: errMsg(err)
+				}
+			});
+		});
+	}
+	startIdleWatch() {
+		this.stopIdleWatch();
+		this.idleTimer = setInterval(() => {
+			this.checkIdle();
+		}, IDLE_CHECK_MS);
+		this.idleTimer.unref?.();
+	}
+	stopIdleWatch() {
+		if (this.idleTimer !== null) clearInterval(this.idleTimer);
+		this.idleTimer = null;
+		this.idleCount = 0;
+	}
+	/** Ask the broker whether anybody is still watching; no broker at all counts as idle. */
+	async checkIdle() {
+		if (this.session === null) return;
+		const clients = await this.ctx.api.streamBroker.listClients.query({ brokerId: `${String(this.id)}/${CAMERA_STREAM_ID}` }).catch(() => null);
+		const busy = clients !== null && isBrokerBusy(clients);
+		this.idleCount = nextIdleCount(this.idleCount, busy);
+		if (shouldCloseForIdle(this.idleCount)) await this.closeStream("idle");
+	}
+	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
+				});
+			}
+		};
+	}
+	recomputeSlice() {
+		const handle = this.resolveHandle();
+		if (handle === null) return;
+		this.lastContactAt = Date.now();
+		this.publishBattery();
+		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, navigationSlice(prev, {
+			...readback,
+			...following !== null ? { following } : {},
+			mode: following === true ? "following" : this.deriveMode(handle)
+		}, 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 } : {},
+				onKeepAliveError: (err) => {
+					this.ctx.logger.warn("robot camera: relay keep-alive failed — closing the monitor", {
+						tags: { deviceId: this.id },
+						meta: { error: errMsg(err) }
+					});
+					this.closeStream("keep-alive");
+				}
+			}).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();
+		await this.closeStream("removed");
+		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, navigationSlice(prev, patch, 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 +97202,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 +97381,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 +98028,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 +98098,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 +98123,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 +98233,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 +98566,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 +98746,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 +99193,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 +99221,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() {
@@ -97571,4 +100124,4 @@ var DreameProviderAddon = class extends BaseDeviceProvider {
 	}
 };
 //#endregion
-export { DreameProviderAddon, mapMowerStatusToActivity as a, deviceTypeForKind as c, dreameConfigSchema as d, toNodreameOptions as f, tokenToSuctionLevel as i, buildConnectionFormSchema as l, suctionLevelToken as n, classifyDreameModel as o, supportedFanSpeedTokens as r, controlCapForKind as s, mapMiotStateToVacuumState as t, connectionFromSettings as u };
+export { DreameProviderAddon, tokenToSuctionLevel as a, deviceTypeForKind as c, dreameConfigSchema as d, toNodreameOptions as f, supportedFanSpeedTokens as i, buildConnectionFormSchema as l, mapMiotStateToVacuumState as n, classifyDreameModel as o, suctionLevelToken as r, controlCapForKind as s, mapMowerStatusToActivity as t, connectionFromSettings as u };