@apocaliss92/nodedreame 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3827 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseDevice: () => BaseDevice,
+  ChargingStatus: () => ChargingStatus,
+  CleaningMode: () => CleaningMode,
+  DefaultCapabilityResolver: () => DefaultCapabilityResolver,
+  DreameApiError: () => DreameApiError,
+  DreameAuthError: () => DreameAuthError,
+  DreameDeviceOfflineError: () => DreameDeviceOfflineError,
+  DreameError: () => DreameError,
+  DreameTransportError: () => DreameTransportError,
+  LIBRARY_NAME: () => LIBRARY_NAME,
+  MOWER_MODEL_CAPABILITIES: () => MODEL_CAPABILITIES2,
+  MiotError: () => MiotError,
+  MiotState: () => MiotState,
+  MowerCapabilityResolver: () => MowerCapabilityResolver,
+  MowerChargingStatus: () => MowerChargingStatus,
+  MowerControlAction: () => MowerControlAction,
+  MowerDevice: () => MowerDevice,
+  MowerStatus: () => MowerStatus,
+  MowerTaskStatus: () => MowerTaskStatus,
+  Nodreame: () => Nodreame,
+  SuctionLevel: () => SuctionLevel,
+  TaskStatus: () => TaskStatus,
+  VACUUM_MODEL_CAPABILITIES: () => MODEL_CAPABILITIES,
+  VacuumCapabilityResolver: () => VacuumCapabilityResolver,
+  VacuumDevice: () => VacuumDevice,
+  WaterVolume: () => WaterVolume,
+  getMowerCapabilities: () => getMowerCapabilities,
+  getVacuumCapabilities: () => getVacuumCapabilities,
+  renderMowerSvg: () => renderMowerSvg,
+  renderVacuumPng: () => renderVacuumPng,
+  resolveCapabilities: () => resolveCapabilities
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/support/version.ts
+var LIBRARY_NAME = "nodedreame";
+
+// src/transport/errors.ts
+var DreameError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DreameError";
+  }
+  cause;
+};
+var DreameAuthError = class extends DreameError {
+  constructor(message, status, cause) {
+    super(message, cause);
+    this.status = status;
+    this.name = "DreameAuthError";
+  }
+  status;
+};
+var DreameApiError = class extends DreameError {
+  constructor(message, status, body, cause) {
+    super(message, cause);
+    this.status = status;
+    this.body = body;
+    this.name = "DreameApiError";
+  }
+  status;
+  body;
+};
+var DreameDeviceOfflineError = class extends DreameApiError {
+  constructor(message, status, body) {
+    super(message, status, body);
+    this.name = "DreameDeviceOfflineError";
+  }
+};
+var DreameTransportError = class extends DreameError {
+  constructor(message, cause) {
+    super(message, cause);
+    this.name = "DreameTransportError";
+  }
+};
+
+// src/transport/crypto.ts
+var import_node_crypto = require("crypto");
+var PASSWORD_SALT = "RAylYC%fmSKp7%Tq";
+var RLC_AES_KEY = "EETjszu*XI5znHsI";
+function hashPassword(plaintext) {
+  return (0, import_node_crypto.createHash)("md5").update(plaintext + PASSWORD_SALT).digest("hex");
+}
+function buildRlcHeader(region, lang, country) {
+  const plaintext = `${region}|${lang}|${country}`;
+  const cipher = (0, import_node_crypto.createCipheriv)("aes-128-ecb", Buffer.from(RLC_AES_KEY, "utf8"), null);
+  const out = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  return out.toString("hex");
+}
+function randomMqttClientId() {
+  return "p_" + (0, import_node_crypto.randomBytes)(8).toString("hex");
+}
+function randomRequestId() {
+  return Math.floor(Math.random() * 2147483647) + 1;
+}
+
+// src/auth/config.ts
+var REGION_HOSTS = {
+  eu: "eu.iot.dreame.tech:13267",
+  us: "us.iot.dreame.tech:13267",
+  cn: "cn.iot.dreame.tech:13267",
+  ru: "ru.iot.dreame.tech:13267",
+  sg: "sg.iot.dreame.tech:13267",
+  in: "in.iot.dreame.tech:13267",
+  de: "eu.iot.dreame.tech:13267",
+  tw: "cn.iot.dreame.tech:13267"
+};
+var REGION_DEFAULT_COUNTRY = {
+  eu: "GB",
+  us: "US",
+  cn: "CN",
+  ru: "RU",
+  sg: "SG",
+  in: "IN",
+  de: "DE",
+  tw: "TW"
+};
+var REGION_DEFAULT_LANG = {
+  eu: "en",
+  us: "en",
+  cn: "zh",
+  ru: "ru",
+  sg: "en",
+  in: "en",
+  de: "de",
+  tw: "zh"
+};
+var OAUTH_BASIC_AUTH = "Basic ZHJlYW1lX2FwcHYxOkFQXmR2QHpAU1FZVnhOODg=";
+var APP_META = "cv=i_829";
+var APP_USER_AGENT = "Dart/3.2 (dart:io)";
+var TENANT_DREAME = "000000";
+var COMMAND_FROM_FIELD = "XXXXXX";
+var IOT_COM_PREFIX_DREAME = 1e4;
+var CONTENT_TYPE_JSON = "application/json";
+var CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";
+
+// src/transport/headers.ts
+function buildHeaders(opts) {
+  const auth = opts.accessToken ? `bearer ${opts.accessToken}` : "bearer";
+  return {
+    "user-agent": APP_USER_AGENT,
+    authorization: OAUTH_BASIC_AUTH,
+    "content-type": opts.contentType ?? CONTENT_TYPE_FORM,
+    "dreame-auth": auth,
+    "dreame-meta": APP_META,
+    "dreame-rlc": buildRlcHeader(opts.region, opts.lang, opts.country),
+    "tenant-id": TENANT_DREAME
+  };
+}
+
+// src/transport/fetch.ts
+var import_undici = require("undici");
+var defaultFetch = import_undici.fetch;
+
+// src/transport/http.ts
+var CODE_DEVICE_OFFLINE = 80001;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var RequestContext = class _RequestContext {
+  region;
+  country;
+  lang;
+  host;
+  fetchImpl;
+  constructor(opts) {
+    this.region = opts.region;
+    this.country = opts.country ?? REGION_DEFAULT_COUNTRY[opts.region];
+    this.lang = opts.lang ?? REGION_DEFAULT_LANG[opts.region];
+    this.host = opts.host ?? REGION_HOSTS[opts.region];
+    this.fetchImpl = opts.fetchImpl ?? defaultFetch;
+  }
+  static from(input) {
+    return new _RequestContext({
+      region: input.region,
+      ...input.country !== void 0 ? { country: input.country } : {},
+      ...input.lang !== void 0 ? { lang: input.lang } : {},
+      ...input.host !== void 0 ? { host: input.host } : {},
+      ...input.fetchImpl !== void 0 ? { fetchImpl: input.fetchImpl } : {}
+    });
+  }
+  /** `https://<host><path>` — pass a path with a leading slash. */
+  url(path) {
+    return `https://${this.host}${path}`;
+  }
+  /** Build the static Dreame headers, optionally with a bearer token + content-type. */
+  headers(opts = {}) {
+    return buildHeaders({
+      region: this.region,
+      country: this.country,
+      lang: this.lang,
+      ...opts.accessToken !== void 0 ? { accessToken: opts.accessToken } : {},
+      ...opts.contentType !== void 0 ? { contentType: opts.contentType } : {}
+    });
+  }
+};
+async function httpPostJson(input) {
+  const Err = input.errorClass ?? DreameApiError;
+  const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const signal = composeSignals(input.signal, timeoutMs);
+  let res;
+  try {
+    res = await input.ctx.fetchImpl(input.url, {
+      method: "POST",
+      headers: input.headers,
+      body: input.body,
+      ...signal !== void 0 ? { signal } : {}
+    });
+  } catch (err) {
+    if (isAbortError(err)) {
+      throw new DreameTransportError(
+        `request to ${input.url} aborted after ${timeoutMs}ms or by caller`,
+        err
+      );
+    }
+    throw new DreameTransportError(`network error contacting ${input.url}`, err);
+  }
+  const text = await res.text();
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    throw new Err(
+      `${input.context} failed: ${res.status} ${text.slice(0, 200)}`,
+      res.status,
+      parsed
+    );
+  }
+  if (!parsed) {
+    throw new Err(`${input.context} response was not JSON (status ${res.status})`, res.status);
+  }
+  if (!input.skipCodeCheck && parsed.code !== void 0 && parsed.code !== 0) {
+    if (parsed.code === CODE_DEVICE_OFFLINE) {
+      throw new DreameDeviceOfflineError(
+        `device offline: ${parsed.msg ?? "timeout"}`,
+        res.status,
+        parsed
+      );
+    }
+    throw new Err(
+      `${input.context} rejected: code=${parsed.code} msg=${parsed.msg ?? "?"}`,
+      res.status,
+      parsed
+    );
+  }
+  return parsed;
+}
+async function httpPostJsonBody(input) {
+  return httpPostJson({
+    ctx: input.ctx,
+    url: input.ctx.url(input.path),
+    headers: input.ctx.headers({
+      ...input.accessToken !== void 0 ? { accessToken: input.accessToken } : {},
+      contentType: CONTENT_TYPE_JSON
+    }),
+    body: JSON.stringify(input.body),
+    context: input.context,
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+    ...input.signal !== void 0 ? { signal: input.signal } : {}
+  });
+}
+function composeSignals(callerSignal, timeoutMs) {
+  if (timeoutMs <= 0) {
+    return callerSignal;
+  }
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (!callerSignal) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([callerSignal, timeoutSignal]);
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+
+// src/transport/schemas.ts
+var import_zod = require("zod");
+var OAuthTokenResponseSchema = import_zod.z.object({
+  access_token: import_zod.z.string().optional(),
+  refresh_token: import_zod.z.string().optional(),
+  expires_in: import_zod.z.number().optional(),
+  token_type: import_zod.z.string().optional(),
+  uid: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  region: import_zod.z.string().optional(),
+  country: import_zod.z.string().optional(),
+  lang: import_zod.z.string().optional(),
+  tenant_id: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional(),
+  error_description: import_zod.z.string().optional(),
+  code: import_zod.z.number().optional(),
+  msg: import_zod.z.string().optional()
+}).passthrough();
+var RawDeviceSchema = import_zod.z.object({
+  did: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  model: import_zod.z.string().optional(),
+  customName: import_zod.z.string().optional(),
+  deviceName: import_zod.z.string().optional(),
+  mac: import_zod.z.string().optional(),
+  online: import_zod.z.boolean().optional(),
+  lwt: import_zod.z.number().optional(),
+  bindDomain: import_zod.z.string().optional(),
+  master: import_zod.z.boolean().optional()
+}).passthrough();
+var DeviceListResponseSchema = import_zod.z.object({
+  code: import_zod.z.number().optional(),
+  msg: import_zod.z.string().optional(),
+  data: import_zod.z.object({
+    page: import_zod.z.object({ records: import_zod.z.array(RawDeviceSchema).optional() }).partial().optional(),
+    records: import_zod.z.array(RawDeviceSchema).optional()
+  }).passthrough().optional(),
+  records: import_zod.z.array(RawDeviceSchema).optional()
+}).passthrough();
+var PropertyResultSchema = import_zod.z.object({
+  siid: import_zod.z.number().optional(),
+  piid: import_zod.z.number().optional(),
+  value: import_zod.z.unknown().optional(),
+  code: import_zod.z.number().optional()
+}).passthrough();
+var SendCommandResponseSchema = import_zod.z.object({
+  code: import_zod.z.number().optional(),
+  msg: import_zod.z.string().optional(),
+  data: import_zod.z.object({ result: import_zod.z.unknown().optional() }).passthrough().optional(),
+  result: import_zod.z.unknown().optional()
+}).passthrough();
+var RawMqttEventSchema = import_zod.z.object({
+  id: import_zod.z.number().optional(),
+  did: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).optional(),
+  data: import_zod.z.object({
+    id: import_zod.z.number().optional(),
+    method: import_zod.z.string().optional(),
+    params: import_zod.z.unknown().optional()
+  }).passthrough().optional()
+}).passthrough();
+
+// src/auth/dreame-account.ts
+function ctxFromInput(input) {
+  return RequestContext.from({ ...input, host: input.authHost });
+}
+async function login(input) {
+  const ctx = ctxFromInput(input);
+  const body = new URLSearchParams({
+    grant_type: "password",
+    scope: "all",
+    platform: "IOS",
+    type: "account",
+    username: input.email,
+    password: hashPassword(input.password),
+    country: ctx.country,
+    lang: ctx.lang
+  });
+  return postForToken(ctx, body);
+}
+async function refresh(input) {
+  const ctx = ctxFromInput(input);
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: input.refreshToken
+  });
+  return postForToken(ctx, body);
+}
+async function postForToken(ctx, body) {
+  const raw = await httpPostJson({
+    ctx,
+    url: ctx.url("/dreame-auth/oauth/token"),
+    headers: ctx.headers(),
+    body,
+    context: "auth",
+    errorClass: DreameAuthError,
+    skipCodeCheck: true
+    // OAuth uses HTTP status + top-level error fields, not parsed.code
+  });
+  const data = OAuthTokenResponseSchema.parse(raw);
+  if (data.error || data.error_description) {
+    throw new DreameAuthError(
+      `auth failed: ${data.error ?? "?"} \u2014 ${data.error_description ?? "no description"}`
+    );
+  }
+  if (!data.access_token) {
+    throw new DreameAuthError(
+      `auth response missing access_token: uid=${data.uid ?? "?"} error=${data.error ?? "?"} code=${data.code ?? "?"}`
+    );
+  }
+  const expiresIn = typeof data.expires_in === "number" ? data.expires_in : 7200;
+  const uid = data.uid !== void 0 ? String(data.uid) : "";
+  if (!uid) {
+    throw new DreameAuthError("auth response missing uid");
+  }
+  const session = {
+    accessToken: data.access_token,
+    uid,
+    expiresAt: Date.now() + expiresIn * 1e3,
+    region: ctx.region
+  };
+  if (typeof data.refresh_token === "string") {
+    session.refreshToken = data.refresh_token;
+  }
+  return session;
+}
+
+// src/cloud/devices.ts
+async function listDevices(input) {
+  const ctx = input.ctx ?? RequestContext.from({ ...input, host: input.apiHost });
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: "/dreame-user-iot/iotuserbind/device/listV2",
+    accessToken: input.session.accessToken,
+    body: {
+      sharedStatus: 1,
+      current: 1,
+      size: 100,
+      lang: ctx.lang,
+      timestamp: Date.now()
+    },
+    context: "device list",
+    ...input.signal !== void 0 ? { signal: input.signal } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+  });
+  const parsed = DeviceListResponseSchema.parse(raw);
+  const records = parsed.data?.page?.records ?? parsed.data?.records ?? parsed.records ?? [];
+  return records.map(toDevice);
+}
+function toDevice(rawIn) {
+  const raw = rawIn;
+  const did = String(rawIn.did ?? "");
+  const model = String(rawIn.model ?? "");
+  const name = String(rawIn.customName || rawIn.deviceName || model || did);
+  let lwtFlag = 0;
+  if (typeof raw["property"] === "string") {
+    try {
+      const p = JSON.parse(raw["property"]);
+      if (p && typeof p.lwt === "number") {
+        lwtFlag = p.lwt;
+      }
+    } catch {
+    }
+  }
+  const online = rawIn.online === true || rawIn.lwt === 1 || lwtFlag === 1;
+  const device = {
+    did,
+    model,
+    name,
+    online,
+    raw,
+    cloudState: parseCloudState(raw)
+  };
+  if (rawIn.mac) {
+    device.mac = String(rawIn.mac);
+  }
+  if (typeof raw["ver"] === "string") {
+    device.firmwareVersion = raw["ver"];
+  }
+  if (typeof raw["sn"] === "string") {
+    device.serialNumber = raw["sn"];
+  }
+  return device;
+}
+function parseCloudState(raw) {
+  const latestStatus = typeof raw["latestStatus"] === "number" ? raw["latestStatus"] : null;
+  const battery = typeof raw["battery"] === "number" ? raw["battery"] : null;
+  const featureCode2 = typeof raw["featureCode2"] === "number" ? raw["featureCode2"] : null;
+  let videoActive = null;
+  if (typeof raw["videoStatus"] === "string") {
+    try {
+      const v = JSON.parse(raw["videoStatus"]);
+      if (v?.operType === "end" || v?.status === 0) {
+        videoActive = false;
+      } else if (v?.operType || v?.status) {
+        videoActive = true;
+      }
+    } catch {
+    }
+  }
+  return { latestStatus, battery, videoActive, featureCode2 };
+}
+
+// src/cloud/commands.ts
+var import_zod2 = require("zod");
+async function sendCommand(input) {
+  const ctx = input.ctx ?? RequestContext.from({ ...input, host: input.apiHost });
+  const prefix = input.iotComPrefix ?? IOT_COM_PREFIX_DREAME;
+  const id = randomRequestId();
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: `/dreame-iot-com-${prefix}/device/sendCommand`,
+    accessToken: input.session.accessToken,
+    body: {
+      did: input.did,
+      id,
+      data: {
+        did: input.did,
+        id,
+        method: input.method,
+        params: input.params,
+        from: COMMAND_FROM_FIELD
+      }
+    },
+    context: input.method,
+    ...input.signal !== void 0 ? { signal: input.signal } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+  });
+  return SendCommandResponseSchema.parse(raw);
+}
+async function getProperties(base, props, opts = {}) {
+  const params = props.map((p) => ({ did: base.did, siid: p.siid, piid: p.piid }));
+  const res = await sendCommand({ ...base, ...opts, method: "get_properties", params });
+  return extractResultArray(res, "get_properties");
+}
+async function setProperties(base, writes, opts = {}) {
+  const params = writes.map((p) => ({
+    did: base.did,
+    siid: p.siid,
+    piid: p.piid,
+    value: p.value
+  }));
+  const res = await sendCommand({ ...base, ...opts, method: "set_properties", params });
+  return extractResultArray(res, "set_properties");
+}
+async function callAction(base, action, opts = {}) {
+  const params = {
+    did: base.did,
+    siid: action.siid,
+    aiid: action.aiid,
+    in: action.in ?? []
+  };
+  const res = await sendCommand({ ...base, ...opts, method: "action", params });
+  return res.data?.result ?? res.result ?? res;
+}
+function extractResultArray(res, context) {
+  const raw = Array.isArray(res.data?.result) ? res.data.result : Array.isArray(res.result) ? res.result : null;
+  if (raw === null) {
+    throw new DreameApiError(
+      `${context}: response did not contain a result array \u2014 ${JSON.stringify(res).slice(0, 200)}`,
+      200,
+      res
+    );
+  }
+  const parsed = import_zod2.z.array(PropertyResultSchema).safeParse(raw);
+  if (!parsed.success) {
+    throw new DreameApiError(
+      `${context}: result array contained a non-object element \u2014 ${JSON.stringify(raw).slice(0, 200)}`,
+      200,
+      res
+    );
+  }
+  return parsed.data;
+}
+
+// src/transport/mqtt-push.ts
+var import_mqtt = __toESM(require("mqtt"), 1);
+
+// src/transport/typed-emitter.ts
+var import_node_events = require("events");
+var TypedEmitter = class {
+  #emitter = new import_node_events.EventEmitter();
+  on(event, listener) {
+    this.#emitter.on(event, listener);
+    return this;
+  }
+  once(event, listener) {
+    this.#emitter.once(event, listener);
+    return this;
+  }
+  off(event, listener) {
+    this.#emitter.off(event, listener);
+    return this;
+  }
+  emit(event, ...args) {
+    return this.#emitter.emit(event, ...args);
+  }
+  removeAllListeners() {
+    this.#emitter.removeAllListeners();
+    return this;
+  }
+};
+
+// src/transport/mqtt-push.ts
+function defaultConnect(url, opts) {
+  const client = import_mqtt.default.connect(url, opts);
+  const typed = client;
+  return typed;
+}
+var DreamePush = class extends TypedEmitter {
+  #device;
+  #session;
+  #region;
+  #connect;
+  #backoffMs;
+  #rejectUnauthorized;
+  #topic;
+  #client = null;
+  #closed = false;
+  #tearingDown = false;
+  #reconnectTimer = null;
+  /**
+   * Per-instance bound close handler. Stored so we can pass the EXACT same
+   * function reference to both `client.on('close', …)` and
+   * `client.removeListener('close', …)` during teardown — a throwaway arrow
+   * would be a different reference and would NOT be removed.
+   */
+  #onClose;
+  constructor(input) {
+    super();
+    this.#device = input.device;
+    this.#session = input.session;
+    this.#region = input.region;
+    this.#connect = input.connect ?? defaultConnect;
+    this.#backoffMs = input.reconnectBackoffMs ?? 5e3;
+    this.#rejectUnauthorized = input.rejectUnauthorized ?? false;
+    this.#topic = buildStatusTopic(this.#device, this.#session.uid, this.#region);
+    this.#onClose = () => {
+      if (this.#tearingDown) {
+        return;
+      }
+      this.emit("close");
+      this.#scheduleReconnect();
+    };
+  }
+  get topic() {
+    return this.#topic;
+  }
+  /** Open the connection and resolve when subscribed. */
+  async open() {
+    if (this.#closed) {
+      throw new DreameTransportError("subscription is closed");
+    }
+    if (this.#client) {
+      return;
+    }
+    await this.#connectAndSubscribe();
+  }
+  /**
+   * Swap to a freshly-refreshed session: close the current client and reopen
+   * with the new access token. Safe to call while connected or disconnected.
+   */
+  async refreshSession(session) {
+    this.#session = session;
+    if (this.#closed) {
+      return;
+    }
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+    await this.#teardownClient();
+    await this.#connectAndSubscribe();
+  }
+  /** Tear down permanently. Closed subscriptions cannot be reopened. */
+  async close() {
+    this.#closed = true;
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = null;
+    }
+    await this.#teardownClient();
+  }
+  async #connectAndSubscribe() {
+    const client = this.#connect(brokerUrl(this.#device), {
+      username: this.#session.uid,
+      password: this.#session.accessToken,
+      clientId: randomMqttClientId(),
+      protocolVersion: 4,
+      reconnectPeriod: 0,
+      // we drive reconnect ourselves
+      connectTimeout: 15e3,
+      rejectUnauthorized: this.#rejectUnauthorized,
+      clean: true
+    });
+    this.#client = client;
+    client.on("message", (_topic, payload) => this.#handleMessage(payload));
+    client.on("error", (err) => this.emit("error", err));
+    client.on("close", this.#onClose);
+    await new Promise((resolve, reject) => {
+      const onConnect = () => {
+        client.removeListener("error", onError);
+        client.subscribe(this.#topic, { qos: 0 }, (err) => {
+          if (err) {
+            reject(new DreameTransportError(`mqtt subscribe failed: ${err.message}`, err));
+            return;
+          }
+          this.emit("connect");
+          resolve();
+        });
+      };
+      const onError = (err) => {
+        client.removeListener("connect", onConnect);
+        reject(new DreameTransportError(`mqtt connect failed: ${err.message}`, err));
+      };
+      client.once("connect", onConnect);
+      client.once("error", onError);
+    });
+  }
+  #scheduleReconnect() {
+    if (this.#closed || this.#reconnectTimer) {
+      return;
+    }
+    this.#client = null;
+    this.#reconnectTimer = setTimeout(() => {
+      this.#reconnectTimer = null;
+      if (this.#closed || this.#client) {
+        return;
+      }
+      void this.#connectAndSubscribe().catch((err) => {
+        this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
+        this.#scheduleReconnect();
+      });
+    }, this.#backoffMs);
+  }
+  async #teardownClient() {
+    const client = this.#client;
+    this.#client = null;
+    if (!client) {
+      return;
+    }
+    this.#tearingDown = true;
+    client.removeListener("close", this.#onClose);
+    await new Promise((resolve) => {
+      client.end(false, {}, () => resolve());
+    });
+    this.#tearingDown = false;
+  }
+  #handleMessage(payload) {
+    let raw;
+    try {
+      raw = JSON.parse(payload.toString("utf8"));
+    } catch (err) {
+      this.emit("error", new DreameTransportError("invalid mqtt payload", err));
+      return;
+    }
+    const result = RawMqttEventSchema.safeParse(raw);
+    if (!result.success) {
+      this.emit("error", new DreameTransportError("unexpected mqtt envelope"));
+      return;
+    }
+    const envelope = result.data;
+    const did = String(envelope.did ?? this.#device.did);
+    const method = envelope.data?.method;
+    const params = envelope.data?.params;
+    if (method === "properties_changed" && Array.isArray(params)) {
+      const changes = parsePropertyChanges(did, params);
+      if (changes.length > 0) {
+        this.emit("properties", changes);
+      }
+      return;
+    }
+    if (method === "event_occured" && isObject(params)) {
+      const ev = parseEventOccured(did, params);
+      if (ev) {
+        this.emit("event", ev);
+      }
+      return;
+    }
+    if (method === "props" && isObject(params)) {
+      this.emit("props", { did, params });
+      return;
+    }
+    if (method === "_sync.update_vacuum_mapinfo" && isObject(params)) {
+      const mi = parseMapInfo(did, params);
+      if (mi) {
+        this.emit("mapInfo", mi);
+      }
+      return;
+    }
+  }
+};
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function brokerUrl(device) {
+  const bindDomain = device.raw["bindDomain"] ?? "";
+  if (!bindDomain) {
+    throw new DreameTransportError(`device ${device.did} has no bindDomain \u2014 cannot connect MQTT`);
+  }
+  return `mqtts://${bindDomain}`;
+}
+function buildStatusTopic(device, uid, region) {
+  return `/status/${device.did}/${uid}/${device.model}/${region}/`;
+}
+function parsePropertyChanges(fallbackDid, params) {
+  const changes = [];
+  for (const p of params) {
+    if (!isObject(p)) {
+      continue;
+    }
+    const siid = p["siid"];
+    const piid = p["piid"];
+    if (typeof siid === "number" && typeof piid === "number") {
+      const did = p["did"];
+      changes.push({
+        did: typeof did === "string" || typeof did === "number" ? String(did) : fallbackDid,
+        siid,
+        piid,
+        value: p["value"]
+      });
+    }
+  }
+  return changes;
+}
+function parseEventOccured(fallbackDid, params) {
+  const siid = params["siid"];
+  const eiid = params["eiid"];
+  if (typeof siid !== "number" || typeof eiid !== "number") {
+    return null;
+  }
+  const did = params["did"];
+  const args = params["arguments"];
+  return {
+    did: typeof did === "string" || typeof did === "number" ? String(did) : fallbackDid,
+    siid,
+    eiid,
+    arguments: Array.isArray(args) ? args : []
+  };
+}
+function parseMapInfo(fallbackDid, params) {
+  const inner = params["map_info"];
+  if (typeof inner !== "string") {
+    return null;
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(inner);
+  } catch {
+    return null;
+  }
+  if (!isObject(decoded)) {
+    return null;
+  }
+  const maps = /* @__PURE__ */ new Map();
+  for (const [key2, value] of Object.entries(decoded)) {
+    const id = Number(key2);
+    if (!Number.isFinite(id) || !Array.isArray(value)) {
+      continue;
+    }
+    maps.set(
+      id,
+      value.filter((v) => typeof v === "number")
+    );
+  }
+  let activeMapId = null;
+  for (const [id, tok] of [...maps].sort((a, b) => a[0] - b[0])) {
+    if (tok.length > 1 || tok.length === 1 && tok[0] !== 0) {
+      activeMapId = id;
+      break;
+    }
+  }
+  const savedMapIds = Object.freeze([...maps.keys()].sort((a, b) => a - b));
+  const did = params["did"];
+  return {
+    did: typeof did === "string" || typeof did === "number" ? String(did) : fallbackDid,
+    maps,
+    activeMapId,
+    savedMapIds
+  };
+}
+
+// src/device/capability.ts
+var CapabilitySet = class {
+  model;
+  #tokens;
+  constructor(model, tokens) {
+    this.model = model;
+    this.#tokens = tokens;
+  }
+  has(token) {
+    return this.#tokens.has(token);
+  }
+  list() {
+    return [...this.#tokens];
+  }
+};
+var DefaultCapabilityResolver = class {
+  resolve(model) {
+    return new CapabilitySet(model, /* @__PURE__ */ new Set());
+  }
+};
+var sharedDefault = new DefaultCapabilityResolver();
+function resolveCapabilities(model) {
+  return sharedDefault.resolve(model);
+}
+
+// src/device/base-device.ts
+function defaultBaseDeviceDeps() {
+  return {
+    createPush: (device, session, region) => new DreamePush({ device, session, region }),
+    getProperties: (base, props) => getProperties(base, props),
+    setProperties: (base, writes) => setProperties(base, writes),
+    callAction: (base, action) => callAction(base, action)
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 3e4;
+var BaseDevice = class extends TypedEmitter {
+  #device;
+  #region;
+  #sessionRef;
+  #deps;
+  #fetchInitial;
+  #initialProps;
+  #pollIntervalMs;
+  #capabilities;
+  #cache = /* @__PURE__ */ new Map();
+  #push = null;
+  #mqttHealthy = false;
+  #pollTimer = null;
+  #closed = false;
+  constructor(input) {
+    super();
+    this.#device = input.device;
+    this.#region = input.region;
+    this.#sessionRef = input.sessionRef;
+    this.#deps = input.deps ?? defaultBaseDeviceDeps();
+    this.#fetchInitial = input.fetchInitialValues ?? true;
+    this.#initialProps = input.initialProps ?? [];
+    this.#pollIntervalMs = input.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.#capabilities = input.capabilities ?? new DefaultCapabilityResolver().resolve(input.device.model);
+  }
+  get deviceId() {
+    return this.#device.did;
+  }
+  get model() {
+    return this.#device.model;
+  }
+  get name() {
+    return this.#device.name;
+  }
+  get capabilities() {
+    return this.#capabilities;
+  }
+  /** Snapshot of all cached property states. */
+  get properties() {
+    return [...this.#cache.values()];
+  }
+  /** Read a cached property, or `undefined` if never observed. */
+  getProperty(siid, piid) {
+    return this.#cache.get(key(siid, piid));
+  }
+  #base() {
+    return { session: this.#sessionRef(), region: this.#region, did: this.#device.did };
+  }
+  /** The region this handle is bound to. Subclasses use it to build map fetches. */
+  get region() {
+    return this.#region;
+  }
+  /** Latest session snapshot. Subclasses use it for out-of-band fetches (maps). */
+  currentSession() {
+    return this.#sessionRef();
+  }
+  /** Open the push, wire events, optionally seed the cache. */
+  async start() {
+    const push = this.#deps.createPush(this.#device, this.#sessionRef(), this.#region);
+    this.#push = push;
+    push.on("properties", (changes) => this.#onProperties(changes));
+    push.on(
+      "event",
+      (ev) => this.emit("event", {
+        deviceId: ev.did || this.#device.did,
+        siid: ev.siid,
+        eiid: ev.eiid,
+        arguments: ev.arguments
+      })
+    );
+    push.on("error", (err) => this.emit("error", err));
+    push.on("connect", () => this.#onMqttUp());
+    push.on("close", () => this.#onMqttDown());
+    await push.open();
+    this.#onMqttUp();
+    if (this.#fetchInitial && this.#initialProps.length > 0) {
+      await this.refreshProperties(this.#initialProps);
+    }
+  }
+  /** Live-read properties, update the cache, return the raw results. */
+  async refreshProperties(props) {
+    this.#assertOpen();
+    const results = await this.#deps.getProperties(this.#base(), props);
+    const changes = [];
+    for (const r of results) {
+      if (typeof r.siid === "number" && typeof r.piid === "number") {
+        changes.push({ did: this.#device.did, siid: r.siid, piid: r.piid, value: r.value });
+      }
+    }
+    if (changes.length > 0) {
+      this.#onProperties(changes);
+    }
+    return results;
+  }
+  /** Write a property to the device. */
+  async setProperty(write) {
+    this.#assertOpen();
+    return this.#deps.setProperties(this.#base(), [write]);
+  }
+  /** Invoke a MIoT action on the device. */
+  async callAction(siid, aiid, input = []) {
+    this.#assertOpen();
+    return this.#deps.callAction(this.#base(), { siid, aiid, in: input });
+  }
+  /** Guard against use after {@link close}. */
+  #assertOpen() {
+    if (this.#closed) {
+      throw new DreameTransportError("device handle is closed");
+    }
+  }
+  /** Propagate a refreshed session to the underlying push. */
+  async applySession(session) {
+    if (this.#push) {
+      await this.#push.refreshSession(session);
+    }
+  }
+  /** Tear down: stop polling, close the push. */
+  async close() {
+    this.#closed = true;
+    this.#stopPolling();
+    const push = this.#push;
+    this.#push = null;
+    if (push) {
+      await push.close();
+    }
+    this.removeAllListeners();
+  }
+  #onProperties(changes) {
+    const emitted = [];
+    const now = Date.now();
+    for (const c of changes) {
+      const k = key(c.siid, c.piid);
+      const previous = this.#cache.get(k);
+      this.#cache.set(k, { siid: c.siid, piid: c.piid, value: c.value, updatedAt: now });
+      const ev = {
+        deviceId: this.#device.did,
+        siid: c.siid,
+        piid: c.piid,
+        value: c.value,
+        previousValue: previous ? previous.value : null
+      };
+      emitted.push(ev);
+      this.emit("propertyChanged", ev);
+    }
+    if (emitted.length > 0) {
+      this.emit("stateChanged", { deviceId: this.#device.did, changes: emitted });
+    }
+  }
+  #onMqttUp() {
+    this.#mqttHealthy = true;
+    this.#stopPolling();
+  }
+  #onMqttDown() {
+    this.#mqttHealthy = false;
+    this.#startPolling();
+  }
+  #startPolling() {
+    if (this.#closed || this.#pollTimer || this.#pollIntervalMs <= 0) {
+      return;
+    }
+    if (this.#initialProps.length === 0) {
+      return;
+    }
+    this.#pollTimer = setInterval(() => {
+      if (this.#mqttHealthy) {
+        this.#stopPolling();
+        return;
+      }
+      void this.refreshProperties(this.#initialProps).catch((err) => {
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      });
+    }, this.#pollIntervalMs);
+  }
+  #stopPolling() {
+    if (this.#pollTimer) {
+      clearInterval(this.#pollTimer);
+      this.#pollTimer = null;
+    }
+  }
+};
+function key(siid, piid) {
+  return `${siid}.${piid}`;
+}
+
+// src/models/vacuum/properties.ts
+var VACUUM_PROP = {
+  /** VERIFIED r2532a — MiotState enum. */
+  STATE: { siid: 2, piid: 1 },
+  /** VERIFIED r2532a — single-value error/fault code (see MiotError). */
+  ERROR: { siid: 2, piid: 2 },
+  /** VERIFIED r2449a — writable CleaningMode (plain 0..3). SAFE write path. */
+  CLEAN_MODE_SETTING: { siid: 2, piid: 6 },
+  /** VERIFIED r2532a — multi-value comma-separated fault-list mirror. */
+  FAULTS_STR: { siid: 4, piid: 18 },
+  /** VERIFIED r2532a — Dreame "task status" enum (TaskStatus). */
+  TASK_STATUS: { siid: 4, piid: 1 },
+  /** ASSUMED Tasshack types.py:573 — job runtime (minutes). */
+  CLEANING_TIME: { siid: 4, piid: 2 },
+  /** ASSUMED Tasshack types.py:574 — area cleaned (m²). */
+  CLEANED_AREA: { siid: 4, piid: 3 },
+  /** ASSUMED Tasshack types.py:575 — suction enum (SuctionLevel). */
+  SUCTION_LEVEL: { siid: 4, piid: 4 },
+  /** ASSUMED Tasshack types.py:576 — water flow during cleaning (WaterVolume). */
+  WATER_VOLUME: { siid: 4, piid: 5 },
+  /** ASSUMED Tasshack types.py:1479 — relocation state machine (0/1/10/11). */
+  RELOCATION_STATUS: { siid: 4, piid: 20 },
+  /**
+   * VERIFIED r2449a — packed (0x1400 capability mask | CleaningMode low-2-bits).
+   * READ-ONLY here: do NOT write directly (drops mask → bricks next clean).
+   * Use CLEAN_MODE_SETTING (siid 2 piid 6) to change clean mode.
+   */
+  CLEANING_MODE: { siid: 4, piid: 23 },
+  /** VERIFIED r2532a — Child Lock boolean. */
+  CHILD_LOCK: { siid: 4, piid: 27 },
+  /** VERIFIED r2532a 2026-05-03 — task progress percentage 0..100. */
+  TASK_PROGRESS_PCT: { siid: 4, piid: 63 },
+  /** VERIFIED r2532a — mop-drying progress (minutes ticking during MopDrying). */
+  DRYING_PROGRESS: { siid: 4, piid: 64 }
+};
+var VACUUM_ACTION = {
+  /** ASSUMED Tasshack — start cleaning. */
+  START: { siid: 2, aiid: 1 },
+  /** VERIFIED r2532a — pause (code 0 while idle). */
+  PAUSE: { siid: 2, aiid: 2 },
+  /** ASSUMED Tasshack — return to dock / charge. */
+  CHARGE: { siid: 3, aiid: 1 },
+  /** ASSUMED Tasshack — START_CUSTOM (segment/zone/spot; needs in payload). */
+  START_CUSTOM: { siid: 4, aiid: 1 },
+  /** VERIFIED r2532a — stop (code 0 while idle). */
+  STOP: { siid: 4, aiid: 2 },
+  /** VERIFIED r2532a 2026-05-02 — clear warning (code 0). */
+  CLEAR_WARNING: { siid: 4, aiid: 3 },
+  /** ASSUMED Tasshack — start dock mop wash. */
+  START_WASHING: { siid: 4, aiid: 4 },
+  /** VERIFIED r2532a 2026-05-02 — locate (robot beeps, code 0). */
+  LOCATE: { siid: 7, aiid: 1 },
+  /** ASSUMED Tasshack — manual auto-empty trigger. */
+  START_AUTO_EMPTY: { siid: 15, aiid: 1 }
+};
+var BATTERY_PROP = {
+  /** VERIFIED r2532a — battery percentage. */
+  LEVEL: { siid: 3, piid: 1 },
+  /** VERIFIED r2532a — charging status (ChargingStatus). */
+  CHARGING_STATUS: { siid: 3, piid: 2 }
+};
+var SETTINGS_PROP = {
+  /** ASSUMED Tasshack types.py:642 — voice volume 0-100. */
+  VOLUME: { siid: 7, piid: 1 }
+};
+var CONSUMABLE_PROP = {
+  MAIN_BRUSH_LEFT: { siid: 9, piid: 2 },
+  SIDE_BRUSH_LEFT: { siid: 10, piid: 2 },
+  FILTER_LEFT: { siid: 11, piid: 1 }
+};
+var CUSTOM_CLEAN_MODE = {
+  SEGMENT: 18,
+  ZONE: 19,
+  SPOT: 20
+};
+
+// src/models/vacuum/enums.ts
+var MiotState = /* @__PURE__ */ ((MiotState2) => {
+  MiotState2[MiotState2["Cleaning"] = 1] = "Cleaning";
+  MiotState2[MiotState2["Standby"] = 2] = "Standby";
+  MiotState2[MiotState2["Paused"] = 3] = "Paused";
+  MiotState2[MiotState2["PausedAlt"] = 4] = "PausedAlt";
+  MiotState2[MiotState2["ReturningToCharge"] = 5] = "ReturningToCharge";
+  MiotState2[MiotState2["Charging"] = 6] = "Charging";
+  MiotState2[MiotState2["Mopping"] = 7] = "Mopping";
+  MiotState2[MiotState2["MopDrying"] = 8] = "MopDrying";
+  MiotState2[MiotState2["MopCleaning"] = 9] = "MopCleaning";
+  MiotState2[MiotState2["ReturningToWash"] = 10] = "ReturningToWash";
+  MiotState2[MiotState2["Mapping"] = 11] = "Mapping";
+  MiotState2[MiotState2["CleaningAlt"] = 12] = "CleaningAlt";
+  MiotState2[MiotState2["ChargingComplete"] = 13] = "ChargingComplete";
+  MiotState2[MiotState2["Updating"] = 14] = "Updating";
+  MiotState2[MiotState2["CallToClean"] = 15] = "CallToClean";
+  MiotState2[MiotState2["AutoRepairBase"] = 16] = "AutoRepairBase";
+  MiotState2[MiotState2["ReturnInstallMop"] = 17] = "ReturnInstallMop";
+  MiotState2[MiotState2["ReturnRemoveMop"] = 18] = "ReturnRemoveMop";
+  MiotState2[MiotState2["WaterSupplyDrainTest"] = 19] = "WaterSupplyDrainTest";
+  MiotState2[MiotState2["CleanMopRefillWater"] = 20] = "CleanMopRefillWater";
+  MiotState2[MiotState2["PausedCleaning"] = 21] = "PausedCleaning";
+  MiotState2[MiotState2["AutoEmptying"] = 22] = "AutoEmptying";
+  MiotState2[MiotState2["RemoteCleaning"] = 23] = "RemoteCleaning";
+  MiotState2[MiotState2["IntelligentCharging"] = 24] = "IntelligentCharging";
+  MiotState2[MiotState2["SecondCleaning"] = 25] = "SecondCleaning";
+  MiotState2[MiotState2["Following"] = 26] = "Following";
+  MiotState2[MiotState2["PartialCleaning"] = 27] = "PartialCleaning";
+  MiotState2[MiotState2["ReturnToEmpty"] = 28] = "ReturnToEmpty";
+  MiotState2[MiotState2["WaitingForTask"] = 29] = "WaitingForTask";
+  MiotState2[MiotState2["CleanWashboardBase"] = 30] = "CleanWashboardBase";
+  MiotState2[MiotState2["AutoWaterDraining"] = 33] = "AutoWaterDraining";
+  MiotState2[MiotState2["ShortcutRunning"] = 97] = "ShortcutRunning";
+  MiotState2[MiotState2["CameraMonitoring"] = 98] = "CameraMonitoring";
+  MiotState2[MiotState2["CameraMonitoringPaused"] = 99] = "CameraMonitoringPaused";
+  MiotState2[MiotState2["InitialDeepClean"] = 101] = "InitialDeepClean";
+  return MiotState2;
+})(MiotState || {});
+var ChargingStatus = /* @__PURE__ */ ((ChargingStatus2) => {
+  ChargingStatus2[ChargingStatus2["Charging"] = 1] = "Charging";
+  ChargingStatus2[ChargingStatus2["Discharging"] = 2] = "Discharging";
+  ChargingStatus2[ChargingStatus2["Returning"] = 5] = "Returning";
+  return ChargingStatus2;
+})(ChargingStatus || {});
+var SuctionLevel = /* @__PURE__ */ ((SuctionLevel2) => {
+  SuctionLevel2[SuctionLevel2["Quiet"] = 0] = "Quiet";
+  SuctionLevel2[SuctionLevel2["Standard"] = 1] = "Standard";
+  SuctionLevel2[SuctionLevel2["Intense"] = 2] = "Intense";
+  SuctionLevel2[SuctionLevel2["Max"] = 3] = "Max";
+  return SuctionLevel2;
+})(SuctionLevel || {});
+var WaterVolume = /* @__PURE__ */ ((WaterVolume2) => {
+  WaterVolume2[WaterVolume2["Low"] = 1] = "Low";
+  WaterVolume2[WaterVolume2["Medium"] = 2] = "Medium";
+  WaterVolume2[WaterVolume2["High"] = 3] = "High";
+  return WaterVolume2;
+})(WaterVolume || {});
+var CleaningMode = /* @__PURE__ */ ((CleaningMode2) => {
+  CleaningMode2[CleaningMode2["Sweeping"] = 0] = "Sweeping";
+  CleaningMode2[CleaningMode2["Mopping"] = 1] = "Mopping";
+  CleaningMode2[CleaningMode2["SweepAndMop"] = 2] = "SweepAndMop";
+  CleaningMode2[CleaningMode2["MopAfterSweep"] = 3] = "MopAfterSweep";
+  return CleaningMode2;
+})(CleaningMode || {});
+var MiotError = /* @__PURE__ */ ((MiotError2) => {
+  MiotError2[MiotError2["Clear"] = 0] = "Clear";
+  MiotError2[MiotError2["WheelRotationAnomaly"] = 1] = "WheelRotationAnomaly";
+  MiotError2[MiotError2["RobotLifted"] = 18] = "RobotLifted";
+  MiotError2[MiotError2["TaskComplete"] = 68] = "TaskComplete";
+  MiotError2[MiotError2["ManualMopInstallRequired"] = 74] = "ManualMopInstallRequired";
+  MiotError2[MiotError2["WastewaterTankFull"] = 105] = "WastewaterTankFull";
+  MiotError2[MiotError2["CleanWaterTankEmpty"] = 107] = "CleanWaterTankEmpty";
+  MiotError2[MiotError2["WashboardFilterNeedsCleaning"] = 114] = "WashboardFilterNeedsCleaning";
+  MiotError2[MiotError2["MopPadsMissing"] = 120] = "MopPadsMissing";
+  MiotError2[MiotError2["BatteryLow"] = 20] = "BatteryLow";
+  MiotError2[MiotError2["ChargeFault"] = 21] = "ChargeFault";
+  MiotError2[MiotError2["BatteryPercentageAnomaly"] = 22] = "BatteryPercentageAnomaly";
+  MiotError2[MiotError2["ChargeNoElectric"] = 28] = "ChargeNoElectric";
+  MiotError2[MiotError2["BatteryFault"] = 29] = "BatteryFault";
+  MiotError2[MiotError2["LowBatteryTurnOff"] = 75] = "LowBatteryTurnOff";
+  MiotError2[MiotError2["RobotStuck"] = 80] = "RobotStuck";
+  MiotError2[MiotError2["RobotStuckRepeat"] = 81] = "RobotStuckRepeat";
+  MiotError2[MiotError2["RobotStuck2"] = 90] = "RobotStuck2";
+  MiotError2[MiotError2["RobotStuckOnTables"] = 91] = "RobotStuckOnTables";
+  MiotError2[MiotError2["RobotStuckOnPassage"] = 92] = "RobotStuckOnPassage";
+  MiotError2[MiotError2["RobotStuckOnThreshold"] = 93] = "RobotStuckOnThreshold";
+  MiotError2[MiotError2["RobotStuckOnLowLyingArea"] = 94] = "RobotStuckOnLowLyingArea";
+  MiotError2[MiotError2["RobotStuckOnRamp"] = 95] = "RobotStuckOnRamp";
+  MiotError2[MiotError2["RobotStuckOnObstacle"] = 96] = "RobotStuckOnObstacle";
+  MiotError2[MiotError2["RobotStuckOnPet"] = 97] = "RobotStuckOnPet";
+  MiotError2[MiotError2["RobotStuckOnSlipperySurface"] = 98] = "RobotStuckOnSlipperySurface";
+  MiotError2[MiotError2["RobotStuckOnCarpet"] = 99] = "RobotStuckOnCarpet";
+  MiotError2[MiotError2["RobotStuckOnCurtain"] = 200] = "RobotStuckOnCurtain";
+  MiotError2[MiotError2["BinFull"] = 101] = "BinFull";
+  MiotError2[MiotError2["StationDisconnected"] = 117] = "StationDisconnected";
+  MiotError2[MiotError2["DustBagFull"] = 121] = "DustBagFull";
+  return MiotError2;
+})(MiotError || {});
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2[TaskStatus2["InterruptedOrPaused"] = 1] = "InterruptedOrPaused";
+  TaskStatus2[TaskStatus2["Active"] = 2] = "Active";
+  TaskStatus2[TaskStatus2["Transitioning"] = 3] = "Transitioning";
+  TaskStatus2[TaskStatus2["OnDockIdle"] = 6] = "OnDockIdle";
+  TaskStatus2[TaskStatus2["TransientPauseEdge"] = 12] = "TransientPauseEdge";
+  TaskStatus2[TaskStatus2["NeedsIntervention"] = 14] = "NeedsIntervention";
+  return TaskStatus2;
+})(TaskStatus || {});
+
+// src/models/_shared/decode.ts
+function asNum(value) {
+  return typeof value === "number" ? value : null;
+}
+function enumLookup(members) {
+  const set = new Set(members);
+  return (n) => n !== null && set.has(n) ? members.find((m) => m === n) ?? null : null;
+}
+
+// src/models/vacuum/decode.ts
+function parseFaultList(value) {
+  if (typeof value !== "string") {
+    if (typeof value === "number" && value !== 0) {
+      return [value];
+    }
+    return [];
+  }
+  const trimmed = value.trim();
+  if (trimmed === "" || trimmed === "0") {
+    return [];
+  }
+  const codes = [];
+  for (const part of trimmed.split(",")) {
+    const n = Number.parseInt(part.trim(), 10);
+    if (Number.isFinite(n) && n !== 0) {
+      codes.push(n);
+    }
+  }
+  return codes;
+}
+
+// src/models/vacuum/capabilities.ts
+var FALLBACK = {
+  verified: false,
+  canMop: false,
+  canAutoInstallMop: false,
+  hasSideBrush: true,
+  hasCamera: false,
+  hasCarpetSensor: false,
+  hasAiObstacleDetection: false,
+  canAutoEmpty: false,
+  canMopWash: false,
+  canMopDry: false,
+  canHeatMopWater: false,
+  hasDetergentReservoir: false,
+  canCleanPerRoom: false,
+  supportsVirtualWalls: false,
+  supportsNoGoZones: false,
+  hasChildLock: false,
+  supportsMultiFloor: false,
+  // Map decoding is model-agnostic (binary frame format is identical across
+  // the lineup); the fallback record leaves it false so an unknown model does
+  // not advertise a feature we have not verified its firmware exposes.
+  canMap: false,
+  supportedSuctionLevels: [
+    0 /* Quiet */,
+    1 /* Standard */,
+    2 /* Intense */,
+    3 /* Max */
+  ],
+  supportedWaterVolumes: [1 /* Low */, 2 /* Medium */, 3 /* High */]
+};
+var X50_FAMILY = {
+  canMop: true,
+  canAutoInstallMop: true,
+  hasSideBrush: true,
+  hasCamera: true,
+  hasCarpetSensor: true,
+  hasAiObstacleDetection: true,
+  canAutoEmpty: true,
+  canMopWash: true,
+  canMopDry: true,
+  canHeatMopWater: true,
+  hasDetergentReservoir: true,
+  canCleanPerRoom: true,
+  supportsVirtualWalls: true,
+  supportsNoGoZones: true,
+  hasChildLock: true,
+  supportsMultiFloor: true,
+  canMap: true,
+  supportedSuctionLevels: [
+    0 /* Quiet */,
+    1 /* Standard */,
+    2 /* Intense */,
+    3 /* Max */
+  ],
+  supportedWaterVolumes: [1 /* Low */, 2 /* Medium */, 3 /* High */]
+};
+function deepFreeze(obj) {
+  if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+    Object.freeze(obj);
+    for (const v of Object.values(obj)) {
+      deepFreeze(v);
+    }
+  }
+  return obj;
+}
+var MODEL_CAPABILITIES = {
+  /** Dreame X40 Ultra Complete — VERIFIED r2449a (2026-05-21). */
+  "dreame.vacuum.r2449a": { model: "dreame.vacuum.r2449a", verified: true, ...X50_FAMILY },
+  /** Dreame X50 Ultra Complete — VERIFIED r2532a (firmware 4.3.9_2199, 2026-05-02). */
+  "dreame.vacuum.r2532a": { model: "dreame.vacuum.r2532a", verified: true, ...X50_FAMILY },
+  /**
+   * Dreame r2538z — the user's device. ASSUMED from the r2532a (X50) sibling:
+   * same dock-side feature set is the working hypothesis. Marked verified:false
+   * until confirmed live (e2e). Flip to true + drop this note once verified.
+   */
+  "dreame.vacuum.r2538z": { model: "dreame.vacuum.r2538z", verified: false, ...X50_FAMILY }
+};
+for (const entry of Object.values(MODEL_CAPABILITIES)) {
+  deepFreeze(entry);
+}
+function getVacuumCapabilities(model) {
+  const known = MODEL_CAPABILITIES[model];
+  if (known) {
+    return known;
+  }
+  return deepFreeze({ model, ...FALLBACK });
+}
+function tokensFor(c) {
+  const tokens = /* @__PURE__ */ new Set();
+  const add = (flag, token) => {
+    if (flag) {
+      tokens.add(token);
+    }
+  };
+  add(c.canMop, "mop");
+  add(c.canAutoInstallMop, "auto-install-mop");
+  add(c.hasSideBrush, "side-brush");
+  add(c.hasCamera, "camera");
+  add(c.hasCarpetSensor, "carpet-sensor");
+  add(c.hasAiObstacleDetection, "ai-obstacle");
+  add(c.canAutoEmpty, "auto-empty");
+  add(c.canMopWash, "mop-wash");
+  add(c.canMopDry, "mop-dry");
+  add(c.canHeatMopWater, "heat-mop-water");
+  add(c.hasDetergentReservoir, "detergent");
+  add(c.canCleanPerRoom, "clean-per-room");
+  add(c.supportsVirtualWalls, "virtual-walls");
+  add(c.supportsNoGoZones, "no-go-zones");
+  add(c.hasChildLock, "child-lock");
+  add(c.supportsMultiFloor, "multi-floor");
+  return tokens;
+}
+var VacuumCapabilitySet = class {
+  model;
+  #tokens;
+  constructor(model, tokens) {
+    this.model = model;
+    this.#tokens = tokens;
+  }
+  has(token) {
+    return this.#tokens.has(token);
+  }
+  list() {
+    return [...this.#tokens];
+  }
+};
+var VacuumCapabilityResolver = class {
+  resolve(model) {
+    return new VacuumCapabilitySet(model, tokensFor(getVacuumCapabilities(model)));
+  }
+};
+
+// src/models/vacuum/map/envelope.ts
+var import_node_crypto2 = require("crypto");
+var zlib = __toESM(require("zlib"), 1);
+var HEADER_SIZE = 27;
+var ANGLE_ABSENT = 32767;
+var FRAME_TYPE = {
+  I: 73,
+  P: 80,
+  W: 87
+};
+var MapDecodeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MapDecodeError";
+  }
+};
+function unwrapEnvelope(value, opts = {}) {
+  const commaIdx = value.indexOf(",");
+  const b64 = commaIdx >= 0 ? value.slice(0, commaIdx) : value;
+  const embeddedKey = commaIdx >= 0 ? value.slice(commaIdx + 1) : null;
+  const standard = b64.replace(/-/g, "+").replace(/_/g, "/");
+  let bytes;
+  try {
+    bytes = Buffer.from(standard, "base64");
+  } catch (err) {
+    throw new MapDecodeError("envelope: base64 decode failed", { cause: err });
+  }
+  if (bytes.length === 0) {
+    throw new MapDecodeError("envelope: empty payload after base64 decode");
+  }
+  const key2 = embeddedKey ?? opts.key ?? null;
+  if (key2) {
+    if (!opts.iv) {
+      throw new MapDecodeError(
+        "envelope: AES key supplied but no IV \u2014 pass `opts.iv` (16-byte ASCII)"
+      );
+    }
+    bytes = aesCbcDecrypt(bytes, key2, opts.iv);
+  }
+  try {
+    return zlib.inflateSync(bytes);
+  } catch (err) {
+    throw new MapDecodeError("envelope: zlib inflate failed", { cause: err });
+  }
+}
+function aesCbcDecrypt(cipher, rawKey, iv) {
+  const keyBytes = Buffer.from(
+    (0, import_node_crypto2.createHash)("sha256").update(rawKey).digest("hex").slice(0, 32),
+    "utf8"
+  );
+  const ivBytes = Buffer.from(iv, "utf8");
+  if (ivBytes.length !== 16) {
+    throw new MapDecodeError(`envelope: AES IV must be 16 ASCII bytes, got ${ivBytes.length}`);
+  }
+  try {
+    const decipher = (0, import_node_crypto2.createDecipheriv)("aes-256-cbc", keyBytes, ivBytes);
+    decipher.setAutoPadding(false);
+    return Buffer.concat([decipher.update(cipher), decipher.final()]);
+  } catch (err) {
+    throw new MapDecodeError("envelope: AES decrypt failed", { cause: err });
+  }
+}
+
+// src/models/vacuum/map/header.ts
+function parseMapHeader(buf) {
+  if (buf.length < HEADER_SIZE) {
+    throw new MapDecodeError(`header: need ${HEADER_SIZE} bytes, got ${buf.length}`);
+  }
+  return {
+    mapId: buf.readInt16LE(0),
+    frameId: buf.readInt16LE(2),
+    frameType: frameTypeFromByte(buf[4]),
+    robotX: buf.readInt16LE(5),
+    robotY: buf.readInt16LE(7),
+    robotA: buf.readInt16LE(9),
+    chargerX: buf.readInt16LE(11),
+    chargerY: buf.readInt16LE(13),
+    chargerA: buf.readInt16LE(15),
+    gridSize: buf.readInt16LE(17),
+    width: buf.readInt16LE(19),
+    height: buf.readInt16LE(21),
+    left: buf.readInt16LE(23),
+    top: buf.readInt16LE(25)
+  };
+}
+function frameTypeFromByte(b) {
+  switch (b) {
+    case FRAME_TYPE.I:
+      return "I";
+    case FRAME_TYPE.P:
+      return "P";
+    case FRAME_TYPE.W:
+      return "W";
+    default:
+      throw new MapDecodeError(`header: unknown frame_type byte ${b}`);
+  }
+}
+
+// src/models/vacuum/map/tail.ts
+function sliceTailText(inflated, header) {
+  const start = HEADER_SIZE + header.width * header.height;
+  if (inflated.length < start) {
+    throw new MapDecodeError(
+      `tail: inflated payload shorter than header+pixels (${inflated.length} < ${start})`
+    );
+  }
+  return inflated.subarray(start).toString("utf8");
+}
+function asMapTail(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new MapDecodeError("tail: JSON top-level is not an object");
+  }
+  const record = { ...value };
+  return record;
+}
+function parseMapJsonTail(text) {
+  if (!text) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    throw new MapDecodeError("tail: JSON parse failed", { cause: err });
+  }
+  return asMapTail(parsed);
+}
+function parseFrame(inflated) {
+  const header = parseMapHeader(inflated);
+  const tail = parseMapJsonTail(sliceTailText(inflated, header));
+  return { header, tail };
+}
+
+// src/models/vacuum/map/pixel-grid.ts
+function classifyPixelFsm1(byte) {
+  if (byte === 0) {
+    return { kind: "outside" };
+  }
+  const seg = byte >> 2;
+  const meta = byte & 3;
+  const isCarpet = meta === 3;
+  if (seg === 63) {
+    return isCarpet ? { kind: "wall", carpet: true } : { kind: "wall" };
+  }
+  if (seg === 62) {
+    return isCarpet ? { kind: "floor", carpet: true } : { kind: "floor" };
+  }
+  if (seg === 61) {
+    return { kind: "outside" };
+  }
+  if (seg === 0) {
+    if (meta === 2) {
+      return { kind: "wall" };
+    }
+    if (isCarpet) {
+      return { kind: "outside", carpet: true };
+    }
+    return { kind: "outside" };
+  }
+  return isCarpet ? { kind: "segment", segmentId: seg, carpet: true } : { kind: "segment", segmentId: seg };
+}
+function decodePixelGridFsm1(pixels, width, height) {
+  const wallRuns = [];
+  const floorRuns = [];
+  const segmentRuns = /* @__PURE__ */ new Map();
+  const carpetRuns = [];
+  for (let y = 0; y < height; y++) {
+    const rowBase = y * width;
+    let runStart = -1;
+    let runKind = "outside";
+    let runSegmentId = 0;
+    let carpetStart = -1;
+    for (let x = 0; x <= width; x++) {
+      const byte = x < width ? pixels[rowBase + x] : 0;
+      const c = x < width ? classifyPixelFsm1(byte) : { kind: "outside", carpet: void 0 };
+      const sameAsRun = runStart >= 0 && c.kind === runKind && (c.kind !== "segment" || c.segmentId === runSegmentId);
+      if (!sameAsRun) {
+        if (runStart >= 0 && runKind !== "outside") {
+          const length = x - runStart;
+          const run = [runStart, y, length];
+          if (runKind === "wall") {
+            wallRuns.push(run);
+          } else if (runKind === "floor") {
+            floorRuns.push(run);
+          } else if (runKind === "segment") {
+            let bucket = segmentRuns.get(runSegmentId);
+            if (!bucket) {
+              bucket = [];
+              segmentRuns.set(runSegmentId, bucket);
+            }
+            bucket.push(run);
+          }
+        }
+        if (x < width && c.kind !== "outside") {
+          runStart = x;
+          runKind = c.kind;
+          runSegmentId = c.kind === "segment" ? c.segmentId : 0;
+        } else {
+          runStart = -1;
+        }
+      }
+      const isCarpet = c.carpet === true;
+      if (isCarpet && carpetStart < 0) {
+        carpetStart = x;
+      } else if (!isCarpet && carpetStart >= 0) {
+        carpetRuns.push([carpetStart, y, x - carpetStart]);
+        carpetStart = -1;
+      }
+    }
+  }
+  const layers = [];
+  if (wallRuns.length > 0) {
+    layers.push({ type: "wall", runs: wallRuns });
+  }
+  if (floorRuns.length > 0) {
+    layers.push({ type: "floor", runs: floorRuns });
+  }
+  for (const [id, runs] of [...segmentRuns.entries()].sort(([a], [b]) => a - b)) {
+    layers.push({ type: "segment", segmentId: id, runs });
+  }
+  if (carpetRuns.length > 0) {
+    layers.push({ type: "carpet", runs: carpetRuns });
+  }
+  return layers;
+}
+function collectSegments(layers, dim, tail) {
+  const activeIds = /* @__PURE__ */ new Set();
+  for (const entry of tail.sa ?? []) {
+    if (Array.isArray(entry) && typeof entry[0] === "number") {
+      activeIds.add(entry[0]);
+    }
+  }
+  const segs = [];
+  for (const layer of layers) {
+    if (layer.type !== "segment" || layer.segmentId === void 0) {
+      continue;
+    }
+    const id = layer.segmentId;
+    let xMinPx = Infinity;
+    let yMinPx = Infinity;
+    let xMaxPx = -Infinity;
+    let yMaxPx = -Infinity;
+    let sumXPx = 0;
+    let sumYPx = 0;
+    let count = 0;
+    for (const [x, y, len] of layer.runs) {
+      if (x < xMinPx) {
+        xMinPx = x;
+      }
+      if (y < yMinPx) {
+        yMinPx = y;
+      }
+      if (x + len - 1 > xMaxPx) {
+        xMaxPx = x + len - 1;
+      }
+      if (y > yMaxPx) {
+        yMaxPx = y;
+      }
+      sumXPx += len * x + len * (len - 1) / 2;
+      sumYPx += len * y;
+      count += len;
+    }
+    if (count === 0) {
+      continue;
+    }
+    const meta = tail.seg_inf?.[String(id)] ?? null;
+    const bbox = {
+      xMin: dim.left + xMinPx * dim.gridSize,
+      yMin: dim.top + yMinPx * dim.gridSize,
+      xMax: dim.left + (xMaxPx + 1) * dim.gridSize,
+      yMax: dim.top + (yMaxPx + 1) * dim.gridSize
+    };
+    const centroid = {
+      x: dim.left + sumXPx / count * dim.gridSize,
+      y: dim.top + sumYPx / count * dim.gridSize
+    };
+    segs.push({
+      id,
+      name: meta?.name ? safeBase64ToUtf8(meta.name) : null,
+      bbox,
+      centroid,
+      neighbours: meta?.nei_id ?? [],
+      floorMaterial: meta?.material ?? null,
+      floorDirection: meta?.direction ?? null,
+      active: activeIds.has(id)
+    });
+  }
+  return segs;
+}
+function safeBase64ToUtf8(s) {
+  try {
+    return Buffer.from(s, "base64").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+// src/models/vacuum/map/path.ts
+var PATH_TYPE_FROM_OP = {
+  M: "mop",
+  W: "sweep-and-mop",
+  S: "sweep",
+  L: "line"
+};
+var PATH_OP_REGEX = /([MWSLl])(-?\d+),(-?\d+)/g;
+function parsePathTr(tr) {
+  if (!tr) {
+    return [];
+  }
+  const out = [];
+  let current = null;
+  let anchor = null;
+  for (const m of tr.matchAll(PATH_OP_REGEX)) {
+    const opRaw = m[1];
+    const xRaw = Number(m[2]);
+    const yRaw = Number(m[3]);
+    const op = opRaw === "l" ? "L" : opRaw;
+    const type = PATH_TYPE_FROM_OP[op];
+    if (!type) {
+      continue;
+    }
+    if (type === "line" && anchor !== null) {
+      const abs = {
+        x: anchor.x + xRaw,
+        y: anchor.y + yRaw
+      };
+      if (!current || current.type !== type) {
+        current = { type, points: [{ x: anchor.x, y: anchor.y }, abs] };
+        out.push(current);
+      } else {
+        current.points.push(abs);
+      }
+      anchor = abs;
+    } else {
+      const pt = { x: xRaw, y: yRaw };
+      if (!current || current.type !== type) {
+        current = { type, points: [pt] };
+        out.push(current);
+      } else {
+        current.points.push(pt);
+      }
+      if (type !== "line") {
+        anchor = pt;
+      }
+    }
+  }
+  return out;
+}
+
+// src/models/vacuum/map/field-utils.ts
+function parseFloatField(v) {
+  if (typeof v === "number") {
+    return Number.isFinite(v) ? v : null;
+  }
+  if (typeof v === "string") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function parseIntField(v) {
+  const n = parseFloatField(v);
+  return n === null ? null : Math.trunc(n);
+}
+
+// src/models/vacuum/map/obstacles.ts
+function parseObstacles(raw) {
+  const out = [];
+  for (const entry of raw) {
+    if (!Array.isArray(entry) || entry.length < 6) {
+      continue;
+    }
+    const x = parseFloatField(entry[0]);
+    const y = parseFloatField(entry[1]);
+    const type = parseIntField(entry[2]);
+    const confRaw = parseFloatField(entry[3]);
+    if (x === null || y === null || type === null) {
+      continue;
+    }
+    const photoFileName = typeof entry[5] === "string" ? entry[5] : null;
+    const idCandidate = parseIntField(entry[6]);
+    const id = idCandidate ?? Math.round((parseFloatField(entry[4]) ?? 0) * 1e6);
+    out.push({
+      id,
+      x,
+      y,
+      type,
+      confidence: confRaw === null ? 0 : Math.round(confRaw * 100),
+      photoFileName,
+      photoKey: null
+    });
+  }
+  return out;
+}
+
+// src/models/vacuum/map/geometry.ts
+function parseVirtualWalls(vw, vws) {
+  const virtualWalls = [];
+  const restrictedAreas = [];
+  if (vw) {
+    for (const line of vw.line ?? []) {
+      const wall = parseLine(line, "wall");
+      if (wall) {
+        virtualWalls.push(wall);
+      }
+    }
+    for (const rect of vw.rect ?? []) {
+      const area = parseRestrictedArea("noGo", rect);
+      if (area) {
+        restrictedAreas.push(area);
+      }
+    }
+    for (const rect of vw.mop ?? []) {
+      const area = parseRestrictedArea("noMop", rect);
+      if (area) {
+        restrictedAreas.push(area);
+      }
+    }
+    for (const rect of vw.nocpt ?? []) {
+      const area = parseRestrictedArea("noGo", rect);
+      if (area) {
+        restrictedAreas.push(area);
+      }
+    }
+  }
+  if (vws) {
+    const npthrsdPresent = Array.isArray(vws.npthrsd) && vws.npthrsd.length > 0;
+    for (const line of vws.vwsl ?? []) {
+      const wall = parseLine(line, "threshold");
+      if (wall) {
+        if (npthrsdPresent) {
+          wall.passable = true;
+        }
+        virtualWalls.push(wall);
+      }
+    }
+    for (const line of vws.npthrsd ?? []) {
+      const wall = parseLine(line, "threshold");
+      if (wall) {
+        wall.passable = false;
+        virtualWalls.push(wall);
+      }
+    }
+  }
+  return { virtualWalls, restrictedAreas };
+}
+function parseLine(raw, kind) {
+  if (!Array.isArray(raw) || raw.length < 4) {
+    return null;
+  }
+  const x0 = parseFloatField(raw[0]);
+  const y0 = parseFloatField(raw[1]);
+  const x1 = parseFloatField(raw[2]);
+  const y1 = parseFloatField(raw[3]);
+  if (x0 === null || y0 === null || x1 === null || y1 === null) {
+    return null;
+  }
+  if (kind === "wall") {
+    return { from: { x: x0, y: y0 }, to: { x: x1, y: y1 } };
+  }
+  return { from: { x: x0, y: y0 }, to: { x: x1, y: y1 }, kind };
+}
+function parseRestrictedArea(kind, raw) {
+  if (!Array.isArray(raw) || raw.length < 4) {
+    return null;
+  }
+  const a = parseFloatField(raw[0]);
+  const b = parseFloatField(raw[1]);
+  const c = parseFloatField(raw[2]);
+  const d = parseFloatField(raw[3]);
+  if (a === null || b === null || c === null || d === null) {
+    return null;
+  }
+  const xMin = Math.min(a, c);
+  const xMax = Math.max(a, c);
+  const yMin = Math.min(b, d);
+  const yMax = Math.max(b, d);
+  const area = {
+    kind,
+    bbox: { xMin, yMin, xMax, yMax }
+  };
+  const e = raw.length > 4 ? parseFloatField(raw[4]) : null;
+  if (e !== null) {
+    area.angle = e;
+  }
+  return area;
+}
+function parseWallsInfo(raw) {
+  if (!raw || !Array.isArray(raw.storeys) || raw.storeys.length === 0) {
+    return null;
+  }
+  const storeys = [];
+  for (const s of raw.storeys) {
+    if (!s || !Array.isArray(s.rooms)) {
+      continue;
+    }
+    const rooms = [];
+    for (const r of s.rooms) {
+      if (!r || typeof r.room_id !== "number" || !Array.isArray(r.walls)) {
+        continue;
+      }
+      const walls = [];
+      for (const w of r.walls) {
+        if (!w || typeof w.type !== "number" || typeof w.beg_pt_x !== "number" || typeof w.beg_pt_y !== "number" || typeof w.end_pt_x !== "number" || typeof w.end_pt_y !== "number" || typeof w.normal_x !== "number" || typeof w.normal_y !== "number") {
+          continue;
+        }
+        walls.push({
+          type: w.type,
+          from: { x: w.beg_pt_x, y: w.beg_pt_y },
+          to: { x: w.end_pt_x, y: w.end_pt_y },
+          normal: { x: w.normal_x, y: w.normal_y }
+        });
+      }
+      rooms.push({ roomId: r.room_id, walls });
+    }
+    storeys.push({ rooms });
+  }
+  if (storeys.length === 0) {
+    return null;
+  }
+  return {
+    versionFlag: typeof raw.version_flag === "number" ? raw.version_flag : 0,
+    storeys
+  };
+}
+function parseTailGeometry(tail) {
+  const { virtualWalls, restrictedAreas } = parseVirtualWalls(tail.vw, tail.vws);
+  return {
+    virtualWalls,
+    restrictedAreas,
+    lowLyingAreas: parseLowLyingAreas(tail.sneak_areas_end, tail.sneak_areas),
+    wallsInfo: parseWallsInfo(tail.walls_info)
+  };
+}
+function isGeometryComplete(g) {
+  return g.virtualWalls.length > 0 && g.restrictedAreas.length > 0 && g.lowLyingAreas.length > 0 && g.wallsInfo !== null;
+}
+function coalesceGeometry(primary, fallback) {
+  return {
+    virtualWalls: primary.virtualWalls.length > 0 ? primary.virtualWalls : fallback.virtualWalls,
+    restrictedAreas: primary.restrictedAreas.length > 0 ? primary.restrictedAreas : fallback.restrictedAreas,
+    lowLyingAreas: primary.lowLyingAreas.length > 0 ? primary.lowLyingAreas : fallback.lowLyingAreas,
+    wallsInfo: primary.wallsInfo !== null ? primary.wallsInfo : fallback.wallsInfo
+  };
+}
+function parseLowLyingAreas(end, live) {
+  const source = end && end.length > 0 ? end : live;
+  if (!source) {
+    return [];
+  }
+  const out = [];
+  for (const entry of source) {
+    if (!entry || !Array.isArray(entry.roi) || entry.roi.length < 4 || entry.roi.length % 2 !== 0) {
+      continue;
+    }
+    const points = [];
+    let badPoint = false;
+    for (let i = 0; i + 1 < entry.roi.length; i += 2) {
+      const x = parseFloatField(entry.roi[i]);
+      const y = parseFloatField(entry.roi[i + 1]);
+      if (x === null || y === null) {
+        badPoint = true;
+        break;
+      }
+      points.push({ x, y });
+    }
+    if (badPoint || points.length === 0) {
+      continue;
+    }
+    const id = typeof entry.id === "number" ? entry.id : -1;
+    const area = { id, points };
+    if (typeof entry.area === "number") {
+      area.area = entry.area;
+    }
+    out.push(area);
+  }
+  return out;
+}
+
+// src/models/vacuum/map/cleaned-area.ts
+function parseCleanedAreaOverlay(decmap) {
+  if (!decmap) {
+    return null;
+  }
+  let inflated;
+  try {
+    inflated = unwrapEnvelope(decmap);
+  } catch {
+    return null;
+  }
+  if (inflated.length < HEADER_SIZE) {
+    return null;
+  }
+  let header;
+  try {
+    header = parseMapHeader(inflated);
+  } catch {
+    return null;
+  }
+  const pixelStart = HEADER_SIZE;
+  const pixelEnd = pixelStart + header.width * header.height;
+  if (inflated.length < pixelEnd || header.width <= 0 || header.height <= 0) {
+    return null;
+  }
+  const pixels = inflated.subarray(pixelStart, pixelEnd);
+  const { cleaned, dirty } = decodeCleanedAreaPixels(pixels, header.width, header.height);
+  const overlay = {
+    dimensions: {
+      left: header.left,
+      top: header.top,
+      width: header.width,
+      height: header.height,
+      gridSize: header.gridSize
+    },
+    cleaned,
+    dirty
+  };
+  if (inflated.length > pixelEnd) {
+    const tailText = inflated.subarray(pixelEnd).toString("utf8");
+    if (tailText) {
+      try {
+        const innerTail = JSON.parse(tailText);
+        if (typeof innerTail === "object" && innerTail !== null && !Array.isArray(innerTail) && "CleanArea" in innerTail) {
+          overlay.cleanedSegments = innerTail.CleanArea;
+        }
+      } catch {
+      }
+    }
+  }
+  return overlay;
+}
+function decodeCleanedAreaPixels(pixels, width, height) {
+  const cleaned = [];
+  const dirty = [];
+  for (let y = 0; y < height; y++) {
+    let cleanStart = -1;
+    let dirtyStart = -1;
+    const rowOff = y * width;
+    for (let x = 0; x < width; x++) {
+      const v = pixels[rowOff + x] & 3;
+      if (v === 1) {
+        if (dirtyStart >= 0) {
+          dirty.push([dirtyStart, y, x - dirtyStart]);
+          dirtyStart = -1;
+        }
+        if (cleanStart < 0) {
+          cleanStart = x;
+        }
+      } else if (v === 2) {
+        if (cleanStart >= 0) {
+          cleaned.push([cleanStart, y, x - cleanStart]);
+          cleanStart = -1;
+        }
+        if (dirtyStart < 0) {
+          dirtyStart = x;
+        }
+      } else {
+        if (cleanStart >= 0) {
+          cleaned.push([cleanStart, y, x - cleanStart]);
+          cleanStart = -1;
+        }
+        if (dirtyStart >= 0) {
+          dirty.push([dirtyStart, y, x - dirtyStart]);
+          dirtyStart = -1;
+        }
+      }
+    }
+    if (cleanStart >= 0) {
+      cleaned.push([cleanStart, y, width - cleanStart]);
+    }
+    if (dirtyStart >= 0) {
+      dirty.push([dirtyStart, y, width - dirtyStart]);
+    }
+  }
+  return { cleaned, dirty };
+}
+
+// src/models/vacuum/map/decode.ts
+function decodeVacuumMap(input, opts = {}) {
+  const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : input;
+  const { header, tail } = parseFrame(inflated);
+  const dimensions = mergeDimensions(header, tail);
+  const robot = pose(header.robotX, header.robotY, header.robotA, tail.nr === true);
+  const dock = pose(header.chargerX, header.chargerY, header.chargerA, tail.nc === true);
+  const docked = tail.oc === true;
+  const pixelStart = HEADER_SIZE;
+  const pixelEnd = pixelStart + header.width * header.height;
+  const pixelGrid = inflated.subarray(pixelStart, pixelEnd);
+  const canDecodePixels = header.frameType === "I" && pixelGrid.length === header.width * header.height;
+  const layers = canDecodePixels ? decodePixelGridFsm1(pixelGrid, header.width, header.height) : [];
+  const segments = canDecodePixels ? collectSegments(layers, dimensions, tail) : [];
+  const paths = parsePathTr(tail.tr ?? "");
+  const obstacles = parseObstacles(tail.ai_obstacle ?? []);
+  let geometry = parseTailGeometry(tail);
+  if (!isGeometryComplete(geometry) && typeof tail.rism === "string" && tail.rism.length > 0) {
+    try {
+      const innerInflated = unwrapEnvelope(tail.rism);
+      const { tail: innerTail } = parseFrame(innerInflated);
+      geometry = coalesceGeometry(geometry, parseTailGeometry(innerTail));
+    } catch {
+    }
+  }
+  const cleanedArea = typeof tail.decmap === "string" ? parseCleanedAreaOverlay(tail.decmap) : null;
+  return {
+    mapId: header.mapId,
+    frameId: header.frameId,
+    frameType: header.frameType,
+    timestamp: tail.timestamp_ms ?? 0,
+    rotation: tail.mra ?? 0,
+    dimensions,
+    robot,
+    dock,
+    docked,
+    layers,
+    segments,
+    paths,
+    obstacles,
+    ...geometry,
+    cleanedArea
+  };
+}
+function mergeDimensions(header, tail) {
+  const left = tail.origin?.[0] ?? header.left;
+  const top = tail.origin?.[1] ?? header.top;
+  return {
+    left,
+    top,
+    width: header.width,
+    height: header.height,
+    gridSize: header.gridSize
+  };
+}
+function pose(x, y, angle, absent) {
+  if (absent || angle === ANGLE_ABSENT) {
+    return null;
+  }
+  return { x, y, angle };
+}
+
+// src/models/vacuum/map/render.ts
+var import_pngjs = require("pngjs");
+var RGBA = {
+  wall: [60, 60, 60, 255],
+  floor: [210, 222, 235, 255],
+  carpet: [180, 150, 120, 200]
+};
+function hsvToRgba(h, s, v) {
+  const c = v * s;
+  const hp = (h % 360 + 360) % 360 / 60;
+  const x = c * (1 - Math.abs(hp % 2 - 1));
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (hp < 1) {
+    r = c;
+    g = x;
+  } else if (hp < 2) {
+    r = x;
+    g = c;
+  } else if (hp < 3) {
+    g = c;
+    b = x;
+  } else if (hp < 4) {
+    g = x;
+    b = c;
+  } else if (hp < 5) {
+    r = x;
+    b = c;
+  } else {
+    r = c;
+    b = x;
+  }
+  const m = v - c;
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255), 255];
+}
+function segmentColor(id) {
+  const hue = id * 137.508 % 360;
+  return hsvToRgba(hue, 0.45, 0.95);
+}
+function renderVacuumPng(map, opts = {}) {
+  const scale = Math.max(1, Math.trunc(opts.scale ?? 1));
+  const w = map.dimensions.width * scale;
+  const h = map.dimensions.height * scale;
+  const png = new import_pngjs.PNG({ width: Math.max(1, w), height: Math.max(1, h) });
+  png.data.fill(0);
+  for (const layer of map.layers) {
+    paintLayer(png, layer, scale);
+  }
+  return import_pngjs.PNG.sync.write(png);
+}
+function paintLayer(png, layer, scale) {
+  const color = layer.type === "segment" ? segmentColor(layer.segmentId ?? 0) : RGBA[layer.type];
+  for (const run of layer.runs) {
+    paintRun(png, run, color, scale, png.width, png.height);
+  }
+}
+function paintRun(png, run, color, scale, width, height) {
+  const [xPx, yPx, len] = run;
+  for (let i = 0; i < len; i += 1) {
+    const baseX = (xPx + i) * scale;
+    const baseY = yPx * scale;
+    for (let dy = 0; dy < scale; dy += 1) {
+      const py = baseY + dy;
+      if (py < 0 || py >= height) {
+        continue;
+      }
+      for (let dx = 0; dx < scale; dx += 1) {
+        const px = baseX + dx;
+        if (px < 0 || px >= width) {
+          continue;
+        }
+        const off = (py * width + px) * 4;
+        png.data[off] = color[0];
+        png.data[off + 1] = color[1];
+        png.data[off + 2] = color[2];
+        png.data[off + 3] = color[3];
+      }
+    }
+  }
+}
+
+// src/models/vacuum/map/oss-fetch.ts
+var OSS_DOWNLOAD_PATH = "/dreame-user-iot/iotfile/getDownloadUrl";
+var DEFAULT_TTL_MS = 30 * 60 * 1e3;
+var OssFetcher = class {
+  ttlMs;
+  now;
+  fetchImpl;
+  cache = /* @__PURE__ */ new Map();
+  /** In-flight fetchBlob calls, keyed `did:filename`. Lets us coalesce concurrent fetches for the same blob. */
+  inflight = /* @__PURE__ */ new Map();
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.now = opts.now ?? Date.now;
+    this.fetchImpl = opts.fetchImpl ?? defaultFetch;
+  }
+  /**
+   * Resolve `input.filename` to a signed download URL. Uses the cache
+   * when fresh; on cache hit returns the cached URL with
+   * `current=<unix_ts>` appended (using `&` if the URL already has a
+   * query string — Aliyun signed URLs always do).
+   */
+  async resolveUrl(input) {
+    const key2 = `${input.did}:${input.filename}`;
+    const now = this.now();
+    const cached = this.cache.get(key2);
+    if (cached && cached.expiresAt > now) {
+      const sep = cached.url.includes("?") ? "&" : "?";
+      return `${cached.url}${sep}current=${Math.floor(now / 1e3)}`;
+    }
+    const ctx = RequestContext.from({ ...input, fetchImpl: this.fetchImpl });
+    const resp = await httpPostJson({
+      ctx,
+      url: ctx.url(OSS_DOWNLOAD_PATH),
+      headers: ctx.headers({
+        accessToken: input.accessToken,
+        contentType: "application/json"
+      }),
+      body: JSON.stringify({
+        did: input.did,
+        model: input.model,
+        filename: input.filename,
+        region: input.region
+      }),
+      context: "oss download url",
+      ...input.signal !== void 0 ? { signal: input.signal } : {},
+      ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+    });
+    if (typeof resp.data !== "string" || resp.data.length === 0) {
+      throw new DreameApiError(
+        `oss download url response missing data: ${JSON.stringify(resp).slice(0, 200)}`,
+        200,
+        resp
+      );
+    }
+    this.cache.set(key2, { url: resp.data, expiresAt: now + this.ttlMs });
+    return resp.data;
+  }
+  /**
+   * Resolve, GET the signed URL, and return the raw bytes.
+   *
+   * Concurrent calls for the same `(did, filename)` pair are coalesced
+   * into a single network request — the second caller awaits the first's
+   * Promise instead of issuing a duplicate fetch.
+   */
+  async fetchBlob(input) {
+    const key2 = `${input.did}:${input.filename}`;
+    const existing = this.inflight.get(key2);
+    if (existing) {
+      return existing;
+    }
+    const promise = this.#doFetchBlob(input).finally(() => {
+      this.inflight.delete(key2);
+    });
+    this.inflight.set(key2, promise);
+    return promise;
+  }
+  async #doFetchBlob(input) {
+    const url = await this.resolveUrl(input);
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: "GET",
+        ...input.signal !== void 0 ? { signal: input.signal } : {}
+      });
+    } catch (err) {
+      throw new DreameTransportError(`oss download network error`, err);
+    }
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new DreameApiError(
+        `oss download failed: ${res.status} ${text.slice(0, 200)}`,
+        res.status
+      );
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  /** Drop all cached URLs. */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+
+// src/models/vacuum/vacuum-device.ts
+var SUCTION = enumLookup([
+  0 /* Quiet */,
+  1 /* Standard */,
+  2 /* Intense */,
+  3 /* Max */
+]);
+var WATER = enumLookup([1 /* Low */, 2 /* Medium */, 3 /* High */]);
+var CLEAN_MODE = enumLookup([
+  0 /* Sweeping */,
+  1 /* Mopping */,
+  2 /* SweepAndMop */,
+  3 /* MopAfterSweep */
+]);
+var STATE = enumLookup(
+  Object.values(MiotState).filter((v) => typeof v === "number")
+);
+var CHARGING = enumLookup([
+  1 /* Charging */,
+  2 /* Discharging */,
+  5 /* Returning */
+]);
+var TASK = enumLookup([
+  1 /* InterruptedOrPaused */,
+  2 /* Active */,
+  3 /* Transitioning */,
+  6 /* OnDockIdle */,
+  12 /* TransientPauseEdge */,
+  14 /* NeedsIntervention */
+]);
+var VacuumDevice = class extends BaseDevice {
+  #caps;
+  #lastMap = null;
+  constructor(input) {
+    super({
+      ...input,
+      // Inject the vacuum resolver so the inherited generic `capabilities`
+      // getter carries the vacuum token set (no banned cast).
+      capabilities: input.capabilities ?? new VacuumCapabilityResolver().resolve(input.device.model)
+    });
+    this.#caps = getVacuumCapabilities(input.device.model);
+  }
+  /** Rich, vacuum-specific capability record (booleans + supported enums). */
+  get vacuumCapabilities() {
+    return this.#caps;
+  }
+  #num(siid, piid) {
+    return asNum(this.getProperty(siid, piid)?.value);
+  }
+  // -- typed state --------------------------------------------------------
+  get statusRaw() {
+    return this.#num(VACUUM_PROP.STATE.siid, VACUUM_PROP.STATE.piid);
+  }
+  get status() {
+    return STATE(this.statusRaw);
+  }
+  get battery() {
+    return this.#num(BATTERY_PROP.LEVEL.siid, BATTERY_PROP.LEVEL.piid);
+  }
+  get chargingRaw() {
+    return this.#num(BATTERY_PROP.CHARGING_STATUS.siid, BATTERY_PROP.CHARGING_STATUS.piid);
+  }
+  get charging() {
+    return CHARGING(this.chargingRaw);
+  }
+  get isCharging() {
+    return this.charging === 1 /* Charging */;
+  }
+  /** Docked => MiotState Charging or ChargingComplete (on the dock). */
+  get isDocked() {
+    const s = this.status;
+    return s === 6 /* Charging */ || s === 13 /* ChargingComplete */;
+  }
+  get suctionRaw() {
+    return this.#num(VACUUM_PROP.SUCTION_LEVEL.siid, VACUUM_PROP.SUCTION_LEVEL.piid);
+  }
+  get suction() {
+    return SUCTION(this.suctionRaw);
+  }
+  get waterRaw() {
+    return this.#num(VACUUM_PROP.WATER_VOLUME.siid, VACUUM_PROP.WATER_VOLUME.piid);
+  }
+  get water() {
+    return WATER(this.waterRaw);
+  }
+  /** Reads the SAFE CLEAN_MODE_SETTING (siid 2 piid 6), plain 0-3. */
+  get cleaningModeRaw() {
+    return this.#num(VACUUM_PROP.CLEAN_MODE_SETTING.siid, VACUUM_PROP.CLEAN_MODE_SETTING.piid);
+  }
+  get cleaningMode() {
+    return CLEAN_MODE(this.cleaningModeRaw);
+  }
+  get taskStatusRaw() {
+    return this.#num(VACUUM_PROP.TASK_STATUS.siid, VACUUM_PROP.TASK_STATUS.piid);
+  }
+  get taskStatus() {
+    return TASK(this.taskStatusRaw);
+  }
+  get errorCode() {
+    return this.#num(VACUUM_PROP.ERROR.siid, VACUUM_PROP.ERROR.piid);
+  }
+  get faults() {
+    return parseFaultList(
+      this.getProperty(VACUUM_PROP.FAULTS_STR.siid, VACUUM_PROP.FAULTS_STR.piid)?.value
+    );
+  }
+  get taskProgressPct() {
+    return this.#num(VACUUM_PROP.TASK_PROGRESS_PCT.siid, VACUUM_PROP.TASK_PROGRESS_PCT.piid);
+  }
+  get mainBrushLeftPct() {
+    return this.#num(CONSUMABLE_PROP.MAIN_BRUSH_LEFT.siid, CONSUMABLE_PROP.MAIN_BRUSH_LEFT.piid);
+  }
+  get sideBrushLeftPct() {
+    return this.#num(CONSUMABLE_PROP.SIDE_BRUSH_LEFT.siid, CONSUMABLE_PROP.SIDE_BRUSH_LEFT.piid);
+  }
+  get filterLeftPct() {
+    return this.#num(CONSUMABLE_PROP.FILTER_LEFT.siid, CONSUMABLE_PROP.FILTER_LEFT.piid);
+  }
+  get volume() {
+    return this.#num(SETTINGS_PROP.VOLUME.siid, SETTINGS_PROP.VOLUME.piid);
+  }
+  // -- command helpers ----------------------------------------------------
+  #resolveCleanOpts(opts) {
+    const repeats = Math.max(1, Math.trunc(opts.repeats ?? 1));
+    const fan = opts.fan ?? this.suctionRaw ?? 1 /* Standard */;
+    const water = opts.water ?? this.waterRaw ?? 2 /* Medium */;
+    return { repeats, fan, water };
+  }
+  #startCustom(mode, payload) {
+    return this.callAction(VACUUM_ACTION.START_CUSTOM.siid, VACUUM_ACTION.START_CUSTOM.aiid, [
+      { piid: 1, value: mode },
+      { piid: 10, value: JSON.stringify(payload) }
+    ]);
+  }
+  #requireCap(flag, op, feature) {
+    if (!flag) {
+      throw new DreameError(`${op}: model ${this.model} does not support ${feature}`);
+    }
+  }
+  // -- no-arg commands ----------------------------------------------------
+  /**
+   * Start cleaning (MIoT action siid 2 aiid 1). Named `startCleaning` — NOT
+   * `start` — because `BaseDevice.start()` is the lifecycle method that opens
+   * the MQTT push, and the facade relies on that meaning. Donor `node-dreame`
+   * names this `start()` only because its standalone `Vacuum` class owns no
+   * lifecycle method to collide with.
+   */
+  startCleaning() {
+    return this.callAction(VACUUM_ACTION.START.siid, VACUUM_ACTION.START.aiid, []);
+  }
+  pause() {
+    return this.callAction(VACUUM_ACTION.PAUSE.siid, VACUUM_ACTION.PAUSE.aiid, []);
+  }
+  stop() {
+    return this.callAction(VACUUM_ACTION.STOP.siid, VACUUM_ACTION.STOP.aiid, []);
+  }
+  /** Return to the dock / charge (MIoT action CHARGE, siid 3 aiid 1). */
+  dock() {
+    return this.callAction(VACUUM_ACTION.CHARGE.siid, VACUUM_ACTION.CHARGE.aiid, []);
+  }
+  locate() {
+    return this.callAction(VACUUM_ACTION.LOCATE.siid, VACUUM_ACTION.LOCATE.aiid, []);
+  }
+  clearWarning() {
+    return this.callAction(VACUUM_ACTION.CLEAR_WARNING.siid, VACUUM_ACTION.CLEAR_WARNING.aiid, []);
+  }
+  async startAutoEmpty() {
+    this.#requireCap(this.#caps.canAutoEmpty, "startAutoEmpty", "auto-empty");
+    return this.callAction(
+      VACUUM_ACTION.START_AUTO_EMPTY.siid,
+      VACUUM_ACTION.START_AUTO_EMPTY.aiid,
+      []
+    );
+  }
+  // -- settings writes ----------------------------------------------------
+  /** Type-safe suction write. Validates against the model's supported levels. */
+  setSuction(level) {
+    return this.setSuctionRaw(level);
+  }
+  /**
+   * Untyped suction write: validates an arbitrary number against the model's
+   * supported levels and rejects with `RangeError` on an invalid input. This
+   * is the raw-input entry point so callers (and tests) can exercise validation
+   * with no type assertions. `async` so the guard surfaces as a rejection.
+   */
+  async setSuctionRaw(level) {
+    if (!this.#caps.supportedSuctionLevels.includes(level)) {
+      throw new RangeError(`setSuction: unsupported suction level ${String(level)}`);
+    }
+    return this.setProperty({ ...VACUUM_PROP.SUCTION_LEVEL, value: level });
+  }
+  /** Type-safe water-volume write. Validates against supported volumes. */
+  setWater(volume) {
+    return this.setWaterRaw(volume);
+  }
+  /** Untyped water-volume write: validates an arbitrary number (zero casts). */
+  async setWaterRaw(volume) {
+    if (!this.#caps.supportedWaterVolumes.includes(volume)) {
+      throw new RangeError(`setWater: unsupported water volume ${String(volume)}`);
+    }
+    return this.setProperty({ ...VACUUM_PROP.WATER_VOLUME, value: volume });
+  }
+  /** SAFE clean-mode write — uses CLEAN_MODE_SETTING (siid 2 piid 6), never the 0x1400 bitfield. */
+  setCleaningMode(mode) {
+    return this.setProperty({ ...VACUUM_PROP.CLEAN_MODE_SETTING, value: mode });
+  }
+  // -- targeted cleaning --------------------------------------------------
+  async cleanSegments(ids, opts = {}) {
+    if (ids.length === 0) {
+      throw new RangeError("cleanSegments: ids must not be empty");
+    }
+    this.#requireCap(this.#caps.canCleanPerRoom, "cleanSegments", "per-room cleaning");
+    const { repeats, fan, water } = this.#resolveCleanOpts(opts);
+    const selects = ids.map((id) => [id, repeats, fan, water, 1]);
+    return this.#startCustom(CUSTOM_CLEAN_MODE.SEGMENT, { selects });
+  }
+  async cleanZones(zones, opts = {}) {
+    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((z3) => [
+      Math.round(z3.x0),
+      Math.round(z3.y0),
+      Math.round(z3.x1),
+      Math.round(z3.y1),
+      repeats,
+      fan,
+      water
+    ]);
+    return this.#startCustom(CUSTOM_CLEAN_MODE.ZONE, { areas });
+  }
+  /**
+   * Send the robot to clean a single point (the SPOT custom-clean action,
+   * mode 20). ASSUMED: Tasshack's "go to point" is the same SPOT action — this
+   * is exposed as `cleanSpot` because it maps to the spot/custom-clean action,
+   * not a distinct go-to. No separate `goTo` is exposed.
+   */
+  async cleanSpot(point, opts = {}) {
+    this.#requireCap(this.#caps.canCleanPerRoom, "cleanSpot", "per-room cleaning");
+    const { repeats, fan, water } = this.#resolveCleanOpts(opts);
+    const points = [[Math.round(point.x), Math.round(point.y), repeats, fan, water]];
+    return this.#startCustom(CUSTOM_CLEAN_MODE.SPOT, { points });
+  }
+  // -- maps ---------------------------------------------------------------
+  /** The most-recently-decoded map, or `null` until {@link getMap} succeeds. */
+  get lastMap() {
+    return this.#lastMap;
+  }
+  /**
+   * The current room/segment id, derived from the most-recently-decoded map's
+   * active-segment set (`sa`). `null` when no map has been fetched or no
+   * segment is currently active. REPLACES the P3 "intentionally not exposed"
+   * placeholder — the value now comes from the decoded map layer (P5).
+   */
+  get currentSegmentId() {
+    return this.#lastMap?.segments.find((s) => s.active)?.id ?? null;
+  }
+  /**
+   * Fetch the current saved/live-map blob (OSS), decode it, cache it as
+   * {@link lastMap}, emit a `'map'` event, and return the {@link VacuumMap}.
+   *
+   * Capability-gated on `canMap`. The `filename` is the OSS object name the
+   * caller resolves from a `mapInfo`/PATH push. The fetcher is injectable so
+   * tests drive it with a synthetic blob and no live network.
+   *
+   * NOTE: active live-frame P-frame STREAMING (continuous merge orchestration)
+   * is a documented follow-up; `getMap` resolves a single frame here. The
+   * `applyVacuumPFrame` merge primitive ships separately for that work.
+   */
+  async getMap(input) {
+    this.#requireCap(this.#caps.canMap, "getMap", "map decoding");
+    const session = this.currentSession();
+    const region = this.region;
+    const fetcher = input.fetcher ?? new OssFetcher();
+    const fetchInput = {
+      host: input.host ?? REGION_HOSTS[region],
+      accessToken: session.accessToken,
+      region,
+      did: this.deviceId,
+      model: this.model,
+      filename: input.filename,
+      ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+      ...input.signal !== void 0 ? { signal: input.signal } : {}
+    };
+    const blob = await fetcher.fetchBlob(fetchInput);
+    const map = decodeVacuumMap(blob, {
+      ...input.key !== void 0 ? { key: input.key } : {},
+      ...input.iv !== void 0 ? { iv: input.iv } : {}
+    });
+    this.#lastMap = map;
+    this.emit("map", map);
+    return map;
+  }
+  /** Props worth seeding on start() / polling — exported for the facade. */
+  static DEFAULT_PROPS = [
+    VACUUM_PROP.STATE,
+    VACUUM_PROP.ERROR,
+    VACUUM_PROP.FAULTS_STR,
+    VACUUM_PROP.TASK_STATUS,
+    VACUUM_PROP.SUCTION_LEVEL,
+    VACUUM_PROP.WATER_VOLUME,
+    VACUUM_PROP.CLEAN_MODE_SETTING,
+    VACUUM_PROP.TASK_PROGRESS_PCT,
+    BATTERY_PROP.LEVEL,
+    BATTERY_PROP.CHARGING_STATUS,
+    CONSUMABLE_PROP.MAIN_BRUSH_LEFT,
+    CONSUMABLE_PROP.SIDE_BRUSH_LEFT,
+    CONSUMABLE_PROP.FILTER_LEFT,
+    SETTINGS_PROP.VOLUME
+  ];
+};
+
+// src/models/mower/properties.ts
+var MOWER_PROP = {
+  /** VERIFIED-by-donor — pose + coverage telemetry (binary). P4 uses progress % only. */
+  POSE_COVERAGE: { siid: 1, piid: 4 },
+  /** VERIFIED-by-donor — MowerStatus (DeviceStatus). */
+  STATUS: { siid: 2, piid: 1 },
+  /** VERIFIED-by-donor — device code blob (model/region). Not decoded in P4. */
+  DEVICE_CODE: { siid: 2, piid: 2 },
+  /** VERIFIED-by-donor — mission task descriptor object {t,d:{...}}; also the action target. */
+  SCHEDULING_TASK: { siid: 2, piid: 50 },
+  /** VERIFIED-by-donor — mission completion summary (often empty). */
+  SCHEDULING_SUMMARY: { siid: 2, piid: 52 },
+  /** VERIFIED-by-donor — per-zone control status {status:[[zone,code],...]}. */
+  MOWER_CONTROL_STATUS: { siid: 2, piid: 56 },
+  /** VERIFIED-by-donor — battery percentage 0-100. */
+  BATTERY: { siid: 3, piid: 1 },
+  /** VERIFIED-by-donor — MowerChargingStatus. */
+  CHARGING_STATUS: { siid: 3, piid: 2 },
+  /** VERIFIED-by-donor — task status code (MowerTaskStatus; mostly diagnostic). */
+  TASK_STATUS: { siid: 5, piid: 104 }
+};
+var MOWER_ACTION = {
+  START_MOWING: { siid: 5, aiid: 1 },
+  STOP: { siid: 5, aiid: 2 },
+  DOCK: { siid: 5, aiid: 3 },
+  PAUSE: { siid: 5, aiid: 4 }
+};
+var TASK_OPCODE = {
+  RESUME: { m: "a", p: 0, o: 5 },
+  ALL_AREA: 100,
+  EDGE: 101,
+  ZONE: 102,
+  SPOT: 103
+};
+function buildResumePayload() {
+  return { m: "a", p: 0, o: 5 };
+}
+function buildAllAreaPayload(mapId) {
+  return { m: "a", p: 0, o: TASK_OPCODE.ALL_AREA, d: { region_id: [mapId], area_id: [] } };
+}
+function buildZonePayload(zoneIds) {
+  return { m: "a", p: 0, o: TASK_OPCODE.ZONE, d: { region: [...zoneIds] } };
+}
+function buildEdgePayload(contourIds) {
+  return { m: "a", p: 0, o: TASK_OPCODE.EDGE, d: { edge: contourIds.map((c) => [...c]) } };
+}
+function buildSpotPayload(spotAreaIds) {
+  return { m: "a", p: 0, o: TASK_OPCODE.SPOT, d: { area: [...spotAreaIds] } };
+}
+
+// src/models/mower/enums.ts
+var MowerStatus = /* @__PURE__ */ ((MowerStatus2) => {
+  MowerStatus2[MowerStatus2["NoStatus"] = 0] = "NoStatus";
+  MowerStatus2[MowerStatus2["Mowing"] = 1] = "Mowing";
+  MowerStatus2[MowerStatus2["Standby"] = 2] = "Standby";
+  MowerStatus2[MowerStatus2["Paused"] = 3] = "Paused";
+  MowerStatus2[MowerStatus2["PausedDueToErrors"] = 4] = "PausedDueToErrors";
+  MowerStatus2[MowerStatus2["ReturningToCharge"] = 5] = "ReturningToCharge";
+  MowerStatus2[MowerStatus2["Charging"] = 6] = "Charging";
+  MowerStatus2[MowerStatus2["Mapping"] = 11] = "Mapping";
+  MowerStatus2[MowerStatus2["ChargingComplete"] = 13] = "ChargingComplete";
+  MowerStatus2[MowerStatus2["Updating"] = 14] = "Updating";
+  return MowerStatus2;
+})(MowerStatus || {});
+var MowerChargingStatus = /* @__PURE__ */ ((MowerChargingStatus2) => {
+  MowerChargingStatus2[MowerChargingStatus2["NotDocked"] = 0] = "NotDocked";
+  MowerChargingStatus2[MowerChargingStatus2["Charging"] = 1] = "Charging";
+  MowerChargingStatus2[MowerChargingStatus2["NotCharging"] = 2] = "NotCharging";
+  MowerChargingStatus2[MowerChargingStatus2["ChargingCompleted"] = 3] = "ChargingCompleted";
+  MowerChargingStatus2[MowerChargingStatus2["ReturnToCharge"] = 5] = "ReturnToCharge";
+  MowerChargingStatus2[MowerChargingStatus2["ChargingPausedLowTemperature"] = 16] = "ChargingPausedLowTemperature";
+  return MowerChargingStatus2;
+})(MowerChargingStatus || {});
+var MowerControlAction = /* @__PURE__ */ ((MowerControlAction3) => {
+  MowerControlAction3[MowerControlAction3["Queued"] = -1] = "Queued";
+  MowerControlAction3[MowerControlAction3["Continue"] = 0] = "Continue";
+  MowerControlAction3[MowerControlAction3["Completed"] = 2] = "Completed";
+  MowerControlAction3[MowerControlAction3["Pause"] = 4] = "Pause";
+  return MowerControlAction3;
+})(MowerControlAction || {});
+var MowerTaskStatus = /* @__PURE__ */ ((MowerTaskStatus2) => {
+  MowerTaskStatus2[MowerTaskStatus2["SpotIncomplete"] = 7] = "SpotIncomplete";
+  return MowerTaskStatus2;
+})(MowerTaskStatus || {});
+
+// src/models/mower/decode.ts
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numArrayOrNull(v) {
+  if (!Array.isArray(v)) {
+    return null;
+  }
+  const out = [];
+  for (const n of v) {
+    if (typeof n !== "number") {
+      return null;
+    }
+    out.push(n);
+  }
+  return out;
+}
+function parseTaskDescriptor(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const t = value["t"];
+  const d = value["d"];
+  if (typeof t !== "string" || !isRecord(d)) {
+    return null;
+  }
+  const exe = d["exe"];
+  const o = d["o"];
+  const status = d["status"];
+  if (typeof exe !== "boolean" || typeof o !== "number" || typeof status !== "boolean") {
+    return null;
+  }
+  return {
+    taskType: t === "TASK" ? "TASK" : "UNKNOWN",
+    executionActive: exe,
+    coverageTarget: o,
+    taskActive: status,
+    areaId: numArrayOrNull(d["area_id"]),
+    regionId: numArrayOrNull(d["region_id"]),
+    elapsedTime: typeof d["time"] === "number" ? d["time"] : null
+  };
+}
+var controlLookup = enumLookup([
+  -1 /* Queued */,
+  0 /* Continue */,
+  2 /* Completed */,
+  4 /* Pause */
+]);
+function controlActionFor(code) {
+  return controlLookup(code);
+}
+function parseControlStatus(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const status = value["status"];
+  if (!Array.isArray(status)) {
+    return null;
+  }
+  if (status.length === 0) {
+    return { action: null, statusCode: null, zones: [] };
+  }
+  const zones = [];
+  for (const entry of status) {
+    const pair = numArrayOrNull(entry);
+    if (pair === null || pair.length < 2) {
+      return null;
+    }
+    zones.push(pair);
+  }
+  const primary = zones.find((e) => e[1] === 0) ?? zones[0];
+  const code = primary?.[1] ?? null;
+  return {
+    action: code === null ? null : controlActionFor(code),
+    statusCode: code,
+    zones
+  };
+}
+
+// src/models/mower/capabilities.ts
+var FALLBACK2 = {
+  verified: false,
+  canMowZones: false,
+  canMowEdges: false,
+  canMowSpots: false,
+  canMowAllArea: false,
+  canResume: true,
+  canSchedule: true,
+  // Vector-map parsing is model-agnostic, but an unknown model leaves it false
+  // until its firmware is verified to expose the batch device-data surface.
+  canMap: false
+};
+var A1_FAMILY = {
+  canMowZones: true,
+  canMowEdges: true,
+  canMowSpots: true,
+  canMowAllArea: true,
+  canResume: true,
+  canSchedule: true,
+  canMap: true
+};
+function deepFreeze2(obj) {
+  if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+    Object.freeze(obj);
+    for (const v of Object.values(obj)) {
+      deepFreeze2(v);
+    }
+  }
+  return obj;
+}
+var MODEL_CAPABILITIES2 = {
+  /** Dreame A1 — the user's mower. ASSUMED from the donor command surface. */
+  "dreame.mower.p2255": { model: "dreame.mower.p2255", verified: false, ...A1_FAMILY }
+};
+for (const entry of Object.values(MODEL_CAPABILITIES2)) {
+  deepFreeze2(entry);
+}
+function getMowerCapabilities(model) {
+  const known = MODEL_CAPABILITIES2[model];
+  if (known) {
+    return known;
+  }
+  return deepFreeze2({ model, ...FALLBACK2 });
+}
+function tokensFor2(c) {
+  const tokens = /* @__PURE__ */ new Set();
+  const add = (flag, token) => {
+    if (flag) {
+      tokens.add(token);
+    }
+  };
+  add(c.canMowZones, "mow-zones");
+  add(c.canMowEdges, "mow-edges");
+  add(c.canMowSpots, "mow-spots");
+  add(c.canMowAllArea, "mow-all-area");
+  add(c.canResume, "resume");
+  add(c.canSchedule, "schedule");
+  return tokens;
+}
+var MowerCapabilitySet = class {
+  model;
+  #tokens;
+  constructor(model, tokens) {
+    this.model = model;
+    this.#tokens = tokens;
+  }
+  has(token) {
+    return this.#tokens.has(token);
+  }
+  list() {
+    return [...this.#tokens];
+  }
+};
+var MowerCapabilityResolver = class {
+  resolve(model) {
+    return new MowerCapabilitySet(model, tokensFor2(getMowerCapabilities(model)));
+  }
+};
+
+// src/models/mower/map/parser.ts
+var PATH_SENTINEL_X = 32767;
+var PATH_SENTINEL_Y = -32768;
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asNumber(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function asString(v, fallback) {
+  return typeof v === "string" ? v : fallback;
+}
+function mapIdFromIndex(mapIndex) {
+  return mapIndex + 1;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function reassembleMapChunks(batchData, prefix) {
+  const pattern = new RegExp(`^${escapeRegex(prefix)}\\.(\\d+)$`);
+  const chunks = [];
+  for (const [key2, value] of Object.entries(batchData)) {
+    const match = pattern.exec(key2);
+    if (match && typeof value === "string") {
+      const idx = Number(match[1]);
+      chunks.push({ idx, value });
+    }
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  chunks.sort((a, b) => a.idx - b.idx);
+  return chunks.map((c) => c.value).join("");
+}
+function parseSplitPos(info) {
+  if (typeof info === "string" && /^\d+$/.test(info)) {
+    return Number(info);
+  }
+  return 0;
+}
+function parsePolygonList(dataMap) {
+  if (!isRecord2(dataMap) || dataMap["dataType"] !== "Map") {
+    return [];
+  }
+  const value = dataMap["value"];
+  return Array.isArray(value) ? value : [];
+}
+function extractPathCoords(pathList) {
+  if (!Array.isArray(pathList)) {
+    return [];
+  }
+  const out = [];
+  for (const p of pathList) {
+    if (isRecord2(p) && typeof p["x"] === "number" && typeof p["y"] === "number") {
+      out.push({ x: p["x"], y: p["y"] });
+    }
+  }
+  return out;
+}
+function extractContourId(raw) {
+  if (typeof raw === "string") {
+    const parts = raw.split(",").map((part) => part.trim());
+    if (parts.length !== 2) {
+      throw new Error(`Invalid contour id: ${raw}`);
+    }
+    const a = Number(parts[0]);
+    const b = Number(parts[1]);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+      throw new Error(`Invalid contour id: ${raw}`);
+    }
+    return [Math.trunc(a), Math.trunc(b)];
+  }
+  if (Array.isArray(raw) && raw.length === 2) {
+    const pair = raw;
+    const a = pair[0];
+    const b = pair[1];
+    if (typeof a === "number" && typeof b === "number") {
+      return [Math.trunc(a), Math.trunc(b)];
+    }
+  }
+  throw new Error(`Invalid contour id: ${JSON.stringify(raw)}`);
+}
+function asEntry(entry) {
+  if (!Array.isArray(entry) || entry.length < 2) {
+    return null;
+  }
+  const tuple = entry;
+  const data = tuple[1];
+  if (!isRecord2(data)) {
+    return null;
+  }
+  return { id: tuple[0], data };
+}
+function parseZones(list, includeTimes) {
+  const out = [];
+  for (const raw of list) {
+    const entry = asEntry(raw);
+    if (!entry) {
+      continue;
+    }
+    const { id, data } = entry;
+    out.push({
+      zoneId: asNumber(id, 0),
+      path: extractPathCoords(data["path"]),
+      name: asString(data["name"], ""),
+      zoneType: asNumber(data["type"], 0),
+      shapeType: includeTimes ? asNumber(data["shapeType"], 0) : 0,
+      area: includeTimes ? asNumber(data["area"], 0) : 0,
+      time: includeTimes ? asNumber(data["time"], 0) : 0,
+      etime: includeTimes ? asNumber(data["etime"], 0) : 0
+    });
+  }
+  return out;
+}
+function parseSpotAreas(list) {
+  const out = [];
+  for (const raw of list) {
+    const entry = asEntry(raw);
+    if (!entry) {
+      continue;
+    }
+    const { id, data } = entry;
+    out.push({
+      areaId: Math.trunc(asNumber(id, 0)),
+      path: extractPathCoords(data["path"]),
+      name: asString(data["name"], ""),
+      shapeType: asNumber(data["shapeType"], 0),
+      area: asNumber(data["area"], 0)
+    });
+  }
+  return out;
+}
+function parsePaths(list) {
+  const out = [];
+  for (const raw of list) {
+    const entry = asEntry(raw);
+    if (!entry) {
+      continue;
+    }
+    const { id, data } = entry;
+    out.push({
+      pathId: asNumber(id, 0),
+      path: extractPathCoords(data["path"]),
+      pathType: asNumber(data["type"], 0)
+    });
+  }
+  return out;
+}
+function parseContours(list) {
+  const out = [];
+  for (const raw of list) {
+    const entry = asEntry(raw);
+    if (!entry) {
+      continue;
+    }
+    const { id, data } = entry;
+    out.push({
+      contourId: extractContourId(id),
+      path: extractPathCoords(data["path"]),
+      contourType: asNumber(data["type"], 0),
+      shapeType: asNumber(data["shapeType"], 0)
+    });
+  }
+  return out;
+}
+function parseBoundary(raw) {
+  if (!isRecord2(raw)) {
+    return null;
+  }
+  const { x1, y1, x2, y2 } = raw;
+  if (typeof x1 !== "number" || typeof y1 !== "number" || typeof x2 !== "number" || typeof y2 !== "number") {
+    return null;
+  }
+  return { x1, y1, x2, y2 };
+}
+function parseMowerMap(mapJsonStr) {
+  const data = JSON.parse(mapJsonStr);
+  if (!isRecord2(data)) {
+    throw new Error("Map JSON is not an object");
+  }
+  const mapIndex = asNumber(data["mapIndex"], 0);
+  return {
+    zones: parseZones(parsePolygonList(data["mowingAreas"]), true),
+    spotAreas: parseSpotAreas(parsePolygonList(data["spotAreas"])),
+    forbiddenAreas: parseZones(parsePolygonList(data["forbiddenAreas"]), false),
+    paths: parsePaths(parsePolygonList(data["paths"])),
+    contours: parseContours(parsePolygonList(data["contours"])),
+    boundary: parseBoundary(data["boundary"]),
+    totalArea: asNumber(data["totalArea"], 0),
+    name: asString(data["name"], ""),
+    mapIndex,
+    mapId: mapIdFromIndex(mapIndex),
+    mowPaths: [],
+    availableMaps: [],
+    currentMapId: null,
+    lastUpdated: Date.now()
+  };
+}
+function parseMowPaths(batchData) {
+  const reassembled = reassembleMapChunks(batchData, "M_PATH");
+  if (!reassembled) {
+    return [];
+  }
+  const splitPos = parseSplitPos(batchData["M_PATH.info"]);
+  let raw = reassembled;
+  if (splitPos > 0 && splitPos < raw.length) {
+    raw = raw.slice(splitPos);
+  }
+  const trimmed = raw.trim();
+  if (trimmed.length === 0 || trimmed === "[]") {
+    return [];
+  }
+  const pairPattern = /\[(-?\d+),(-?\d+)\]/g;
+  const rawPairs = [];
+  for (const m of raw.matchAll(pairPattern)) {
+    rawPairs.push([Number(m[1]), Number(m[2])]);
+  }
+  if (rawPairs.length === 0) {
+    return [];
+  }
+  const segments = [];
+  let current = [];
+  for (const [x, y] of rawPairs) {
+    if (x === PATH_SENTINEL_X && y === PATH_SENTINEL_Y) {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+    } else {
+      current.push({ x: x * 10, y: y * 10 });
+    }
+  }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  if (segments.length === 0) {
+    return [];
+  }
+  return [{ zoneId: 0, segments }];
+}
+function parseMapPart(part) {
+  const trimmed = part.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  let arr;
+  try {
+    arr = JSON.parse(trimmed);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(arr)) {
+    return [];
+  }
+  const out = [];
+  for (const item of arr) {
+    if (typeof item !== "string") {
+      continue;
+    }
+    try {
+      out.push(parseMowerMap(item));
+    } catch {
+    }
+  }
+  return out;
+}
+function parseBatchMapData(batchData) {
+  if (Object.keys(batchData).length === 0) {
+    return null;
+  }
+  const rawMap = reassembleMapChunks(batchData, "MAP");
+  if (!rawMap) {
+    return null;
+  }
+  const splitPos = parseSplitPos(batchData["MAP.info"]);
+  const parts = splitPos > 0 && splitPos < rawMap.length ? [rawMap.slice(0, splitPos), rawMap.slice(splitPos)] : [rawMap];
+  const parsedMaps = [];
+  for (const part of parts) {
+    parsedMaps.push(...parseMapPart(part));
+  }
+  if (parsedMaps.length === 0) {
+    return null;
+  }
+  const primary = parsedMaps.find((m) => m.mapIndex === 0) ?? parsedMaps[0];
+  if (!primary) {
+    return null;
+  }
+  const availableMaps = [...parsedMaps].sort((a, b) => a.mapId - b.mapId).map((m) => ({
+    mapId: m.mapId,
+    mapIndex: m.mapIndex,
+    name: m.name,
+    totalArea: m.totalArea
+  }));
+  const mowPaths = parseMowPaths(batchData);
+  return {
+    ...primary,
+    availableMaps,
+    mowPaths,
+    currentMapId: primary.mapId
+  };
+}
+
+// src/models/mower/map/render.ts
+var DEFAULT_WIDTH = 1200;
+var DEFAULT_HEIGHT = 1200;
+var DEFAULT_PADDING = 50;
+var BACKGROUND = "#f5f5f0";
+var MAP_BOUNDARY = "#006400";
+var MOWING_PATH = "#ffa500";
+var NAV_PATH = "#b4b4b4";
+var OBSTACLE_STROKE = "#ff4d00";
+var OBSTACLE_FILL = "#ff4d0065";
+var TEXT_COLOR = "#000000";
+var ZONE_COLORS = [
+  ["#a4d291c8", "#86be73"],
+  ["#a0c8dcc8", "#82aac8"],
+  ["#f0c8aac8", "#dcaf8c"],
+  ["#f0b4b4c8", "#dc9696"],
+  ["#e6dca0c8", "#d2c882"],
+  ["#beaadcc8", "#aa91c8"],
+  ["#aad7d2c8", "#8cc3be"],
+  ["#dcbea0c8", "#c8a582"]
+];
+var SENTINEL = 2147483647;
+function calculateBounds(allPoints) {
+  const valid = allPoints.filter((p) => p.x !== SENTINEL && p.y !== SENTINEL);
+  if (valid.length === 0) {
+    return { minX: 0, minY: 0, maxX: 100, maxY: 100 };
+  }
+  let minX = valid[0]?.x ?? 0;
+  let maxX = minX;
+  let minY = valid[0]?.y ?? 0;
+  let maxY = minY;
+  for (const p of valid) {
+    if (p.x < minX) minX = p.x;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+function coordToPixel(point, bounds, width, height, padding) {
+  let { maxX, maxY } = bounds;
+  const { minX, minY } = bounds;
+  if (maxX === minX) {
+    maxX = minX + 100;
+  }
+  if (maxY === minY) {
+    maxY = minY + 100;
+  }
+  const coordWidth = maxX - minX;
+  const coordHeight = maxY - minY;
+  const availableWidth = width - 2 * padding;
+  const availableHeight = height - 2 * padding;
+  const scale = Math.min(availableWidth / coordWidth, availableHeight / coordHeight);
+  const renderedWidth = coordWidth * scale;
+  const renderedHeight = coordHeight * scale;
+  const offsetX = padding + (availableWidth - renderedWidth) / 2;
+  const offsetY = padding + (availableHeight - renderedHeight) / 2;
+  const px = Math.trunc(offsetX + (point.x - minX) * scale);
+  const py = Math.trunc(offsetY + (maxY - point.y) * scale);
+  return { px, py };
+}
+function svgPolygon(points, bounds, width, height, padding, fill, stroke) {
+  if (points.length < 3) {
+    return "";
+  }
+  const pixels = points.map((p) => coordToPixel(p, bounds, width, height, padding)).map((p) => `${p.px},${p.py}`).join(" ");
+  return `<polygon points="${pixels}" fill="${fill}" stroke="${stroke}"/>`;
+}
+function svgPathFromSegments(segments, bounds, width, height, padding, stroke, strokeWidth, dashed) {
+  const parts = [];
+  for (const segment of segments) {
+    if (segment.length < 2) {
+      continue;
+    }
+    const first = segment[0];
+    if (!first) {
+      continue;
+    }
+    let prev = coordToPixel(first, bounds, width, height, padding);
+    parts.push(`M ${prev.px} ${prev.py}`);
+    for (let i = 1; i < segment.length; i += 1) {
+      const point = segment[i];
+      if (!point) {
+        continue;
+      }
+      const pixel = coordToPixel(point, bounds, width, height, padding);
+      if (pixel.px !== prev.px || pixel.py !== prev.py) {
+        parts.push(`L ${pixel.px} ${pixel.py}`);
+        prev = pixel;
+      }
+    }
+  }
+  if (parts.length === 0) {
+    return "";
+  }
+  const dash = dashed ? ' stroke-dasharray="10,5"' : "";
+  return `<path d="${parts.join(" ")}" stroke="${stroke}" stroke-width="${strokeWidth}"${dash} fill="none"/>`;
+}
+function renderMowerSvg(map, opts = {}) {
+  const width = opts.width ?? DEFAULT_WIDTH;
+  const height = opts.height ?? DEFAULT_HEIGHT;
+  const padding = opts.padding ?? DEFAULT_PADDING;
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg">`,
+    `<rect width="100%" height="100%" fill="${BACKGROUND}"/>`
+  ];
+  const allPoints = [];
+  for (const zone of map.zones) {
+    allPoints.push(...zone.path);
+  }
+  for (const area of map.forbiddenAreas) {
+    allPoints.push(...area.path);
+  }
+  for (const path of map.paths) {
+    allPoints.push(...path.path);
+  }
+  for (const contour of map.contours) {
+    allPoints.push(...contour.path);
+  }
+  for (const mp of map.mowPaths) {
+    for (const seg of mp.segments) {
+      allPoints.push(...seg);
+    }
+  }
+  if (allPoints.length === 0) {
+    lines.push(
+      `<text x="${Math.trunc(width / 2)}" y="${Math.trunc(height / 2)}" font-family="Arial, sans-serif" font-size="16" fill="${TEXT_COLOR}" text-anchor="middle">No map data available</text>`
+    );
+    lines.push("</svg>");
+    return lines.join("\n");
+  }
+  const bounds = calculateBounds(allPoints);
+  const multiZone = map.zones.length > 1;
+  for (const navPath of map.paths) {
+    const dashed = svgPathFromSegments(
+      [navPath.path],
+      bounds,
+      width,
+      height,
+      padding,
+      NAV_PATH,
+      3,
+      true
+    );
+    if (dashed) {
+      lines.push(dashed);
+    }
+  }
+  map.zones.forEach((zone, i) => {
+    if (!multiZone) {
+      return;
+    }
+    const palette = ZONE_COLORS[i % ZONE_COLORS.length];
+    const [fill, outline] = palette ?? ZONE_COLORS[0] ?? ["#cccccc", "#888888"];
+    const poly = svgPolygon(zone.path, bounds, width, height, padding, fill, outline);
+    if (poly) {
+      lines.push(poly);
+    }
+  });
+  map.zones.forEach((zone, i) => {
+    const outline = multiZone ? ZONE_COLORS[i % ZONE_COLORS.length]?.[1] ?? MAP_BOUNDARY : MAP_BOUNDARY;
+    const boundary = svgPathFromSegments(
+      [zone.path],
+      bounds,
+      width,
+      height,
+      padding,
+      outline,
+      2,
+      false
+    );
+    if (boundary) {
+      lines.push(boundary);
+    }
+  });
+  for (const mp of map.mowPaths) {
+    const track = svgPathFromSegments(
+      mp.segments,
+      bounds,
+      width,
+      height,
+      padding,
+      MOWING_PATH,
+      2,
+      false
+    );
+    if (track) {
+      lines.push(track);
+    }
+  }
+  for (const area of map.forbiddenAreas) {
+    const poly = svgPolygon(
+      area.path,
+      bounds,
+      width,
+      height,
+      padding,
+      OBSTACLE_FILL,
+      OBSTACLE_STROKE
+    );
+    if (poly) {
+      lines.push(poly);
+    }
+  }
+  lines.push("</svg>");
+  return lines.join("\n");
+}
+
+// src/models/mower/mower-device.ts
+var DEFAULT_MAP_PROPS = ["MAP", "M_PATH"];
+var STATUS = enumLookup(
+  Object.values(MowerStatus).filter((v) => typeof v === "number")
+);
+var CHARGING2 = enumLookup(
+  Object.values(MowerChargingStatus).filter((v) => typeof v === "number")
+);
+var MowerDevice = class extends BaseDevice {
+  #caps;
+  #fetchBatch;
+  #lastMap = null;
+  constructor(input) {
+    super({
+      ...input,
+      // Inject the mower resolver so the inherited generic `capabilities` getter
+      // carries the mower token set (no banned cast).
+      capabilities: input.capabilities ?? new MowerCapabilityResolver().resolve(input.device.model)
+    });
+    this.#caps = getMowerCapabilities(input.device.model);
+    this.#fetchBatch = input.getBatchDeviceDatas ?? null;
+  }
+  /** Rich, mower-specific capability record. */
+  get mowerCapabilities() {
+    return this.#caps;
+  }
+  #num(siid, piid) {
+    return asNum(this.getProperty(siid, piid)?.value);
+  }
+  // -- typed state --------------------------------------------------------
+  get statusRaw() {
+    return this.#num(MOWER_PROP.STATUS.siid, MOWER_PROP.STATUS.piid);
+  }
+  get status() {
+    return STATUS(this.statusRaw);
+  }
+  get battery() {
+    return this.#num(MOWER_PROP.BATTERY.siid, MOWER_PROP.BATTERY.piid);
+  }
+  get chargingRaw() {
+    return this.#num(MOWER_PROP.CHARGING_STATUS.siid, MOWER_PROP.CHARGING_STATUS.piid);
+  }
+  get charging() {
+    return CHARGING2(this.chargingRaw);
+  }
+  /** Docked => on the dock (Charging / ChargingComplete state). */
+  get isDocked() {
+    const s = this.status;
+    return s === 6 /* Charging */ || s === 13 /* ChargingComplete */;
+  }
+  get isMowing() {
+    return this.status === 1 /* Mowing */;
+  }
+  get taskStatusRaw() {
+    return this.#num(MOWER_PROP.TASK_STATUS.siid, MOWER_PROP.TASK_STATUS.piid);
+  }
+  /** Parsed scheduling task descriptor (2:50), or null. */
+  get task() {
+    return parseTaskDescriptor(
+      this.getProperty(MOWER_PROP.SCHEDULING_TASK.siid, MOWER_PROP.SCHEDULING_TASK.piid)?.value
+    );
+  }
+  /**
+   * Mowing coverage target / progress signal from the task descriptor (`d.o`).
+   * This is the P4 progress surface; the byte-accurate pose-track % is P5.
+   */
+  get coverageTargetPct() {
+    return this.task?.coverageTarget ?? null;
+  }
+  /** Parsed per-zone control status (2:56), or null. */
+  get controlStatus() {
+    return parseControlStatus(
+      this.getProperty(MOWER_PROP.MOWER_CONTROL_STATUS.siid, MOWER_PROP.MOWER_CONTROL_STATUS.piid)?.value
+    );
+  }
+  get controlAction() {
+    return this.controlStatus?.action ?? null;
+  }
+  // -- command helpers ----------------------------------------------------
+  #requireCap(flag, op, feature) {
+    if (!flag) {
+      throw new DreameError(`${op}: model ${this.model} does not support ${feature}`);
+    }
+  }
+  /** Send a scheduling-task action (2:50) carrying a single opcode object. */
+  #sendTask(payload) {
+    return this.callAction(MOWER_PROP.SCHEDULING_TASK.siid, MOWER_PROP.SCHEDULING_TASK.piid, [
+      payload
+    ]);
+  }
+  // -- no-arg commands ----------------------------------------------------
+  /**
+   * Start the generic mowing action (siid 5 aiid 1). Named `startMowing` — NOT
+   * `start` — because `BaseDevice.start()` is the MQTT lifecycle method the
+   * facade relies on; overriding it would break handle startup.
+   */
+  startMowing() {
+    return this.callAction(MOWER_ACTION.START_MOWING.siid, MOWER_ACTION.START_MOWING.aiid, []);
+  }
+  pause() {
+    return this.callAction(MOWER_ACTION.PAUSE.siid, MOWER_ACTION.PAUSE.aiid, []);
+  }
+  stop() {
+    return this.callAction(MOWER_ACTION.STOP.siid, MOWER_ACTION.STOP.aiid, []);
+  }
+  /** Send the mower to its dock (siid 5 aiid 3). */
+  dock() {
+    return this.callAction(MOWER_ACTION.DOCK.siid, MOWER_ACTION.DOCK.aiid, []);
+  }
+  /**
+   * Resume mowing after a pause. Encoded as the continueControl opcode
+   * `{m:'a', p:0, o:5}` sent as the single in-param of the SCHEDULING_TASK
+   * (2:50) action — NOT a siid-5 action. Mirrors the donor TASK_PAYLOAD_RESUME.
+   */
+  async resume() {
+    this.#requireCap(this.#caps.canResume, "resume", "resume");
+    return this.#sendTask(buildResumePayload());
+  }
+  // -- targeted mowing ----------------------------------------------------
+  /** All-area, map-targeted mowing (2:50 o:100). */
+  async startMowingAllArea(mapId) {
+    this.#requireCap(this.#caps.canMowAllArea, "startMowingAllArea", "all-area mowing");
+    return this.#sendTask(buildAllAreaPayload(Math.trunc(mapId)));
+  }
+  /** Zone-selective mowing (2:50 o:102). */
+  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((z3) => Math.trunc(z3))));
+  }
+  /** Edge / contour mowing (2:50 o:101). Contour ids are two-int pairs [[1,0]]. */
+  async startMowingEdges(contourIds) {
+    this.#requireCap(this.#caps.canMowEdges, "startMowingEdges", "edge mowing");
+    if (contourIds.length === 0) {
+      throw new RangeError("startMowingEdges: contourIds must not be empty");
+    }
+    return this.#sendTask(buildEdgePayload(contourIds));
+  }
+  /** Spot mowing (2:50 o:103). */
+  async startMowingSpots(spotAreaIds) {
+    this.#requireCap(this.#caps.canMowSpots, "startMowingSpots", "spot mowing");
+    if (spotAreaIds.length === 0) {
+      throw new RangeError("startMowingSpots: spotAreaIds must not be empty");
+    }
+    return this.#sendTask(buildSpotPayload(spotAreaIds.map((s) => Math.trunc(s))));
+  }
+  // -- maps ---------------------------------------------------------------
+  /** The most-recently-parsed map, or `null` until {@link getMap} succeeds. */
+  get lastMap() {
+    return this.#lastMap;
+  }
+  /**
+   * Fetch the batched vector-map data, parse it into a {@link MowerMap}, cache
+   * it as {@link lastMap}, and return it. Capability-gated on `canMap`.
+   *
+   * The batch fetcher is injected at construction (the live cloud endpoint path
+   * is not yet recovered — see `cloud/commands.ts`). Rejects with
+   * {@link DreameError} if no fetcher was injected or the batch yields no
+   * parseable map (asleep mower / empty data).
+   */
+  async getMap(props = DEFAULT_MAP_PROPS) {
+    this.#requireCap(this.#caps.canMap, "getMap", "map parsing");
+    if (!this.#fetchBatch) {
+      throw new DreameError(
+        "getMap: no batch device-data fetcher injected (live endpoint unrecovered)"
+      );
+    }
+    const batch = await this.#fetchBatch(this.deviceId, [...props]);
+    const map = parseBatchMapData(batch);
+    if (!map) {
+      throw new DreameError("getMap: batch device-data contained no parseable map");
+    }
+    this.#lastMap = map;
+    return map;
+  }
+  /**
+   * Render the current map to a deterministic SVG string. Uses {@link lastMap}
+   * when present, otherwise fetches first via {@link getMap}.
+   */
+  async mapSvg(opts) {
+    const map = this.#lastMap ?? await this.getMap();
+    return renderMowerSvg(map, opts ?? {});
+  }
+  /** Props worth seeding on start() / polling — exported for the facade. */
+  static DEFAULT_PROPS = [
+    MOWER_PROP.STATUS,
+    MOWER_PROP.BATTERY,
+    MOWER_PROP.CHARGING_STATUS,
+    MOWER_PROP.TASK_STATUS,
+    MOWER_PROP.SCHEDULING_TASK,
+    MOWER_PROP.MOWER_CONTROL_STATUS
+  ];
+};
+
+// src/api/nodreame.ts
+var DEFAULT_REFRESH_LEEWAY_SECS = 100;
+function deviceClassFor(model) {
+  if (model.startsWith("dreame.vacuum.")) {
+    return VacuumDevice;
+  }
+  if (model.startsWith("dreame.mower.")) {
+    return MowerDevice;
+  }
+  return BaseDevice;
+}
+function defaultDeps(opts) {
+  return {
+    login: (input) => login(input),
+    refresh: (input) => refresh(input),
+    listDevices: (input) => listDevices(input),
+    createDevice: (args) => {
+      const DeviceClass = deviceClassFor(args.device.model);
+      return new DeviceClass({
+        device: args.device,
+        region: args.region,
+        sessionRef: args.sessionRef,
+        ...opts.fetchInitialValues !== void 0 ? { fetchInitialValues: opts.fetchInitialValues } : {},
+        ...opts.pollIntervalMs !== void 0 ? { pollIntervalMs: opts.pollIntervalMs } : {}
+      });
+    }
+  };
+}
+var Nodreame = class extends TypedEmitter {
+  #opts;
+  #deps;
+  #leewayMs;
+  #session = null;
+  #devices = [];
+  #closed = false;
+  constructor(opts, deps) {
+    super();
+    if (!opts.username || !opts.password) {
+      throw new DreameAuthError("username and password are required");
+    }
+    this.#opts = opts;
+    this.#deps = deps ?? defaultDeps(opts);
+    this.#leewayMs = (opts.refreshLeewaySecs ?? DEFAULT_REFRESH_LEEWAY_SECS) * 1e3;
+  }
+  get region() {
+    return this.#opts.region;
+  }
+  get session() {
+    return this.#session;
+  }
+  get devices() {
+    return this.#devices;
+  }
+  /** Authenticate and stash the single shared session. */
+  async login() {
+    this.#session = await this.#deps.login({
+      email: this.#opts.username,
+      password: this.#opts.password,
+      region: this.#opts.region,
+      ...this.#opts.country !== void 0 ? { country: this.#opts.country } : {},
+      ...this.#opts.lang !== void 0 ? { lang: this.#opts.lang } : {},
+      ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
+    });
+    return this.#session;
+  }
+  /** Return a valid session, refreshing proactively within the leeway window. */
+  async ensureSession() {
+    const current = this.#session;
+    if (!current) {
+      return this.login();
+    }
+    if (Date.now() < current.expiresAt - this.#leewayMs) {
+      return current;
+    }
+    if (current.refreshToken) {
+      try {
+        const next = await this.#deps.refresh({
+          refreshToken: current.refreshToken,
+          region: this.#opts.region,
+          ...this.#opts.country !== void 0 ? { country: this.#opts.country } : {},
+          ...this.#opts.lang !== void 0 ? { lang: this.#opts.lang } : {},
+          ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
+        });
+        await this.#adoptSession(next);
+        return next;
+      } catch {
+      }
+    }
+    const fresh = await this.login();
+    await this.#propagateSession(fresh);
+    return fresh;
+  }
+  /** Discover devices and build a live handle per device. */
+  async discoverDevices() {
+    if (this.#closed) {
+      throw new DreameAuthError("client is closed");
+    }
+    const session = await this.ensureSession();
+    const records = await this.#deps.listDevices({
+      session,
+      region: this.#opts.region,
+      ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
+    });
+    const handles = records.map(
+      (device) => this.#deps.createDevice({
+        device,
+        region: this.#opts.region,
+        sessionRef: () => this.#requireSession()
+      })
+    );
+    for (const h of handles) {
+      h.on("stateChanged", (e) => this.emit("stateChanged", e));
+      h.on("event", (e) => this.emit("event", e));
+      h.on("error", (err) => this.emit("error", err));
+      await h.start();
+    }
+    const previous = this.#devices;
+    this.#devices = [...handles];
+    await Promise.all(previous.map((d) => d.close()));
+    return this.#devices;
+  }
+  /** Tear everything down: close every device push and clear timers. */
+  async close() {
+    this.#closed = true;
+    const devices = this.#devices;
+    this.#devices = [];
+    await Promise.all(devices.map((d) => d.close()));
+    this.removeAllListeners();
+  }
+  #requireSession() {
+    if (!this.#session) {
+      throw new DreameAuthError("no active session \u2014 call login() first");
+    }
+    return this.#session;
+  }
+  async #adoptSession(session) {
+    this.#session = session;
+    await this.#propagateSession(session);
+  }
+  /** Push the refreshed token to every live device push. */
+  async #propagateSession(session) {
+    if (this.#closed) {
+      return;
+    }
+    await Promise.all(this.#devices.map((d) => d.applySession(session)));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseDevice,
+  ChargingStatus,
+  CleaningMode,
+  DefaultCapabilityResolver,
+  DreameApiError,
+  DreameAuthError,
+  DreameDeviceOfflineError,
+  DreameError,
+  DreameTransportError,
+  LIBRARY_NAME,
+  MOWER_MODEL_CAPABILITIES,
+  MiotError,
+  MiotState,
+  MowerCapabilityResolver,
+  MowerChargingStatus,
+  MowerControlAction,
+  MowerDevice,
+  MowerStatus,
+  MowerTaskStatus,
+  Nodreame,
+  SuctionLevel,
+  TaskStatus,
+  VACUUM_MODEL_CAPABILITIES,
+  VacuumCapabilityResolver,
+  VacuumDevice,
+  WaterVolume,
+  getMowerCapabilities,
+  getVacuumCapabilities,
+  renderMowerSvg,
+  renderVacuumPng,
+  resolveCapabilities
+});
+//# sourceMappingURL=index.cjs.map