@apocaliss92/nodedreame 1.11.10 → 1.12.0

package/dist/index.cjs

@@ -32,17 +32,28 @@ var index_exports = {};
 __export(index_exports, {
   AI_FEATURE_BIT: () => AI_FEATURE_BIT,
   AI_FEATURE_JSON_KEY: () => AI_FEATURE_JSON_KEY,
+  ALIYUN_REGION_ID: () => ALIYUN_REGION_ID,
   AUTO_SWITCH_JSON_KEY: () => AUTO_SWITCH_JSON_KEY,
   BaseDevice: () => BaseDevice,
   ChargingStatus: () => ChargingStatus,
   CleaningMode: () => CleaningMode,
+  DRIVE_DIRECTIONS: () => DRIVE_DIRECTIONS,
   DefaultCapabilityResolver: () => DefaultCapabilityResolver,
   DreameApiError: () => DreameApiError,
   DreameAuthError: () => DreameAuthError,
+  DreameCameraController: () => DreameCameraController,
+  DreameCameraStream: () => DreameCameraStream,
   DreameDeviceOfflineError: () => DreameDeviceOfflineError,
   DreameError: () => DreameError,
   DreameTransportError: () => DreameTransportError,
+  DreameVideoSession: () => DreameVideoSession,
   LIBRARY_NAME: () => LIBRARY_NAME,
+  LV_STATUS: () => LV_STATUS,
+  LvRtmpClient: () => LvRtmpClient,
+  MONITOR_AIID: () => MONITOR_AIID,
+  MONITOR_PIID: () => MONITOR_PIID,
+  MONITOR_SIID: () => MONITOR_SIID,
+  MONITOR_VENDOR_TOKEN: () => MONITOR_VENDOR_TOKEN,
   MOWER_MODEL_CAPABILITIES: () => MODEL_CAPABILITIES2,
   MOWER_TASK_SUBSTATES: () => MOWER_TASK_SUBSTATES,
   MiotError: () => MiotError,
@@ -55,40 +66,72 @@ __export(index_exports, {
   MowerStatus: () => MowerStatus,
   MowerTaskStatus: () => MowerTaskStatus,
   Nodreame: () => Nodreame,
+  PET_SOUNDS: () => PET_SOUNDS,
   SuctionLevel: () => SuctionLevel,
+  TALK_AUDIO_HEADER_G711A: () => TALK_AUDIO_HEADER_G711A,
   TaskStatus: () => TaskStatus,
+  VACUUM_ACTIONS: () => VACUUM_ACTIONS,
   VACUUM_CONSUMABLES: () => VACUUM_CONSUMABLES,
   VACUUM_MODEL_CAPABILITIES: () => MODEL_CAPABILITIES,
+  VACUUM_MOVE: () => VACUUM_MOVE,
+  VACUUM_SIID: () => VACUUM_SIID,
   VacuumCapabilityResolver: () => VacuumCapabilityResolver,
   VacuumDevice: () => VacuumDevice,
   WaterVolume: () => WaterVolume,
+  aacSampleRate: () => aacSampleRate,
+  aacToAdts: () => aacToAdts,
+  avccToAnnexB: () => avccToAnnexB,
   consumableSpec: () => consumableSpec,
   createClientDumper: () => createClientDumper,
   createDumper: () => createDumper,
+  createIotSession: () => createIotSession,
   decodeAiFeature: () => decodeAiFeature,
   decodeAutoSwitch: () => decodeAutoSwitch,
   decodeAutoSwitchAll: () => decodeAutoSwitchAll,
+  decodeWifiSignalMap: () => decodeWifiSignalMap,
   encodeAiFeatureWrite: () => encodeAiFeatureWrite,
   encodeAutoSwitchWrite: () => encodeAutoSwitchWrite,
   extractMowerConsumableValues: () => extractMowerConsumableValues,
+  getAliyunAuthCode: () => getAliyunAuthCode,
+  getDeviceVideoProfile: () => getDeviceVideoProfile,
   getMowerCapabilities: () => getMowerCapabilities,
   getVacuumCapabilities: () => getVacuumCapabilities,
+  getVideoAccessToken: () => getVideoAccessToken,
+  getVideoFamilyId: () => getVideoFamilyId,
+  hashAccessCode: () => hashAccessCode,
+  isAuthRefusedError: () => isAuthRefusedError,
   isDreameConsumableKey: () => isDreameConsumableKey,
+  listDevices: () => listDevices,
+  loginByOauth: () => loginByOauth,
+  makeMonitorSession: () => makeMonitorSession,
   mowerConsumableIndex: () => mowerConsumableIndex,
   mowerFaultSeverity: () => mowerFaultSeverity,
+  parseAacConfig: () => parseAacConfig,
+  parseAvcConfig: () => parseAvcConfig,
+  parseConnectivity: () => parseConnectivity,
   parseMowerConsumables: () => parseMowerConsumables,
   parseMowerHeartbeat: () => parseMowerHeartbeat,
   parseMowingProgress: () => parseMowingProgress,
+  parseObstacleData: () => parseObstacleData,
+  parsePersonFollow: () => parsePersonFollow,
+  parseRelayUrl: () => parseRelayUrl,
+  pcm16ToALaw: () => pcm16ToALaw,
+  pcm16leToALaw: () => pcm16leToALaw,
+  remoteDriveValue: () => remoteDriveValue,
   renderMowerSvg: () => renderMowerSvg,
   renderVacuumPng: () => renderVacuumPng,
+  renderWifiSignalPng: () => renderWifiSignalPng,
   resolveCapabilities: () => resolveCapabilities,
-  supportedAutoSwitchKeys: () => supportedAutoSwitchKeys
+  signApiGatewayRequest: () => signApiGatewayRequest,
+  streamQuery: () => streamQuery,
+  supportedAutoSwitchKeys: () => supportedAutoSwitchKeys,
+  toVideoProfile: () => toVideoProfile
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/support/version.ts
 var LIBRARY_NAME = "nodedreame";
-var LIBRARY_VERSION = "1.11.10";
+var LIBRARY_VERSION = "1.12.0";
 
 // src/transport/errors.ts
 var DreameError = class extends Error {
@@ -473,6 +516,34 @@ async function postForToken(ctx, body) {
   return session;
 }
 
+// src/cloud/connectivity.ts
+var str = (v) => typeof v === "string" && v.length > 0 ? v : null;
+var numOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+function parseBroker(bindDomain) {
+  const s = str(bindDomain);
+  if (!s) return null;
+  const idx = s.lastIndexOf(":");
+  if (idx < 0) return { host: s, port: null };
+  const port = Number(s.slice(idx + 1));
+  return { host: s.slice(0, idx), port: Number.isFinite(port) ? port : null };
+}
+function parseConnectivity(raw) {
+  const deviceInfo = raw["deviceInfo"] ?? {};
+  return {
+    online: raw["online"] === true,
+    connectionType: str(deviceInfo["scType"]),
+    mac: str(raw["mac"]),
+    broker: parseBroker(raw["bindDomain"]),
+    region: str(raw["region"]),
+    cloudVendor: str(raw["vendor"]),
+    firmwareVersion: str(raw["ver"]),
+    serialNumber: str(raw["sn"]),
+    subModel: str(raw["subModel"]),
+    battery: numOrNull(raw["battery"]),
+    statusCode: numOrNull(raw["latestStatus"])
+  };
+}
+
 // src/cloud/devices.ts
 async function listDevices(input) {
   const ctx = input.ctx ?? RequestContext.from({ ...input, host: input.apiHost });
@@ -517,7 +588,8 @@ function toDevice(rawIn) {
     name,
     online,
     raw,
-    cloudState: parseCloudState(raw)
+    cloudState: parseCloudState(raw),
+    connectivity: parseConnectivity(raw)
   };
   if (rawIn.mac) {
     device.mac = String(rawIn.mac);
@@ -717,6 +789,10 @@ var TypedEmitter = class {
   emit(event, ...args) {
     return this.#emitter.emit(event, ...args);
   }
+  /** Number of listeners registered for `event`. */
+  listenerCount(event) {
+    return this.#emitter.listenerCount(event);
+  }
   removeAllListeners() {
     this.#emitter.removeAllListeners();
     return this;
@@ -729,6 +805,24 @@ function defaultConnect(url, opts) {
   const typed = client;
   return typed;
 }
+function isAuthRefusedError(err) {
+  let cur = err;
+  for (let depth = 0; cur != null && depth < 6; depth += 1) {
+    if (typeof cur !== "object") {
+      break;
+    }
+    const code = cur.code;
+    if (code === 4 || code === 5 || code === 134 || code === 135) {
+      return true;
+    }
+    const message = cur.message;
+    if (typeof message === "string" && /not authorized|bad user ?name|bad username or password|bad password/i.test(message)) {
+      return true;
+    }
+    cur = cur.cause;
+  }
+  return false;
+}
 var DreamePush = class extends TypedEmitter {
   #device;
   #session;
@@ -737,11 +831,15 @@ var DreamePush = class extends TypedEmitter {
   #backoffMs;
   #keepaliveSeconds;
   #rejectUnauthorized;
+  #onAuthFailure;
+  #maxAuthRetries;
   #topic;
   #client = null;
   #closed = false;
   #tearingDown = false;
   #reconnectTimer = null;
+  /** Consecutive auth-refused re-auths since the last successful connect. */
+  #authFailureCount = 0;
   /**
    * Per-instance bound close handler. Stored so we can pass the EXACT same
    * function reference to both `client.on('close', …)` and
@@ -758,6 +856,8 @@ var DreamePush = class extends TypedEmitter {
     this.#backoffMs = input.reconnectBackoffMs ?? 5e3;
     this.#keepaliveSeconds = input.keepaliveSeconds ?? 60;
     this.#rejectUnauthorized = input.rejectUnauthorized ?? false;
+    this.#onAuthFailure = input.onAuthFailure ?? null;
+    this.#maxAuthRetries = input.maxAuthRetries ?? 3;
     this.#topic = buildStatusTopic(this.#device, this.#session.uid, this.#region);
     this.#onClose = () => {
       if (this.#tearingDown) {
@@ -794,7 +894,11 @@ var DreamePush = class extends TypedEmitter {
       this.#reconnectTimer = null;
     }
     await this.#teardownClient();
-    await this.#connectAndSubscribe();
+    try {
+      await this.#connectAndSubscribe();
+    } catch {
+      this.#scheduleReconnect();
+    }
   }
   /** Tear down permanently. Closed subscriptions cannot be reopened. */
   async close() {
@@ -831,6 +935,7 @@ var DreamePush = class extends TypedEmitter {
               reject(new DreameTransportError(`mqtt subscribe failed: ${err.message}`, err));
               return;
             }
+            this.#authFailureCount = 0;
             this.emit("connect");
             resolve();
           });
@@ -864,12 +969,55 @@ var DreamePush = class extends TypedEmitter {
       if (this.#closed || this.#client) {
         return;
       }
-      void this.#connectAndSubscribe().catch((err) => {
-        this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
-        this.#scheduleReconnect();
-      });
+      void this.#attemptReconnect();
     }, this.#backoffMs);
   }
+  /**
+   * One reconnect attempt with reactive auth self-heal. If the broker refuses
+   * the CONNECT with an auth error (a stale access token) and an
+   * `onAuthFailure` provider is wired and the re-auth budget is not exhausted,
+   * mint a fresh session and retry with the new token instead of replaying the
+   * old one. Any other failure (or an exhausted budget) falls back to the plain
+   * backoff reconnect so bad credentials cannot hot-loop re-login.
+   */
+  async #attemptReconnect() {
+    try {
+      await this.#connectAndSubscribe();
+    } catch (err) {
+      if (this.#closed) {
+        return;
+      }
+      if (this.#onAuthFailure && isAuthRefusedError(err) && this.#authFailureCount < this.#maxAuthRetries) {
+        await this.#reauthenticateAndReconnect();
+        return;
+      }
+      this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
+      this.#scheduleReconnect();
+    }
+  }
+  /** Mint a fresh session via `onAuthFailure`, adopt its token, and reconnect. */
+  async #reauthenticateAndReconnect() {
+    this.#authFailureCount += 1;
+    let session;
+    try {
+      session = await this.#onAuthFailure();
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new DreameTransportError(String(err)));
+      if (!this.#client) {
+        this.#scheduleReconnect();
+      }
+      return;
+    }
+    if (this.#closed) {
+      return;
+    }
+    this.#session = session;
+    this.#topic = buildStatusTopic(this.#device, this.#session.uid, this.#region);
+    if (this.#client) {
+      return;
+    }
+    void this.#attemptReconnect();
+  }
   async #teardownClient() {
     const client = this.#client;
     this.#client = null;
@@ -1045,7 +1193,12 @@ function resolveCapabilities(model) {
 // src/device/base-device.ts
 function defaultBaseDeviceDeps() {
   return {
-    createPush: (device, session, region) => new DreamePush({ device, session, region }),
+    createPush: (device, session, region, onAuthFailure) => new DreamePush({
+      device,
+      session,
+      region,
+      ...onAuthFailure !== void 0 ? { onAuthFailure } : {}
+    }),
     getProperties: (base, props) => getProperties(base, props),
     getCachedProperties: (base, props) => getCachedProperties(base, props),
     setProperties: (base, writes) => setProperties(base, writes),
@@ -1057,6 +1210,7 @@ var BaseDevice = class extends TypedEmitter {
   #device;
   #region;
   #sessionRef;
+  #onAuthFailure;
   #deps;
   #fetchInitial;
   #initialProps;
@@ -1072,6 +1226,7 @@ var BaseDevice = class extends TypedEmitter {
     this.#device = input.device;
     this.#region = input.region;
     this.#sessionRef = input.sessionRef;
+    this.#onAuthFailure = input.onAuthFailure;
     this.#deps = input.deps ?? defaultBaseDeviceDeps();
     this.#fetchInitial = input.fetchInitialValues ?? true;
     this.#initialProps = input.initialProps ?? [];
@@ -1111,7 +1266,12 @@ var BaseDevice = class extends TypedEmitter {
   }
   /** Open the push, wire events, optionally seed the cache. */
   async start() {
-    const push = this.#deps.createPush(this.#device, this.#sessionRef(), this.#region);
+    const push = this.#deps.createPush(
+      this.#device,
+      this.#sessionRef(),
+      this.#region,
+      this.#onAuthFailure
+    );
     this.#push = push;
     push.on("properties", (changes) => this.#onProperties(changes));
     push.on(
@@ -2014,8 +2174,1015 @@ var VacuumCapabilityResolver = class {
   }
 };
 
+// src/video/schemas.ts
+var import_zod3 = require("zod");
+var VideoAccessTokenResponseSchema = import_zod3.z.object({
+  code: import_zod3.z.number().optional(),
+  msg: import_zod3.z.string().nullish(),
+  data: import_zod3.z.object({
+    data: import_zod3.z.object({
+      token: import_zod3.z.string(),
+      userId: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional(),
+      expireAt: import_zod3.z.number().optional()
+    }).passthrough()
+  }).passthrough()
+}).passthrough();
+var AuthCodeResponseSchema = import_zod3.z.object({
+  code: import_zod3.z.number().optional(),
+  msg: import_zod3.z.string().nullish(),
+  data: import_zod3.z.string()
+}).passthrough();
+var FamilyIdResponseSchema = import_zod3.z.object({
+  code: import_zod3.z.number().optional(),
+  msg: import_zod3.z.string().nullish(),
+  data: import_zod3.z.object({ data: import_zod3.z.object({ familyId: import_zod3.z.string() }).passthrough() }).passthrough()
+}).passthrough();
+var DeviceVideoInfoSchema = import_zod3.z.object({
+  model: import_zod3.z.string().optional(),
+  displayName: import_zod3.z.string().optional(),
+  permit: import_zod3.z.string().optional(),
+  videoDynamicVendor: import_zod3.z.boolean().optional(),
+  defaultVendors: import_zod3.z.array(import_zod3.z.string()).optional(),
+  productId: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional()
+}).passthrough();
+var DeviceInfoRecordSchema = import_zod3.z.object({
+  did: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional(),
+  model: import_zod3.z.string().optional(),
+  customName: import_zod3.z.string().optional(),
+  vendor: import_zod3.z.string().optional(),
+  online: import_zod3.z.boolean().optional(),
+  lwt: import_zod3.z.number().optional(),
+  property: import_zod3.z.string().optional(),
+  bindDomain: import_zod3.z.string().optional(),
+  deviceInfo: DeviceVideoInfoSchema.optional()
+}).passthrough();
+var DeviceInfoResponseSchema = import_zod3.z.object({
+  code: import_zod3.z.number().optional(),
+  msg: import_zod3.z.string().nullish(),
+  data: DeviceInfoRecordSchema
+}).passthrough();
+
+// src/video/profile.ts
+var KNOWN_VENDORS = ["tx", "ali"];
+function asVendor(v) {
+  return v === "tx" || v === "ali" ? v : null;
+}
+function parseProperty(property) {
+  if (!property) {
+    return { iotId: null, lwt: null };
+  }
+  try {
+    const p = JSON.parse(property);
+    return {
+      iotId: typeof p.iotId === "string" && p.iotId.length > 0 ? p.iotId : null,
+      lwt: typeof p.lwt === "number" ? p.lwt : null
+    };
+  } catch {
+    return { iotId: null, lwt: null };
+  }
+}
+function toVideoProfile(record) {
+  const info = record.deviceInfo ?? {};
+  const supportedVendors = (info.defaultVendors ?? []).filter(
+    (v) => KNOWN_VENDORS.includes(v)
+  );
+  const prop = parseProperty(record.property);
+  const online = record.online === true || record.lwt === 1 || prop.lwt === 1;
+  return {
+    did: String(record.did ?? ""),
+    model: String(record.model ?? info.model ?? ""),
+    displayName: info.displayName ?? null,
+    videoCapable: info.permit === "video" || supportedVendors.length > 0,
+    currentVendor: asVendor(record.vendor),
+    supportedVendors,
+    dynamicVendor: info.videoDynamicVendor === true,
+    iotId: prop.iotId,
+    online
+  };
+}
+
+// src/video/client.ts
+var P_THIRD_VIDEO = "/dreame-third-video";
+var P_SMARTHOME = "/dreame-smarthome";
+var P_USER_IOT = "/dreame-user-iot";
+var DEFAULT_OS = "android";
+function resolveCtx(input) {
+  return input.ctx ?? RequestContext.from({ ...input, host: input.apiHost });
+}
+function passthrough(input) {
+  return {
+    accessToken: input.session.accessToken,
+    ...input.signal !== void 0 ? { signal: input.signal } : {},
+    ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {}
+  };
+}
+async function getVideoAccessToken(input) {
+  const ctx = resolveCtx(input);
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: `${P_THIRD_VIDEO}/tx/user/accesstoken`,
+    body: { os: DEFAULT_OS },
+    context: "video accesstoken",
+    ...passthrough(input)
+  });
+  const parsed = VideoAccessTokenResponseSchema.parse(raw);
+  const d = parsed.data.data;
+  return {
+    token: d.token,
+    userId: d.userId !== void 0 ? String(d.userId) : null,
+    // Cloud reports expiry in epoch-seconds; expose epoch-ms like DreameSession.
+    expiresAt: d.expireAt !== void 0 ? d.expireAt * 1e3 : 0
+  };
+}
+async function getAliyunAuthCode(input) {
+  const ctx = resolveCtx(input);
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: `${P_SMARTHOME}/aliIot/getAuthCodeV3`,
+    body: { os: DEFAULT_OS },
+    context: "aliyun authCode",
+    ...passthrough(input)
+  });
+  return AuthCodeResponseSchema.parse(raw).data;
+}
+async function getVideoFamilyId(input) {
+  const ctx = resolveCtx(input);
+  const videoToken = input.videoToken ?? (await getVideoAccessToken({ ...input, ctx })).token;
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: `${P_THIRD_VIDEO}/tx/mgr/family/getFamilyId`,
+    body: { accesstoken: videoToken, os: DEFAULT_OS },
+    context: "video familyId",
+    ...passthrough(input)
+  });
+  return FamilyIdResponseSchema.parse(raw).data.data.familyId;
+}
+async function getDeviceVideoProfile(input) {
+  const ctx = resolveCtx(input);
+  const raw = await httpPostJsonBody({
+    ctx,
+    path: `${P_USER_IOT}/iotuserbind/device/info`,
+    body: { did: input.did },
+    context: "device video info",
+    ...passthrough(input)
+  });
+  return toVideoProfile(DeviceInfoResponseSchema.parse(raw).data);
+}
+
+// src/video/aliyun/constants.ts
+var ALIYUN_APP_KEY = "33974273";
+var ALIYUN_APP_SECRET = "65a62f03ae5eda97af962fecc2e3efa6";
+var ALIYUN_REGION_ID = {
+  eu: "eu-central-1",
+  de: "eu-central-1",
+  us: "us-east-1",
+  cn: "cn-shanghai",
+  ru: "eu-central-1",
+  sg: "ap-southeast-1",
+  in: "ap-southeast-1",
+  tw: "cn-shanghai"
+};
+function livingAccountHost(regionId) {
+  return `living-account.${regionId}.aliyuncs.com`;
+}
+function apiIotHost(regionId) {
+  return `${regionId}.api-iot.aliyuncs.com`;
+}
+var VISION_STREAM_QUERY = "/vision/customer/stream/query";
+
+// src/video/aliyun/identity.ts
+var import_node_crypto3 = require("crypto");
+var import_zod4 = require("zod");
+
+// src/video/aliyun/signing.ts
+var import_node_crypto2 = require("crypto");
+var CT_JSON = "application/json; charset=UTF-8";
+var CT_FORM = "application/x-www-form-urlencoded; charset=UTF-8";
+function md5Base64(s) {
+  return (0, import_node_crypto2.createHash)("md5").update(s, "utf8").digest("base64");
+}
+function signApiGatewayRequest(input) {
+  const accept = CT_JSON;
+  const contentType = input.json !== void 0 ? CT_JSON : CT_FORM;
+  const date = input.date ?? (/* @__PURE__ */ new Date()).toUTCString();
+  let body;
+  let contentMd5 = "";
+  let formParams;
+  if (input.json !== void 0) {
+    body = JSON.stringify(input.json);
+    contentMd5 = md5Base64(body);
+  } else {
+    const form = input.form ?? {};
+    body = Object.entries(form).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join("&");
+    formParams = form;
+  }
+  const caHeaders = {
+    "X-Ca-Key": input.appKey,
+    "X-Ca-Nonce": input.nonce ?? crypto.randomUUID().toUpperCase(),
+    "X-Ca-Timestamp": String(input.timestamp ?? Date.now()),
+    "X-Ca-Version": "1",
+    ...input.extraCaHeaders ?? {}
+  };
+  const signedHeaderNames = Object.keys(caHeaders).sort(
+    (a, b) => a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0
+  );
+  const headerBlock = signedHeaderNames.map((k) => `${k}:${caHeaders[k]}
+`).join("");
+  let resource = input.path;
+  if (formParams && Object.keys(formParams).length > 0) {
+    const sorted = Object.keys(formParams).sort();
+    resource += "?" + sorted.map((k) => `${k}=${formParams[k]}`).join("&");
+  }
+  const stringToSign = `${input.method}
+${accept}
+${contentMd5}
+${contentType}
+${date}
+${headerBlock}${resource}`;
+  const signature = (0, import_node_crypto2.createHmac)("sha1", input.appSecret).update(stringToSign, "utf8").digest("base64");
+  const headers = {
+    "Content-Type": contentType,
+    Accept: accept,
+    Date: date,
+    "X-Ca-Signature": signature,
+    "X-Ca-Signature-Method": "HmacSHA1",
+    "X-Ca-Signature-Headers": signedHeaderNames.join(","),
+    ...caHeaders
+  };
+  if (contentMd5) {
+    headers["Content-MD5"] = contentMd5;
+  }
+  return { headers, body };
+}
+
+// src/video/aliyun/identity.ts
+var LoginByOauthSchema = import_zod4.z.object({
+  data: import_zod4.z.object({
+    data: import_zod4.z.object({
+      loginSuccessResult: import_zod4.z.object({
+        sid: import_zod4.z.string(),
+        refreshToken: import_zod4.z.string().optional(),
+        token: import_zod4.z.string().optional(),
+        openAccount: import_zod4.z.object({ openId: import_zod4.z.string().optional() }).passthrough().optional()
+      }).passthrough()
+    }).passthrough()
+  }).passthrough()
+}).passthrough();
+var CreateSessionSchema = import_zod4.z.object({
+  code: import_zod4.z.number().optional(),
+  message: import_zod4.z.string().nullish(),
+  data: import_zod4.z.object({
+    iotToken: import_zod4.z.string(),
+    refreshToken: import_zod4.z.string().optional(),
+    identityId: import_zod4.z.string().optional(),
+    iotTokenExpire: import_zod4.z.number().optional()
+  }).passthrough()
+}).passthrough();
+async function postJson(url, headers, body, fetchImpl, ctx) {
+  const res = await fetchImpl(url, { method: "POST", headers, body });
+  const text = await res.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new DreameApiError(`${ctx} returned non-JSON (status ${res.status})`, res.status);
+  }
+}
+async function loginByOauth(input) {
+  const host = livingAccountHost(input.regionId);
+  const riskControlInfo = {
+    createIfNotExist: "true",
+    sdkVersion: "3.4.0.27",
+    openaccountVersion: "3.4.0.27",
+    platformName: "iOS",
+    netType: "wifi",
+    brand: "Apple",
+    USE_H5_NC: "true",
+    deviceId: input.deviceId ?? (0, import_node_crypto3.randomUUID)(),
+    locale: "en-US",
+    platformVersion: "26.5.2",
+    platform: "iPhone",
+    appKey: ALIYUN_APP_KEY,
+    USE_OA_PWD_ENCRYPT: "true",
+    model: "iPhone16,2",
+    utdid: input.utdid ?? (0, import_node_crypto3.randomUUID)().replace(/-/g, "").slice(0, 20),
+    appVersion: "1895"
+  };
+  const value = JSON.stringify({
+    riskControlInfo,
+    oauthPlateform: 23,
+    oauthAppKey: ALIYUN_APP_KEY,
+    authCode: input.authCode
+  });
+  const signed = signApiGatewayRequest({
+    method: "POST",
+    host,
+    path: "/api/prd/loginbyoauth.json",
+    appKey: ALIYUN_APP_KEY,
+    appSecret: ALIYUN_APP_SECRET,
+    form: { loginByOauthRequest: value }
+  });
+  const json = await postJson(
+    `https://${host}/api/prd/loginbyoauth.json`,
+    signed.headers,
+    signed.body,
+    input.fetchImpl ?? defaultFetch,
+    "loginbyoauth"
+  );
+  const r = LoginByOauthSchema.parse(json).data.data.loginSuccessResult;
+  return {
+    sid: r.sid,
+    refreshToken: r.refreshToken ?? "",
+    openId: r.openAccount?.openId ?? ""
+  };
+}
+async function createIotSession(input) {
+  const host = apiIotHost(input.regionId);
+  const path = "/account/createSessionByAuthCode";
+  const payload = {
+    id: (0, import_node_crypto3.randomUUID)().toUpperCase(),
+    params: { request: { appKey: ALIYUN_APP_KEY, authCode: input.sid, accountType: "OA_SESSION" } },
+    request: { apiVer: "1.0.4", language: "en-US", appKey: ALIYUN_APP_KEY },
+    version: "1.0.0"
+  };
+  const signed = signApiGatewayRequest({
+    method: "POST",
+    host,
+    path,
+    appKey: ALIYUN_APP_KEY,
+    appSecret: ALIYUN_APP_SECRET,
+    json: payload,
+    extraCaHeaders: { "X-Ca-Stage": "RELEASE" }
+  });
+  const json = await postJson(
+    `https://${host}${path}`,
+    signed.headers,
+    signed.body,
+    input.fetchImpl ?? defaultFetch,
+    "createSessionByAuthCode"
+  );
+  const parsed = CreateSessionSchema.parse(json);
+  if (parsed.code !== 200 && parsed.code !== 0) {
+    throw new DreameApiError(`createSession rejected: code=${parsed.code} msg=${parsed.message ?? "?"}`, 200, parsed);
+  }
+  const d = parsed.data;
+  return {
+    iotToken: d.iotToken,
+    refreshToken: d.refreshToken ?? "",
+    identityId: d.identityId ?? "",
+    expiresAt: Date.now() + (d.iotTokenExpire ?? 72e3) * 1e3
+  };
+}
+
+// src/video/aliyun/vision.ts
+var import_zod5 = require("zod");
+var VISION_DEVICE_OFFLINE = 9201;
+var StreamQueryResponseSchema = import_zod5.z.object({
+  code: import_zod5.z.number().optional(),
+  message: import_zod5.z.string().nullish(),
+  data: import_zod5.z.object({
+    typeList: import_zod5.z.array(import_zod5.z.string()).optional(),
+    relayUrl: import_zod5.z.string().optional(),
+    relayDecryptKey: import_zod5.z.object({ iv: import_zod5.z.string().optional(), key: import_zod5.z.string().optional() }).passthrough().optional(),
+    p2pInfo: import_zod5.z.object({
+      stunUrl: import_zod5.z.string().optional(),
+      alterStunUrl: import_zod5.z.string().optional(),
+      signalUrl: import_zod5.z.string().optional(),
+      portDetectStunUrlList: import_zod5.z.array(import_zod5.z.string()).optional()
+    }).passthrough().optional(),
+    supportVisionPtz: import_zod5.z.boolean().optional()
+  }).passthrough().optional()
+}).passthrough();
+async function streamQuery(input) {
+  const appKey = input.appKey ?? ALIYUN_APP_KEY;
+  const appSecret = input.appSecret ?? ALIYUN_APP_SECRET;
+  const host = apiIotHost(input.regionId);
+  const payload = {
+    id: crypto.randomUUID().toUpperCase(),
+    params: {
+      streamType: input.streamType ?? 0,
+      needDomainName: true,
+      relayEncryptType: 0,
+      clientType: "iOS",
+      iotId: input.iotId,
+      enablePortPredict: true,
+      enableWebSocket: true,
+      forceIFrame: true,
+      cacheDuration: 3e3,
+      relayEncrypted: input.relayEncrypted ?? false
+    },
+    request: { language: "en-US", appKey, iotToken: input.iotToken, apiVer: "2.2.0" },
+    version: "1.0.0"
+  };
+  const signed = signApiGatewayRequest({
+    method: "POST",
+    host,
+    path: VISION_STREAM_QUERY,
+    appKey,
+    appSecret,
+    json: payload,
+    extraCaHeaders: { "X-Ca-Stage": "RELEASE" }
+  });
+  const fetchImpl = input.fetchImpl ?? defaultFetch;
+  const res = await fetchImpl(`https://${host}${VISION_STREAM_QUERY}`, {
+    method: "POST",
+    headers: signed.headers,
+    body: signed.body,
+    ...input.signal ? { signal: input.signal } : {}
+  });
+  const text = await res.text();
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new DreameApiError(`stream/query returned non-JSON (status ${res.status})`, res.status);
+  }
+  const parsed = StreamQueryResponseSchema.parse(json);
+  if (parsed.code === VISION_DEVICE_OFFLINE) {
+    throw new DreameDeviceOfflineError(
+      `stream/query: device video agent offline (code ${VISION_DEVICE_OFFLINE}) \u2014 retry to wake`,
+      res.status,
+      parsed
+    );
+  }
+  if (parsed.code !== 200 && parsed.code !== 0) {
+    throw new DreameApiError(
+      `stream/query rejected: code=${parsed.code} msg=${parsed.message ?? "?"}`,
+      res.status,
+      parsed
+    );
+  }
+  const d = parsed.data ?? {};
+  const dk = d.relayDecryptKey;
+  const hasKey = dk && dk.iv && dk.key;
+  const p = d.p2pInfo;
+  const p2pInfo = p ? {
+    ...p.stunUrl !== void 0 ? { stunUrl: p.stunUrl } : {},
+    ...p.alterStunUrl !== void 0 ? { alterStunUrl: p.alterStunUrl } : {},
+    ...p.signalUrl !== void 0 ? { signalUrl: p.signalUrl } : {},
+    ...p.portDetectStunUrlList !== void 0 ? { portDetectStunUrlList: p.portDetectStunUrlList } : {}
+  } : null;
+  return {
+    typeList: d.typeList ?? [],
+    relayUrl: d.relayUrl ?? null,
+    relayDecryptKey: hasKey ? { iv: dk.iv, key: dk.key } : null,
+    p2pInfo,
+    ...d.supportVisionPtz !== void 0 ? { supportVisionPtz: d.supportVisionPtz } : {}
+  };
+}
+
+// src/video/aliyun/session.ts
+var DEFAULT_WAKE_TIMEOUT_MS = 3e4;
+var DEFAULT_WAKE_POLL_MS = 2e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var REFRESH_LEEWAY_MS = 6e4;
+var DreameVideoSession = class {
+  #session;
+  #region;
+  #regionId;
+  #fetchImpl;
+  #iot = null;
+  #inFlight = null;
+  constructor(input) {
+    this.#session = input.session;
+    this.#region = input.region;
+    this.#regionId = ALIYUN_REGION_ID[input.region];
+    this.#fetchImpl = input.fetchImpl;
+  }
+  /** The resolved Aliyun IoT region id (e.g. `eu-central-1`). */
+  get regionId() {
+    return this.#regionId;
+  }
+  /** Mint (or reuse) a valid Aliyun IoT session, refreshing before expiry. */
+  async ensureIotSession() {
+    const cur = this.#iot;
+    if (cur && Date.now() < cur.expiresAt - REFRESH_LEEWAY_MS) {
+      return cur;
+    }
+    if (this.#inFlight) {
+      return this.#inFlight;
+    }
+    this.#inFlight = this.#mint();
+    try {
+      this.#iot = await this.#inFlight;
+      return this.#iot;
+    } finally {
+      this.#inFlight = null;
+    }
+  }
+  async #mint() {
+    const base = {
+      session: this.#session,
+      region: this.#region,
+      ...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+    };
+    const authCode = await getAliyunAuthCode(base);
+    const oa = await loginByOauth({
+      authCode,
+      regionId: this.#regionId,
+      ...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+    });
+    return createIotSession({
+      sid: oa.sid,
+      regionId: this.#regionId,
+      ...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+    });
+  }
+  /**
+   * Mint a fresh LinkVisual stream descriptor for a device. `encrypted:false`
+   * (default) yields a plain RTMP relay URL directly playable by ffmpeg.
+   *
+   * A camera that has been idle reports "device offline" until the query wakes
+   * its video agent via the LinkVisual cloud. This transparently retries on that
+   * (up to `wakeTimeoutMs`, default 30s) so a single call returns a live stream;
+   * pass `wakeTimeoutMs: 0` to fail fast instead.
+   */
+  async getStreamInfo(iotId, opts) {
+    const deadline = Date.now() + (opts?.wakeTimeoutMs ?? DEFAULT_WAKE_TIMEOUT_MS);
+    const pollMs = opts?.pollMs ?? DEFAULT_WAKE_POLL_MS;
+    for (; ; ) {
+      const iot = await this.ensureIotSession();
+      try {
+        return await streamQuery({
+          regionId: this.#regionId,
+          iotToken: iot.iotToken,
+          iotId,
+          relayEncrypted: opts?.encrypted ?? false,
+          ...this.#fetchImpl ? { fetchImpl: this.#fetchImpl } : {}
+        });
+      } catch (err) {
+        if (err instanceof DreameDeviceOfflineError && Date.now() + pollMs < deadline) {
+          await sleep(pollMs);
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  /**
+   * Convenience: mint a fresh plain RTMP relay URL for a device, or `null` when
+   * the device is not currently streaming (no relay available).
+   */
+  async getRtmpUrl(iotId) {
+    const info = await this.getStreamInfo(iotId, { encrypted: false });
+    return info.relayUrl;
+  }
+};
+
+// src/video/monitor/constants.ts
+var MONITOR_SIID = 10001;
+var MONITOR_AIID = {
+  /** Stream lifecycle + keep-alive (monitor start/end, keep_alive). */
+  CAMERA_OPERATE: 1,
+  /** Two-way intercom start/end. */
+  VOICE_OPERATE: 2,
+  /** Generic property-scoped operations. */
+  PROPERTY_OPERATE: 3,
+  /** Privacy access-code gate (launch/verify/set/reset). */
+  ACCESS_CODE_OPERATE: 4,
+  /** Video-vendor SDK init / switch. */
+  VIDEO_VENDOR: 7
+};
+var MONITOR_PIID = {
+  MONITOR_STATUS: 1,
+  MONITOR_AUDIO_STATUS: 2,
+  MONITOR_RECORD_STATUS: 4,
+  TAKE_PHOTO: 5,
+  KEEP_ALIVE: 6,
+  MONITOR_FAULTS: 7,
+  FILL_LIGHT_SET: 9,
+  CAMERA_LIGHT_SWITCH: 10,
+  VIDEO_VENDOR_STATUS: 11,
+  GET_PROPERTY: 99,
+  PERSON_DATA: 110,
+  VIDEO_OBSTACLE_SWITCH: 111,
+  VIDEO_OBSTACLE_DATA: 112,
+  MONITOR_TASK_STATUS: 103,
+  UPLOAD_STATUS: 1003,
+  GET_ACCESS_CODE: 1100,
+  SET_ACCESS_CODE: 1101,
+  VERIFY_ACCESS_CODE: 1102,
+  MONITOR_REST_MODE: 1103,
+  SET_ACCESS_HOT_STATUS: 1104,
+  MONITOR_SPACE: 2003
+};
+var MONITOR_VENDOR_TOKEN = {
+  ali: "alify",
+  tx: "tx"
+};
+var VACUUM_SIID = 4;
+var VACUUM_MOVE = {
+  /** Remote-drive state property (set_properties), sent ~1 Hz while held. */
+  REMOTE_STATE_PIID: 15,
+  /** Work-mode action instance (go-to-point, cruise, person-follow start). */
+  WORK_AIID: 1,
+  /** Work-mode stop action instance (person-follow stop). */
+  STOP_AIID: 2,
+  /** piid carrying the work-mode selector value in the WORK action. */
+  MODE_PIID: 1,
+  /** piid carrying the point-info JSON in the WORK action. */
+  POINT_PIID: 10,
+  /** Work-mode selector values. */
+  MODE_SPOT: 23,
+  // go to point (MonitorSpotMode)
+  MODE_CRUISE: 22,
+  // cruise / patrol / find-pet
+  MODE_PERSON_FOLLOW: 26,
+  MODE_SPOT_CLEAN: 20,
+  // spot-clean the current position (SpotClean)
+  /** Auto-switch setter property (fill-light auto/full toggle lives here). */
+  AUTO_SWITCH_PIID: 50
+};
+var VACUUM_CHARGE = { siid: 3, aiid: 1 };
+var VOICE_SIID = 7;
+var VOICE_LOCATE_AIID = 1;
+var VOICE_PLAY_SOUND_AIID = 2;
+var VOICE_SOUND_PIID = 4;
+var VACUUM_LOCATE = { siid: VOICE_SIID, aiid: VOICE_LOCATE_AIID };
+var PET_SOUNDS = {
+  meow: 684,
+  bark: 685,
+  footsteps: 686,
+  purring: 687,
+  tickTock: 688
+};
+var VACUUM_ACTIONS = {
+  startClean: { siid: 2, aiid: 1 },
+  pauseClean: { siid: 2, aiid: 2 },
+  stopClean: { siid: 4, aiid: 2 },
+  dockWash: { siid: 4, aiid: 4 },
+  autoEmpty: { siid: 15, aiid: 1 }
+};
+
+// src/video/monitor/protocol.ts
+var import_node_crypto4 = require("crypto");
+function makeMonitorSession(accountId, now = Date.now()) {
+  return (0, import_node_crypto4.createHash)("md5").update(`${accountId}_${now}`).digest("hex");
+}
+function hashAccessCode(code) {
+  return (0, import_node_crypto4.createHash)("sha256").update(code).digest("hex");
+}
+function buildActionInput(piid, params, session) {
+  const value = JSON.stringify({ ...params ?? {}, session });
+  return { piid, value };
+}
+function startMonitorParams(iotId, vendor, area) {
+  return {
+    token: MONITOR_VENDOR_TOKEN[vendor],
+    channelId: iotId,
+    area,
+    operType: "monitor",
+    operation: "start"
+  };
+}
+function stopMonitorParams() {
+  return { operType: "monitor", operation: "end" };
+}
+function keepAliveParams(videoStatus) {
+  return { operType: "keep_alive", videoStatus };
+}
+function accessCodeLaunchParams() {
+  return { open: true };
+}
+function verifyAccessCodeParams(code, lazymode = 0) {
+  return { oldcode: hashAccessCode(code), lazymode };
+}
+function intercomStartParams(opts) {
+  return {
+    operType: "intercom",
+    operation: "start",
+    ...opts?.needRecordSound !== void 0 ? { need_record_sound: opts.needRecordSound } : {},
+    ...opts?.videoCall ? { phone: 1 } : {}
+  };
+}
+function intercomStopParams() {
+  return { operType: "intercom", operation: "end" };
+}
+function fillLightParams(value) {
+  return { value: String(value) };
+}
+function takePhotoParams() {
+  return { operType: "takephoto", operation: "start" };
+}
+function remoteDriveValue(spdv, spdw, now = Date.now()) {
+  return JSON.stringify({
+    spdv,
+    spdw,
+    audio: "false",
+    random: Math.floor(Math.random() * 1e3),
+    timestamp: now
+  });
+}
+var DRIVE_DIRECTIONS = {
+  forward: [200, 0],
+  left: [0, 45],
+  right: [0, -45],
+  turnAround: [0, 180],
+  stop: [0, 0]
+};
+function actionCode(res) {
+  const r = res;
+  return typeof r?.code === "number" ? r.code : null;
+}
+function firstOutValue(res) {
+  const r = res;
+  const out = r?.out ?? r?.result?.out;
+  return Array.isArray(out) && out.length > 0 ? out[0]?.value : void 0;
+}
+
+// src/video/monitor/controller.ts
+var DEFAULT_KEEP_ALIVE_MS = 1e4;
+var DEFAULT_AREA = "4";
+var DreameCameraController = class {
+  #device;
+  #relay;
+  #iotId;
+  #accountId;
+  #vendor;
+  #accessCode;
+  #area;
+  #keepAliveIntervalMs;
+  #wakeTimeoutMs;
+  #onKeepAliveError;
+  #log;
+  #session = null;
+  #keepAliveTimer = null;
+  #opened = false;
+  constructor(input) {
+    this.#device = input.device;
+    this.#relay = input.relay;
+    this.#iotId = input.iotId;
+    this.#accountId = input.accountId;
+    this.#vendor = input.vendor ?? "ali";
+    this.#accessCode = input.accessCode;
+    this.#area = input.area ?? DEFAULT_AREA;
+    this.#keepAliveIntervalMs = input.keepAliveIntervalMs ?? DEFAULT_KEEP_ALIVE_MS;
+    this.#wakeTimeoutMs = input.wakeTimeoutMs;
+    this.#onKeepAliveError = input.onKeepAliveError;
+    this.#log = input.log ?? (() => {
+    });
+  }
+  #logLine(msg) {
+    this.#log(`[nodedreame:monitor] ${msg}`);
+  }
+  /** True while a monitor session is active (between {@link open} and {@link close}). */
+  get isOpen() {
+    return this.#opened;
+  }
+  /** Send one camera action, resolving to the raw device reply. */
+  async #action(aiid, piid, params) {
+    if (!this.#session) {
+      throw new DreameError("camera controller has no session; call open() first");
+    }
+    const input = buildActionInput(piid, params, this.#session);
+    return this.#device.callAction(MONITOR_SIID, aiid, [input]);
+  }
+  /**
+   * Run the full cold-start sequence and return a live relay URL. Starts the
+   * keep-alive loop; the caller MUST {@link close} when done to release the
+   * device. Throws if the monitor cannot be started or no relay comes up.
+   */
+  async open() {
+    if (this.#opened) {
+      throw new DreameError("camera stream already open");
+    }
+    this.#session = makeMonitorSession(this.#accountId);
+    this.#logLine(`open: vendor=${this.#vendor} iotId=${this.#iotId} area=${this.#area}`);
+    await this.#tryPrime();
+    const startRes = await this.#startMonitorWithGate();
+    const encryptionKey = asString(firstOutValue(startRes));
+    this.#logLine(`startMonitor accepted (encryptionKey=${encryptionKey ? "yes" : "no"})`);
+    this.#opened = true;
+    this.#startKeepAlive();
+    let relayUrl;
+    try {
+      const info = await this.#relay.getStreamInfo(this.#iotId, {
+        encrypted: false,
+        ...this.#wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: this.#wakeTimeoutMs } : {}
+      });
+      relayUrl = info.relayUrl;
+    } catch (err) {
+      this.#logLine(`relay mint failed: ${err instanceof Error ? err.message : String(err)}`);
+      await this.close();
+      throw err;
+    }
+    if (!relayUrl) {
+      await this.close();
+      throw new DreameError("monitor started but no relay URL was returned");
+    }
+    this.#logLine("relay up");
+    return { rtmpUrl: relayUrl, encryptionKey };
+  }
+  async #tryPrime() {
+    try {
+      await this.#action(MONITOR_AIID.ACCESS_CODE_OPERATE, MONITOR_PIID.GET_ACCESS_CODE, accessCodeLaunchParams());
+    } catch {
+    }
+    try {
+      await this.#action(MONITOR_AIID.VIDEO_VENDOR, MONITOR_PIID.VIDEO_VENDOR_STATUS, null);
+    } catch {
+    }
+  }
+  async #startMonitorWithGate() {
+    const params = startMonitorParams(this.#iotId, this.#vendor, this.#area);
+    let res = await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, params);
+    if (actionCode(res) === 0) {
+      return res;
+    }
+    this.#logLine(`startMonitor refused (code ${actionCode(res) ?? "?"}); verifying access code`);
+    if (this.#accessCode) {
+      await this.#action(
+        MONITOR_AIID.ACCESS_CODE_OPERATE,
+        MONITOR_PIID.VERIFY_ACCESS_CODE,
+        verifyAccessCodeParams(this.#accessCode)
+      );
+      res = await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, params);
+    }
+    if (actionCode(res) !== 0) {
+      const code = actionCode(res);
+      throw new DreameError(
+        `startMonitor refused (code ${code ?? "?"})` + (this.#accessCode ? "" : "; device likely requires an accessCode")
+      );
+    }
+    return res;
+  }
+  #startKeepAlive() {
+    this.#stopKeepAlive();
+    this.#keepAliveTimer = setInterval(() => {
+      void this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.KEEP_ALIVE, keepAliveParams("opened")).catch(
+        (err) => this.#onKeepAliveError?.(err)
+      );
+    }, this.#keepAliveIntervalMs);
+    this.#keepAliveTimer.unref?.();
+  }
+  #stopKeepAlive() {
+    if (this.#keepAliveTimer) {
+      clearInterval(this.#keepAliveTimer);
+      this.#keepAliveTimer = null;
+    }
+  }
+  /**
+   * Mint a FRESH single-use RTMP relay URL for the already-open monitor. Each
+   * consumer needs its own relay URL, so call this once per ffmpeg/consumer.
+   * Throws if the stream is not open.
+   */
+  async mintRelayUrl() {
+    if (!this.#opened) {
+      throw new DreameError("camera stream is not open; call open() first");
+    }
+    const info = await this.#relay.getStreamInfo(this.#iotId, {
+      encrypted: false,
+      ...this.#wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: this.#wakeTimeoutMs } : {}
+    });
+    if (!info.relayUrl) {
+      throw new DreameError("no relay URL available for the open monitor");
+    }
+    return info.relayUrl;
+  }
+  /** Start the two-way intercom session (control plane only; see module docs on mic uplink). */
+  async startIntercom(opts) {
+    return this.#action(MONITOR_AIID.VOICE_OPERATE, MONITOR_PIID.MONITOR_AUDIO_STATUS, intercomStartParams(opts));
+  }
+  /** Stop the two-way intercom session. */
+  async stopIntercom() {
+    return this.#action(MONITOR_AIID.VOICE_OPERATE, MONITOR_PIID.MONITOR_AUDIO_STATUS, intercomStopParams());
+  }
+  /** Set the fill-light brightness (40–100 = manual %, below 40 / 101 = auto). */
+  async setFillLight(value) {
+    return this.#action(MONITOR_AIID.PROPERTY_OPERATE, MONITOR_PIID.FILL_LIGHT_SET, fillLightParams(value));
+  }
+  /**
+   * Device-side snapshot: the robot captures a still and uploads it to cloud
+   * storage (read the result back from the `uploadStatus` property). Prefer a
+   * frame-grab from the live stream for an instant image.
+   */
+  async takePhoto() {
+    return this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.TAKE_PHOTO, takePhotoParams());
+  }
+  /**
+   * Remote-drive the robot ("PTZ" substitute — the camera is fixed, the robot
+   * moves). `spdv` = forward speed, `spdw` = turn; send repeatedly (~1 Hz) while
+   * a direction is held, then `stop`. Only valid while the stream is open.
+   */
+  async drive(spdv, spdw) {
+    this.#requireSession();
+    if (!this.#device.setProperty) {
+      throw new DreameError("device does not support setProperty; cannot remote-drive");
+    }
+    return this.#device.setProperty({
+      siid: VACUUM_SIID,
+      piid: VACUUM_MOVE.REMOTE_STATE_PIID,
+      value: remoteDriveValue(spdv, spdw)
+    });
+  }
+  /** Remote-drive by named direction (forward/left/right/turnAround/stop). */
+  async driveDirection(direction) {
+    const [spdv, spdw] = DRIVE_DIRECTIONS[direction];
+    return this.drive(spdv, spdw);
+  }
+  /** Start person-follow mode (robot tracks a detected person). */
+  async startPersonFollow() {
+    this.#requireSession();
+    return this.#device.callAction(VACUUM_SIID, VACUUM_MOVE.WORK_AIID, [
+      { piid: VACUUM_MOVE.MODE_PIID, value: VACUUM_MOVE.MODE_PERSON_FOLLOW }
+    ]);
+  }
+  /**
+   * Universal stop for the current work mode — stops person-follow, spot-clean,
+   * go-to-point, cruise, etc. (siid 4 / aiid 2).
+   */
+  async stopWork() {
+    return this.#device.callAction(VACUUM_SIID, VACUUM_MOVE.STOP_AIID, []);
+  }
+  /** Stop person-follow mode (alias for {@link stopWork}). */
+  async stopPersonFollow() {
+    return this.stopWork();
+  }
+  /** Spot-clean the robot's current position (WorkMode SpotClean). */
+  async spotClean() {
+    return this.#device.callAction(VACUUM_SIID, VACUUM_MOVE.WORK_AIID, [
+      { piid: VACUUM_MOVE.MODE_PIID, value: VACUUM_MOVE.MODE_SPOT_CLEAN }
+    ]);
+  }
+  /** Play one of the robot's sound clips (e.g. pet sounds) by id. */
+  async playSound(soundId) {
+    return this.#device.callAction(VOICE_SIID, VOICE_PLAY_SOUND_AIID, [
+      { piid: VOICE_SOUND_PIID, value: soundId }
+    ]);
+  }
+  /** Play a named pet-teasing sound (meow/bark/footsteps/purring/tickTock). */
+  async playPetSound(sound) {
+    return this.playSound(PET_SOUNDS[sound]);
+  }
+  /** Run a common whole-robot action (startClean/pauseClean/stopClean/dockWash/autoEmpty). */
+  async runVacuumAction(action) {
+    const a = VACUUM_ACTIONS[action];
+    return this.#device.callAction(a.siid, a.aiid, []);
+  }
+  /** Find-pet: cruise the home looking for the pet. */
+  async findPet() {
+    this.#requireSession();
+    return this.#device.callAction(VACUUM_SIID, VACUUM_MOVE.WORK_AIID, [
+      { piid: VACUUM_MOVE.MODE_PIID, value: VACUUM_MOVE.MODE_CRUISE },
+      { piid: VACUUM_MOVE.POINT_PIID, value: JSON.stringify({ findpet: "" }) }
+    ]);
+  }
+  /** Send the robot to a map point (`spoint` current, `tpoint` targets). */
+  async goToPoint(spoint, tpoint) {
+    this.#requireSession();
+    return this.#device.callAction(VACUUM_SIID, VACUUM_MOVE.WORK_AIID, [
+      { piid: VACUUM_MOVE.MODE_PIID, value: VACUUM_MOVE.MODE_SPOT },
+      { piid: VACUUM_MOVE.POINT_PIID, value: JSON.stringify({ spoint, tpoint }) }
+    ]);
+  }
+  /** Toggle the fill light between auto (`full=false`) and full-on (`full=true`). */
+  async setFillLightAuto(full) {
+    if (!this.#device.setProperty) {
+      throw new DreameError("device does not support setProperty; cannot toggle fill light");
+    }
+    return this.#device.setProperty({
+      siid: VACUUM_SIID,
+      piid: VACUUM_MOVE.AUTO_SWITCH_PIID,
+      value: JSON.stringify({ k: "FillinLight", v: full ? 1 : 0 })
+    });
+  }
+  /**
+   * Send the robot back to its dock to charge ("go home"). Works regardless of
+   * stream state — usable as a standalone command or a PTZ "home" preset.
+   */
+  async returnToDock() {
+    return this.#device.callAction(VACUUM_CHARGE.siid, VACUUM_CHARGE.aiid, []);
+  }
+  /** Locate the robot — it beeps. Works regardless of stream state. */
+  async locate() {
+    return this.#device.callAction(VACUUM_LOCATE.siid, VACUUM_LOCATE.aiid, []);
+  }
+  #requireSession() {
+    if (!this.#opened) {
+      throw new DreameError("camera stream is not open; call open() first");
+    }
+  }
+  /** Stop the keep-alive loop and release the monitor on the device. Idempotent. */
+  async close() {
+    this.#stopKeepAlive();
+    if (!this.#opened) {
+      this.#session = null;
+      return;
+    }
+    this.#opened = false;
+    this.#logLine("close: stopping monitor");
+    try {
+      await this.#action(MONITOR_AIID.CAMERA_OPERATE, MONITOR_PIID.MONITOR_STATUS, stopMonitorParams());
+    } finally {
+      this.#session = null;
+    }
+  }
+};
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+
 // src/models/vacuum/map/envelope.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var zlib = __toESM(require("zlib"), 1);
 var HEADER_SIZE = 27;
 var ANGLE_ABSENT = 32767;
@@ -2093,7 +3260,7 @@ function looksLikeBase64Zlib(buf) {
 }
 function aesCbcDecrypt(cipher, rawKey, iv) {
   const keyBytes = Buffer.from(
-    (0, import_node_crypto2.createHash)("sha256").update(rawKey).digest("hex").slice(0, 32),
+    (0, import_node_crypto5.createHash)("sha256").update(rawKey).digest("hex").slice(0, 32),
     "utf8"
   );
   const ivBytes = Buffer.from(iv, "utf8");
@@ -2101,7 +3268,7 @@ function aesCbcDecrypt(cipher, rawKey, iv) {
     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);
+    const decipher = (0, import_node_crypto5.createDecipheriv)("aes-256-cbc", keyBytes, ivBytes);
     decipher.setAutoPadding(false);
     return Buffer.concat([decipher.update(cipher), decipher.final()]);
   } catch (err) {
@@ -3434,6 +4601,97 @@ function drawLabel(png, cx, cy, text, color, px) {
   }
 }
 
+// src/models/vacuum/map/wifi.ts
+var import_pngjs2 = require("pngjs");
+var NIBBLE_TO_BARS = { 10: 0, 11: 1, 12: 2, 13: 3, 14: 4 };
+var isWifiNibble = (n) => n >= 10 && n <= 14;
+var NIBBLE_RGBA = {
+  2: [176, 182, 190, 255],
+  // map border (context)
+  3: [242, 244, 247, 255],
+  // mapped floor (context)
+  10: [229, 234, 238, 255],
+  // unreached
+  11: [217, 226, 239, 255],
+  // 1 bar
+  12: [205, 218, 239, 255],
+  // 2 bars
+  13: [161, 189, 242, 255],
+  // 3 bars
+  14: [129, 168, 245, 255]
+  // 4 bars
+};
+var poseOrNull = (x, y, a) => x === 0 && y === 0 ? null : { x, y, angle: a === ANGLE_ABSENT ? 0 : a };
+function decodeWifiSignalMap(input, opts = {}) {
+  const inflated = typeof input === "string" ? unwrapEnvelope(input, opts) : looksLikeBase64Zlib(input) ? unwrapEnvelope(input.toString("latin1"), opts) : input;
+  const header = parseMapHeader(inflated);
+  const { width, height, gridSize, left, top } = header;
+  const pixelEnd = HEADER_SIZE + width * height;
+  const grid = inflated.subarray(HEADER_SIZE, pixelEnd);
+  const cells = new Uint8Array(width * height);
+  for (let i = 0; i < cells.length; i++) cells[i] = (grid[i] ?? 0) & 15;
+  const dimensions = { left, top, width, height, gridSize };
+  const robot = poseOrNull(header.robotX, header.robotY, header.robotA);
+  const dock = poseOrNull(header.chargerX, header.chargerY, header.chargerA);
+  const signalAt = (worldX, worldY) => {
+    if (gridSize <= 0) return null;
+    const col = Math.floor((worldX - left) / gridSize);
+    const row = Math.floor((worldY - top) / gridSize);
+    if (col < 0 || col >= width || row < 0 || row >= height) return null;
+    const nibble = cells[row * width + col] ?? 0;
+    return isWifiNibble(nibble) ? NIBBLE_TO_BARS[nibble] : null;
+  };
+  return {
+    dimensions,
+    robot,
+    dock,
+    cells,
+    signalAt,
+    currentSignal: robot ? signalAt(robot.x, robot.y) : null
+  };
+}
+function renderWifiSignalPng(map, opts = {}) {
+  const scale = Math.max(1, Math.floor(opts.scale ?? 4));
+  const { width, height, left, top, gridSize } = map.dimensions;
+  const png = new import_pngjs2.PNG({ width: width * scale, height: height * scale, colorType: 6 });
+  for (let row = 0; row < height; row++) {
+    for (let col = 0; col < width; col++) {
+      const nibble = map.cells[row * width + col] ?? 0;
+      const rgba = NIBBLE_RGBA[nibble];
+      if (!rgba) continue;
+      for (let dy = 0; dy < scale; dy++) {
+        for (let dx = 0; dx < scale; dx++) {
+          const px = col * scale + dx + (row * scale + dy) * width * scale;
+          const o = px << 2;
+          png.data[o] = rgba[0];
+          png.data[o + 1] = rgba[1];
+          png.data[o + 2] = rgba[2];
+          png.data[o + 3] = rgba[3];
+        }
+      }
+    }
+  }
+  if ((opts.markRobot ?? true) && map.robot && gridSize > 0) {
+    const cx = Math.floor((map.robot.x - left) / gridSize) * scale + Math.floor(scale / 2);
+    const cy = Math.floor((map.robot.y - top) / gridSize) * scale + Math.floor(scale / 2);
+    const r = Math.max(2, scale);
+    for (let dy = -r; dy <= r; dy++) {
+      for (let dx = -r; dx <= r; dx++) {
+        if (dx * dx + dy * dy > r * r) continue;
+        const x = cx + dx;
+        const y = cy + dy;
+        if (x < 0 || y < 0 || x >= width * scale || y >= height * scale) continue;
+        const o = x + y * width * scale << 2;
+        png.data[o] = 255;
+        png.data[o + 1] = 69;
+        png.data[o + 2] = 0;
+        png.data[o + 3] = 255;
+      }
+    }
+  }
+  return import_pngjs2.PNG.sync.write(png);
+}
+
 // src/models/vacuum/map/oss-fetch.ts
 var OSS_DOWNLOAD_PATH = "/dreame-user-iot/iotfile/getDownloadUrl";
 var DEFAULT_TTL_MS = 30 * 60 * 1e3;
@@ -3919,11 +5177,11 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
     }
     this.#requireCap(this.#caps.canCleanPerRoom, "cleanZones", "per-room cleaning");
     const { repeats, fan, water } = this.#resolveCleanOpts(opts);
-    const areas = zones.map((z4) => [
-      Math.round(z4.x0),
-      Math.round(z4.y0),
-      Math.round(z4.x1),
-      Math.round(z4.y1),
+    const areas = zones.map((z7) => [
+      Math.round(z7.x0),
+      Math.round(z7.y0),
+      Math.round(z7.x1),
+      Math.round(z7.y1),
       repeats,
       fan,
       water
@@ -4051,6 +5309,66 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
       ...input.iv !== void 0 ? { iv: input.iv } : {}
     };
   }
+  /**
+   * Fetch the robot's Wi-Fi signal map — the last stored coverage heatmap, with
+   * NO robot movement. Requests it (map service `wifiMap` action, siid 6 aiid 4),
+   * polls `PropWifiMap` (6/15) for the OSS object it advertises, fetches + decodes
+   * it into a per-cell signal grid + geometry + robot/dock poses. The signal at
+   * any world point (incl. the robot's own position) is a lookup — see
+   * {@link WifiSignalMap.signalAt} / {@link WifiSignalMap.currentSignal}.
+   *
+   * Pass `requestFresh: false` to skip the request and read whatever is already
+   * advertised. Throws if no Wi-Fi map exists yet (never run on this device).
+   */
+  async getWifiSignalMap(input = {}) {
+    if (input.requestFresh !== false) {
+      try {
+        await this.callAction(6, 4, []);
+      } catch {
+      }
+    }
+    const pollMs = input.pollMs ?? 2500;
+    const deadline = Date.now() + (input.maxWaitMs ?? 2e4);
+    let objectName = "";
+    for (; ; ) {
+      const res = await this.refreshProperties([{ siid: 6, piid: 15 }]);
+      const val = res[0]?.value;
+      if (typeof val === "string" && val.length > 0) {
+        objectName = val;
+        break;
+      }
+      if (Date.now() + pollMs >= deadline) {
+        throw new DreameError("wifi signal map not available (none stored yet, or request timed out)");
+      }
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+    const filename = objectName.replace(/^\d+,/, "");
+    const blob = await this.#fetchMapBlob({
+      filename,
+      ...input.fetcher ? { fetcher: input.fetcher } : {},
+      ...input.host ? { host: input.host } : {},
+      ...input.timeoutMs !== void 0 ? { timeoutMs: input.timeoutMs } : {},
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    return decodeWifiSignalMap(blob, this.#decodeOpts(input));
+  }
+  /**
+   * Render the Wi-Fi signal map as a simple PNG heatmap image (weakest→strongest,
+   * unreached grey, robot marker) — ready to display. Convenience over
+   * {@link getWifiSignalMap} + {@link renderWifiSignalPng}.
+   */
+  async getWifiSignalImage(input = {}) {
+    const map = await this.getWifiSignalMap(input);
+    return renderWifiSignalPng(map, input);
+  }
+  /**
+   * The one-call "current Wi-Fi signal": fetches the signal map and returns the
+   * bars (1–4, 0 = unreached) at the robot's own position, or null when unknown.
+   */
+  async getCurrentSignal(input = {}) {
+    const map = await this.getWifiSignalMap(input);
+    return map.currentSignal;
+  }
   /**
    * The merge base for live P-frame streaming — always an INFLATED frame buffer.
    * An I-frame (re)seeds it; each P-frame merge replaces it with the merged
@@ -4114,6 +5432,39 @@ var VacuumDevice = class _VacuumDevice extends BaseDevice {
     this.emit("map", frame);
     return frame;
   }
+  /**
+   * Build a {@link DreameCameraController} for this device's camera, wired to
+   * both planes it needs: the MIoT action transport (this device handle) and a
+   * fresh Aliyun {@link DreameVideoSession} for the relay. Call
+   * `controller.open()` to autonomously cold-start the stream and get a pullable
+   * RTMP URL, then `controller.close()` to release it.
+   *
+   * The camera's per-session privacy gate means a coded camera needs its PIN:
+   * pass `accessCode` (the code set at pairing). `iotId` is resolved from the
+   * device's cloud video profile when not supplied.
+   */
+  async createCameraController(opts) {
+    const session = this.currentSession();
+    const region = this.region;
+    const relay = opts?.relay ?? new DreameVideoSession({ session, region });
+    const iotId = opts?.iotId ?? (await getDeviceVideoProfile({ session, region, did: this.deviceId })).iotId;
+    if (!iotId) {
+      throw new DreameError("device has no LinkVisual iotId; not a camera device or not provisioned");
+    }
+    return new DreameCameraController({
+      device: this,
+      relay,
+      iotId,
+      accountId: session.uid,
+      ...opts?.vendor ? { vendor: opts.vendor } : {},
+      ...opts?.accessCode !== void 0 ? { accessCode: opts.accessCode } : {},
+      ...opts?.area ? { area: opts.area } : {},
+      ...opts?.keepAliveIntervalMs !== void 0 ? { keepAliveIntervalMs: opts.keepAliveIntervalMs } : {},
+      ...opts?.wakeTimeoutMs !== void 0 ? { wakeTimeoutMs: opts.wakeTimeoutMs } : {},
+      ...opts?.onKeepAliveError ? { onKeepAliveError: opts.onKeepAliveError } : {},
+      ...opts?.log ? { log: opts.log } : {}
+    });
+  }
   /** Props worth seeding on start() / polling — exported for the facade. */
   static DEFAULT_PROPS = [
     VACUUM_PROP.STATE,
@@ -4652,7 +6003,7 @@ function isRecord3(v) {
 function asNumber(v, fallback) {
   return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
-function asString(v, fallback) {
+function asString2(v, fallback) {
   return typeof v === "string" ? v : fallback;
 }
 function mapIdFromIndex(mapIndex) {
@@ -4747,7 +6098,7 @@ function parseZones(list, includeTimes) {
     out.push({
       zoneId: asNumber(id, 0),
       path: extractPathCoords(data["path"]),
-      name: asString(data["name"], ""),
+      name: asString2(data["name"], ""),
       zoneType: asNumber(data["type"], 0),
       shapeType: includeTimes ? asNumber(data["shapeType"], 0) : 0,
       area: includeTimes ? asNumber(data["area"], 0) : 0,
@@ -4768,7 +6119,7 @@ function parseSpotAreas(list) {
     out.push({
       areaId: Math.trunc(asNumber(id, 0)),
       path: extractPathCoords(data["path"]),
-      name: asString(data["name"], ""),
+      name: asString2(data["name"], ""),
       shapeType: asNumber(data["shapeType"], 0),
       area: asNumber(data["area"], 0)
     });
@@ -4832,7 +6183,7 @@ function parseMowerMap(mapJsonStr) {
     contours: parseContours(parsePolygonList(data["contours"])),
     boundary: parseBoundary(data["boundary"]),
     totalArea: asNumber(data["totalArea"], 0),
-    name: asString(data["name"], ""),
+    name: asString2(data["name"], ""),
     mapIndex,
     mapId: mapIdFromIndex(mapIndex),
     mowPaths: [],
@@ -5360,7 +6711,7 @@ var MowerDevice = class _MowerDevice extends BaseDevice {
     if (zoneIds.length === 0) {
       throw new RangeError("startMowingZones: zoneIds must not be empty");
     }
-    return this.#sendTask(buildZonePayload(zoneIds.map((z4) => Math.trunc(z4))));
+    return this.#sendTask(buildZonePayload(zoneIds.map((z7) => Math.trunc(z7))));
   }
   /** Edge / contour mowing (2:50 o:101). Contour ids are two-int pairs [[1,0]]. */
   async startMowingEdges(contourIds) {
@@ -5525,6 +6876,7 @@ function defaultDeps(opts) {
         device: args.device,
         region: args.region,
         sessionRef: args.sessionRef,
+        ...args.onAuthFailure !== void 0 ? { onAuthFailure: args.onAuthFailure } : {},
         ...opts.fetchInitialValues !== void 0 ? { fetchInitialValues: opts.fetchInitialValues } : {},
         ...opts.pollIntervalMs !== void 0 ? { pollIntervalMs: opts.pollIntervalMs } : {}
       });
@@ -5538,6 +6890,15 @@ var Nodreame = class extends TypedEmitter {
   #session = null;
   #devices = [];
   #closed = false;
+  /** Background timer that proactively refreshes before the token expires. */
+  #refreshTimer = null;
+  /** Guard against overlapping proactive-refresh runs. */
+  #refreshInFlight = false;
+  /**
+   * The single in-flight refresh, shared by concurrent callers so the proactive
+   * timer and a manual `ensureSession()`/`reauthenticate()` never double-refresh.
+   */
+  #inFlightRefresh = null;
   constructor(opts, deps) {
     super();
     if (!opts.username || !opts.password) {
@@ -5566,6 +6927,7 @@ var Nodreame = class extends TypedEmitter {
       ...this.#opts.lang !== void 0 ? { lang: this.#opts.lang } : {},
       ...this.#opts.fetchImpl !== void 0 ? { fetchImpl: this.#opts.fetchImpl } : {}
     });
+    this.#scheduleProactiveRefresh();
     return this.#session;
   }
   /** Return a valid session, refreshing proactively within the leeway window. */
@@ -5577,18 +6939,61 @@ var Nodreame = class extends TypedEmitter {
     if (Date.now() < current.expiresAt - this.#leewayMs) {
       return current;
     }
+    return this.#refreshNow(current);
+  }
+  /**
+   * Force a session refresh REGARDLESS of the current expiry, then propagate the
+   * new token to every live device push. Wired as each push's `onAuthFailure`:
+   * when a broker refuses a CONNECT because it considers the token stale (even
+   * though {@link ensureSession} still thinks it valid — e.g. server-side early
+   * revocation or clock skew), this mints a genuinely fresh token instead of
+   * replaying the rejected one.
+   */
+  async reauthenticate() {
+    if (this.#closed) {
+      throw new DreameAuthError("client is closed");
+    }
+    const current = this.#session;
+    if (!current) {
+      return this.login();
+    }
+    return this.#refreshNow(current);
+  }
+  /**
+   * Refresh via the refresh-token (with a full re-login fallback) and propagate
+   * the new token to every device push. Shared by {@link ensureSession} (within
+   * the leeway window) and {@link reauthenticate} (unconditional).
+   */
+  async #refreshNow(current) {
+    const existing = this.#inFlightRefresh;
+    if (existing) {
+      return existing;
+    }
+    const run = this.#doRefresh(current);
+    this.#inFlightRefresh = run;
+    try {
+      return await run;
+    } finally {
+      this.#inFlightRefresh = null;
+    }
+  }
+  async #doRefresh(current) {
     if (current.refreshToken) {
+      let next = null;
       try {
-        const next = await this.#deps.refresh({
+        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 } : {}
         });
+      } catch {
+        next = null;
+      }
+      if (next) {
         await this.#adoptSession(next);
         return next;
-      } catch {
       }
     }
     const fresh = await this.login();
@@ -5610,23 +7015,30 @@ var Nodreame = class extends TypedEmitter {
       (device) => this.#deps.createDevice({
         device,
         region: this.#opts.region,
-        sessionRef: () => this.#requireSession()
+        sessionRef: () => this.#requireSession(),
+        onAuthFailure: () => this.reauthenticate()
       })
     );
     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));
+      h.on("error", (err) => {
+        if (this.listenerCount("error") > 0) {
+          this.emit("error", err);
+        }
+      });
       await h.start();
     }
     const previous = this.#devices;
     this.#devices = [...handles];
     await Promise.all(previous.map((d) => d.close()));
+    this.#scheduleProactiveRefresh();
     return this.#devices;
   }
   /** Tear everything down: close every device push and clear timers. */
   async close() {
     this.#closed = true;
+    this.#clearRefreshTimer();
     const devices = this.#devices;
     this.#devices = [];
     await Promise.all(devices.map((d) => d.close()));
@@ -5641,13 +7053,68 @@ var Nodreame = class extends TypedEmitter {
   async #adoptSession(session) {
     this.#session = session;
     await this.#propagateSession(session);
+    this.#scheduleProactiveRefresh();
+  }
+  #clearRefreshTimer() {
+    if (this.#refreshTimer) {
+      clearTimeout(this.#refreshTimer);
+      this.#refreshTimer = null;
+    }
+  }
+  /** Arm the proactive-refresh timer `delayMs` from now (clamped to ≥0). */
+  #armRefreshTimer(delayMs) {
+    this.#clearRefreshTimer();
+    if (this.#closed) {
+      return;
+    }
+    this.#refreshTimer = setTimeout(
+      () => {
+        this.#refreshTimer = null;
+        void this.#runProactiveRefresh();
+      },
+      Math.max(0, delayMs)
+    );
+  }
+  /** (Re)arm the proactive-refresh timer against the current session's expiry. */
+  #scheduleProactiveRefresh() {
+    const session = this.#session;
+    if (!session) {
+      this.#clearRefreshTimer();
+      return;
+    }
+    this.#armRefreshTimer(session.expiresAt - this.#leewayMs - Date.now());
+  }
+  /**
+   * Timer body: refresh the session before it expires, then reschedule against
+   * the new expiry. Because {@link ensureSession} propagates the refreshed token
+   * to every device push, each MQTT connection is re-keyed BEFORE the broker
+   * would reject the old one — the reactive re-auth loop never even starts.
+   */
+  async #runProactiveRefresh() {
+    if (this.#closed || this.#refreshInFlight) {
+      return;
+    }
+    this.#refreshInFlight = true;
+    try {
+      await this.ensureSession();
+      this.#refreshInFlight = false;
+      this.#scheduleProactiveRefresh();
+    } catch (err) {
+      this.#refreshInFlight = false;
+      if (this.listenerCount("error") > 0) {
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+      if (!this.#closed) {
+        this.#armRefreshTimer(this.#leewayMs);
+      }
+    }
   }
   /** 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)));
+    await Promise.allSettled(this.#devices.map((d) => d.applySession(session)));
   }
 };
 
@@ -5764,59 +7231,59 @@ function redact(value) {
 }
 
 // src/diagnostics/dump-format.ts
-var import_zod3 = require("zod");
-var DumpScalarSchema = import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean()]);
-var PropertyObservationSchema = import_zod3.z.object({
-  values: import_zod3.z.array(DumpScalarSchema),
-  unmapped: import_zod3.z.array(DumpScalarSchema),
-  enum: import_zod3.z.string().optional(),
-  count: import_zod3.z.number(),
-  firstSeen: import_zod3.z.number(),
-  lastSeen: import_zod3.z.number()
+var import_zod6 = require("zod");
+var DumpScalarSchema = import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number(), import_zod6.z.boolean()]);
+var PropertyObservationSchema = import_zod6.z.object({
+  values: import_zod6.z.array(DumpScalarSchema),
+  unmapped: import_zod6.z.array(DumpScalarSchema),
+  enum: import_zod6.z.string().optional(),
+  count: import_zod6.z.number(),
+  firstSeen: import_zod6.z.number(),
+  lastSeen: import_zod6.z.number()
 });
-var EventObservationSchema = import_zod3.z.object({
-  at: import_zod3.z.number(),
-  type: import_zod3.z.string(),
-  data: import_zod3.z.unknown().optional()
+var EventObservationSchema = import_zod6.z.object({
+  at: import_zod6.z.number(),
+  type: import_zod6.z.string(),
+  data: import_zod6.z.unknown().optional()
 });
-var RawFrameSchema = import_zod3.z.object({
-  at: import_zod3.z.number(),
-  source: import_zod3.z.string(),
-  payload: import_zod3.z.unknown()
+var RawFrameSchema = import_zod6.z.object({
+  at: import_zod6.z.number(),
+  source: import_zod6.z.string(),
+  payload: import_zod6.z.unknown()
 });
-var CommandSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  siid: import_zod3.z.number().optional(),
-  aiid: import_zod3.z.number().optional()
+var CommandSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  siid: import_zod6.z.number().optional(),
+  aiid: import_zod6.z.number().optional()
 });
-var SensorSchema = import_zod3.z.object({
-  model: import_zod3.z.string(),
-  channel: import_zod3.z.number().optional()
+var SensorSchema = import_zod6.z.object({
+  model: import_zod6.z.string(),
+  channel: import_zod6.z.number().optional()
 });
-var DeviceDumpSchema = import_zod3.z.object({
-  schemaVersion: import_zod3.z.literal(1),
-  library: import_zod3.z.union([import_zod3.z.literal("nodedreame"), import_zod3.z.literal("nodewitt")]),
-  libraryVersion: import_zod3.z.string(),
-  device: import_zod3.z.object({
-    model: import_zod3.z.string(),
-    firmware: import_zod3.z.string().optional(),
-    region: import_zod3.z.string().optional(),
-    type: import_zod3.z.string().optional()
+var DeviceDumpSchema = import_zod6.z.object({
+  schemaVersion: import_zod6.z.literal(1),
+  library: import_zod6.z.union([import_zod6.z.literal("nodedreame"), import_zod6.z.literal("nodewitt")]),
+  libraryVersion: import_zod6.z.string(),
+  device: import_zod6.z.object({
+    model: import_zod6.z.string(),
+    firmware: import_zod6.z.string().optional(),
+    region: import_zod6.z.string().optional(),
+    type: import_zod6.z.string().optional()
   }),
-  observations: import_zod3.z.object({
-    properties: import_zod3.z.record(import_zod3.z.string(), PropertyObservationSchema),
-    events: import_zod3.z.array(EventObservationSchema),
-    rawFrames: import_zod3.z.array(RawFrameSchema).optional()
+  observations: import_zod6.z.object({
+    properties: import_zod6.z.record(import_zod6.z.string(), PropertyObservationSchema),
+    events: import_zod6.z.array(EventObservationSchema),
+    rawFrames: import_zod6.z.array(RawFrameSchema).optional()
   }),
-  catalog: import_zod3.z.object({
-    commands: import_zod3.z.array(CommandSchema).optional(),
-    capabilities: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
-    sensors: import_zod3.z.array(SensorSchema).optional()
+  catalog: import_zod6.z.object({
+    commands: import_zod6.z.array(CommandSchema).optional(),
+    capabilities: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional(),
+    sensors: import_zod6.z.array(SensorSchema).optional()
   }),
-  meta: import_zod3.z.object({
-    startedAt: import_zod3.z.number(),
-    durationMs: import_zod3.z.number(),
-    generatedAt: import_zod3.z.number()
+  meta: import_zod6.z.object({
+    startedAt: import_zod6.z.number(),
+    durationMs: import_zod6.z.number(),
+    generatedAt: import_zod6.z.number()
   })
 });
 
@@ -6105,21 +7572,939 @@ function createDumper(target, options) {
 function createClientDumper(client, options) {
   return client.devices.map((d) => createDumper(d, options));
 }
+
+// src/video/monitor/detections.ts
+var asRecord = (value) => {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return value && typeof value === "object" ? value : null;
+};
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+var toMs = (raw) => {
+  const n = num(raw);
+  if (n === void 0) return Date.now();
+  return n > 1e15 ? Math.round(n / 1e6) : n;
+};
+var toBox = (raw) => {
+  if (Array.isArray(raw) && raw.length >= 4) {
+    const [x2, y2, w2, h2] = raw;
+    if ([x2, y2, w2, h2].every((v) => num(v) !== void 0)) {
+      return { x: x2, y: y2, w: w2, h: h2 };
+    }
+    return null;
+  }
+  const r = asRecord(raw);
+  if (!r) return null;
+  const x = num(r["x"]);
+  const y = num(r["y"]);
+  const w = num(r["w"]) ?? num(r["width"]);
+  const h = num(r["h"]) ?? num(r["height"]);
+  if (x === void 0 || y === void 0 || w === void 0 || h === void 0) return null;
+  const label = typeof r["label"] === "string" ? r["label"] : void 0;
+  const score = num(r["score"]) ?? num(r["confidence"]);
+  return { x, y, w, h, ...label !== void 0 ? { label } : {}, ...score !== void 0 ? { score } : {} };
+};
+function parsePersonFollow(value) {
+  const r = asRecord(value);
+  if (!r) return null;
+  return {
+    timestampMs: toMs(r["timestamp"] ?? r["time"]),
+    box: toBox(r["bbox"] ?? r["box"])
+  };
+}
+function parseObstacleData(value) {
+  const r = asRecord(value);
+  if (!r) return null;
+  const list = r["boxlist"] ?? r["boxes"] ?? r["boxList"];
+  const boxes = [];
+  if (Array.isArray(list)) {
+    for (const item of list) {
+      const box = toBox(item);
+      if (box) boxes.push(box);
+    }
+  }
+  return { timestampMs: toMs(r["timestamp"] ?? r["time"]), boxes };
+}
+
+// src/video/media/lv-rtmp-client.ts
+var import_node_net = __toESM(require("net"), 1);
+var import_node_events2 = require("events");
+var import_node_crypto6 = require("crypto");
+
+// src/video/media/amf0.ts
+var AMF0 = {
+  NUMBER: 0,
+  BOOLEAN: 1,
+  STRING: 2,
+  OBJECT: 3,
+  NULL: 5,
+  UNDEFINED: 6,
+  ECMA_ARRAY: 8,
+  OBJECT_END: 9,
+  STRICT_ARRAY: 10,
+  LONG_STRING: 12
+};
+function amfNumber(n) {
+  const b = Buffer.alloc(9);
+  b[0] = AMF0.NUMBER;
+  b.writeDoubleBE(n, 1);
+  return b;
+}
+function amfBoolean(v) {
+  return Buffer.from([AMF0.BOOLEAN, v ? 1 : 0]);
+}
+function amfString(s) {
+  const str2 = Buffer.from(s, "utf8");
+  const b = Buffer.alloc(3 + str2.length);
+  b[0] = AMF0.STRING;
+  b.writeUInt16BE(str2.length, 1);
+  str2.copy(b, 3);
+  return b;
+}
+function amfNull() {
+  return Buffer.from([AMF0.NULL]);
+}
+function amfNamed(key2, value) {
+  const k = Buffer.from(key2, "utf8");
+  const b = Buffer.alloc(2 + k.length);
+  b.writeUInt16BE(k.length, 0);
+  k.copy(b, 2);
+  return Buffer.concat([b, value]);
+}
+function amfObject(pairs) {
+  const parts = [Buffer.from([AMF0.OBJECT])];
+  for (const [k, v] of pairs) parts.push(amfNamed(k, v));
+  parts.push(Buffer.from([0, 0, AMF0.OBJECT_END]));
+  return Buffer.concat(parts);
+}
+function decodeOne(buf, pos) {
+  const type = buf[pos];
+  let p = pos + 1;
+  switch (type) {
+    case AMF0.NUMBER:
+      return { value: buf.readDoubleBE(p), next: p + 8 };
+    case AMF0.BOOLEAN:
+      return { value: buf[p] !== 0, next: p + 1 };
+    case AMF0.STRING: {
+      const len = buf.readUInt16BE(p);
+      return { value: buf.toString("utf8", p + 2, p + 2 + len), next: p + 2 + len };
+    }
+    case AMF0.LONG_STRING: {
+      const len = buf.readUInt32BE(p);
+      return { value: buf.toString("utf8", p + 4, p + 4 + len), next: p + 4 + len };
+    }
+    case AMF0.NULL:
+      return { value: null, next: p };
+    case AMF0.UNDEFINED:
+      return { value: void 0, next: p };
+    case AMF0.ECMA_ARRAY:
+    case AMF0.OBJECT: {
+      if (type === AMF0.ECMA_ARRAY) p += 4;
+      const obj = {};
+      for (; ; ) {
+        const klen = buf.readUInt16BE(p);
+        if (klen === 0 && buf[p + 2] === AMF0.OBJECT_END) return { value: obj, next: p + 3 };
+        const key2 = buf.toString("utf8", p + 2, p + 2 + klen);
+        const r = decodeOne(buf, p + 2 + klen);
+        obj[key2] = r.value;
+        p = r.next;
+      }
+    }
+    case AMF0.STRICT_ARRAY: {
+      const count = buf.readUInt32BE(p);
+      p += 4;
+      const arr = [];
+      for (let i = 0; i < count; i++) {
+        const r = decodeOne(buf, p);
+        arr.push(r.value);
+        p = r.next;
+      }
+      return { value: arr, next: p };
+    }
+    default:
+      throw new Error(`AMF0: unsupported type 0x${(type ?? -1).toString(16)} at ${pos}`);
+  }
+}
+function decodeAmf0(buf) {
+  const out = [];
+  let pos = 0;
+  while (pos < buf.length) {
+    const r = decodeOne(buf, pos);
+    out.push(r.value);
+    pos = r.next;
+  }
+  return out;
+}
+
+// src/video/media/chunk.ts
+var MSG = {
+  SET_CHUNK_SIZE: 1,
+  ABORT: 2,
+  ACK: 3,
+  USER_CONTROL: 4,
+  WINDOW_ACK_SIZE: 5,
+  SET_PEER_BW: 6,
+  AUDIO: 8,
+  VIDEO: 9,
+  DATA_AMF0: 18,
+  COMMAND_AMF0: 20
+};
+var PRIVATE_MODE_CHUNK_SIZE = 6e4;
+function basicHeader(fmt, csid) {
+  if (csid < 64) return Buffer.from([fmt << 6 | csid]);
+  if (csid < 320) return Buffer.from([fmt << 6, csid - 64]);
+  return Buffer.from([fmt << 6 | 1, csid - 64 & 255, csid - 64 >> 8]);
+}
+function encodeMessage(o) {
+  if (o.body.length > PRIVATE_MODE_CHUNK_SIZE) {
+    throw new Error(`message body ${o.body.length} exceeds private-mode chunk size ${PRIVATE_MODE_CHUNK_SIZE}`);
+  }
+  const ts = o.timestamp ?? 0;
+  const hdrLen = o.fmt === 0 ? 11 : 7;
+  const hdr = Buffer.alloc(hdrLen);
+  hdr.writeUIntBE(ts >= 16777215 ? 16777215 : ts, 0, 3);
+  hdr.writeUIntBE(o.body.length, 3, 3);
+  hdr[6] = o.type;
+  if (o.fmt === 0) hdr.writeUInt32LE(o.msid ?? 0, 7);
+  const ext = ts >= 16777215 ? (() => {
+    const e = Buffer.alloc(4);
+    e.writeUInt32BE(ts, 0);
+    return e;
+  })() : Buffer.alloc(0);
+  return Buffer.concat([basicHeader(o.fmt, o.csid), hdr, ext, o.body]);
+}
+function freshState() {
+  return { timestamp: 0, delta: 0, length: 0, type: 0, msid: 0, extTs: false, partial: [], received: 0 };
+}
+var ChunkReader = class {
+  chunkSize;
+  pending = Buffer.alloc(0);
+  streams = /* @__PURE__ */ new Map();
+  constructor(chunkSize = PRIVATE_MODE_CHUNK_SIZE) {
+    this.chunkSize = chunkSize;
+  }
+  feed(data) {
+    this.pending = this.pending.length ? Buffer.concat([this.pending, data]) : data;
+    const out = [];
+    for (; ; ) {
+      const consumed = this.tryReadChunk(out);
+      if (consumed === 0) break;
+      this.pending = this.pending.subarray(consumed);
+    }
+    return out;
+  }
+  /** Returns bytes consumed for one chunk, or 0 if more data is needed. */
+  tryReadChunk(out) {
+    const buf = this.pending;
+    if (buf.length < 1) return 0;
+    const fmt = buf[0] >> 6;
+    let csid = buf[0] & 63;
+    let p = 1;
+    if (csid === 0) {
+      if (buf.length < 2) return 0;
+      csid = 64 + buf[1];
+      p = 2;
+    } else if (csid === 1) {
+      if (buf.length < 3) return 0;
+      csid = 64 + buf[1] + buf[2] * 256;
+      p = 3;
+    }
+    const st = this.streams.get(csid) ?? freshState();
+    const hdrLen = fmt === 0 ? 11 : fmt === 1 ? 7 : fmt === 2 ? 3 : 0;
+    if (buf.length < p + hdrLen) return 0;
+    let tsField = 0;
+    if (fmt <= 2) {
+      tsField = buf.readUIntBE(p, 3);
+      if (fmt <= 1) {
+        st.length = buf.readUIntBE(p + 3, 3);
+        st.type = buf[p + 6];
+      }
+      if (fmt === 0) st.msid = buf.readUInt32LE(p + 7);
+      st.extTs = tsField === 16777215;
+    }
+    p += hdrLen;
+    if (st.extTs) {
+      if (buf.length < p + 4) return 0;
+      tsField = buf.readUInt32BE(p);
+      p += 4;
+    }
+    const startOfMessage = st.received === 0;
+    if (startOfMessage) {
+      if (fmt === 0) {
+        st.timestamp = tsField;
+        st.delta = 0;
+      } else if (fmt <= 2) {
+        st.delta = tsField;
+        st.timestamp += tsField;
+      } else st.timestamp += st.delta;
+    }
+    const take = Math.min(this.chunkSize, st.length - st.received);
+    if (buf.length < p + take) return 0;
+    st.partial.push(Buffer.from(buf.subarray(p, p + take)));
+    st.received += take;
+    if (st.received >= st.length) {
+      out.push({ csid, msid: st.msid, timestamp: st.timestamp, type: st.type, body: Buffer.concat(st.partial) });
+      st.partial = [];
+      st.received = 0;
+    }
+    this.streams.set(csid, st);
+    return p + take;
+  }
+};
+
+// src/video/media/flv.ts
+var ANNEXB_START = Buffer.from([0, 0, 0, 1]);
+function parseVideoTag(body) {
+  if (body.length < 5) return null;
+  const b0 = body[0];
+  return {
+    frameType: b0 >> 4,
+    codecId: b0 & 15,
+    avcPacketType: body[1],
+    compositionTime: body.readIntBE(2, 3),
+    data: body.subarray(5)
+  };
+}
+function parseAudioTag(body) {
+  if (body.length < 1) return null;
+  const b0 = body[0];
+  const soundFormat = b0 >> 4;
+  const isAac = soundFormat === 10;
+  if (isAac && body.length < 2) return null;
+  return {
+    soundFormat,
+    sampleRateIndex: b0 >> 2 & 3,
+    channels: (b0 & 1) + 1,
+    aacPacketType: isAac ? body[1] : null,
+    data: body.subarray(isAac ? 2 : 1)
+  };
+}
+function parseAvcConfig(rec) {
+  const nalLengthSize = (rec[4] & 3) + 1;
+  let p = 5;
+  const sps = [];
+  const pps = [];
+  const numSps = rec[p++] & 31;
+  for (let i = 0; i < numSps; i++) {
+    const n = rec.readUInt16BE(p);
+    sps.push(Buffer.from(rec.subarray(p + 2, p + 2 + n)));
+    p += 2 + n;
+  }
+  const numPps = rec[p++];
+  for (let i = 0; i < numPps; i++) {
+    const n = rec.readUInt16BE(p);
+    pps.push(Buffer.from(rec.subarray(p + 2, p + 2 + n)));
+    p += 2 + n;
+  }
+  return { sps, pps, nalLengthSize };
+}
+function avccToAnnexB(data, cfg, prependParams) {
+  const parts = [];
+  if (prependParams) for (const nal of [...cfg.sps, ...cfg.pps]) parts.push(ANNEXB_START, nal);
+  let p = 0;
+  while (p + cfg.nalLengthSize <= data.length) {
+    const len = data.readUIntBE(p, cfg.nalLengthSize);
+    p += cfg.nalLengthSize;
+    if (len === 0 || p + len > data.length) break;
+    parts.push(ANNEXB_START, data.subarray(p, p + len));
+    p += len;
+  }
+  return Buffer.concat(parts);
+}
+function parseAacConfig(asc) {
+  const a0 = asc[0];
+  const a1 = asc[1];
+  return {
+    objectType: a0 >> 3,
+    samplingFrequencyIndex: (a0 & 7) << 1 | a1 >> 7,
+    channelConfiguration: a1 >> 3 & 15
+  };
+}
+var AAC_SAMPLE_RATES = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+function aacSampleRate(cfg) {
+  return AAC_SAMPLE_RATES[cfg.samplingFrequencyIndex] ?? 0;
+}
+function aacToAdts(raw, cfg) {
+  const frameLen = raw.length + 7;
+  const h = Buffer.alloc(7);
+  h[0] = 255;
+  h[1] = 241;
+  h[2] = cfg.objectType - 1 << 6 | cfg.samplingFrequencyIndex << 2 | cfg.channelConfiguration >> 2;
+  h[3] = (cfg.channelConfiguration & 3) << 6 | frameLen >> 11 & 3;
+  h[4] = frameLen >> 3 & 255;
+  h[5] = (frameLen & 7) << 5 | 31;
+  h[6] = 252;
+  return Buffer.concat([h, raw]);
+}
+
+// src/video/media/lv-rtmp-client.ts
+var LV_STATUS = {
+  REQUEST_AUDIO_TYPE: "NetStream.RequestAudioType",
+  FORCE_IFRAME_START: "NetStream.ForceIFrame.Start",
+  PING_START: "NetStream.Ping.Start",
+  PING_RESPONSE: "NetStream.Ping.Response",
+  PRE_CONNECT: "NetStream.PreConnect",
+  KEEPALIVE: "NetStream.Keepalive",
+  SERVER_INFO: "NetStream.ServerInfo",
+  TRANSFER_DATA: "NetStream.TransferData",
+  PLAY_START: "NetStream.Play.Start",
+  /** Server signals the talk (intercom uplink) channel is ready. */
+  TALK_READY: "NetStream.TalkReady"
+};
+var TALK_AUDIO_HEADER_G711A = 114;
+var CONNECT_CAPABILITIES = 15;
+var CONNECT_AUDIO_CODECS = 3191;
+var CONNECT_VIDEO_CODECS = 252;
+var CONNECT_VIDEO_FUNCTION = 1;
+var PLAY_START_LIVE = -1e3;
+var HANDSHAKE_C0_PRIVATE = 4;
+var HANDSHAKE_S0S1_LEN = 1537;
+var DEFAULT_PING_INTERVAL_MS = 3e4;
+var DEFAULT_CACHE_DURATION_MS = 3e3;
+var ACK_THRESHOLD_BYTES = 25e4;
+var CSID_CONTROL = 2;
+var CSID_COMMAND = 3;
+var CSID_TALK = 4;
+var CSID_PLAY = 8;
+var PLAY_STREAM_ID = 1;
+function parseRelayUrl(url, cacheDurationMs) {
+  const m = /^rtmp:\/\/([^/:]+)(?::(\d+))?\/(.*)$/.exec(url);
+  if (!m) throw new Error(`not an rtmp:// url: ${url}`);
+  const host = m[1];
+  const port = m[2] ? Number(m[2]) : 1935;
+  const path = m[3];
+  const slash = path.lastIndexOf("/");
+  if (slash < 0) throw new Error(`relay url has no playpath: ${url}`);
+  let app = path.slice(0, slash);
+  const playpath = path.slice(slash + 1);
+  if (!/[?&]cacheDuration=/.test(app)) app += `${app.includes("?") ? "&" : "?"}cacheDuration=${cacheDurationMs}`;
+  return { host, port, app, playpath, tcUrl: `rtmp://${host}:${port}/${app}` };
+}
+var LvRtmpClient = class extends import_node_events2.EventEmitter {
+  opts;
+  endpoint;
+  socket = null;
+  handshakeBuf = Buffer.alloc(0);
+  handshakeDone = false;
+  c1Time = 0;
+  reader = new ChunkReader(PRIVATE_MODE_CHUNK_SIZE);
+  transactionId = 0;
+  bytesIn = 0;
+  bytesAcked = 0;
+  ackWindow = ACK_THRESHOLD_BYTES;
+  pingTimer = null;
+  firstMessageSeen = false;
+  avcConfig = null;
+  aacConfig = null;
+  closed = false;
+  constructor(options) {
+    super();
+    this.opts = {
+      url: options.url,
+      cacheDurationMs: options.cacheDurationMs ?? DEFAULT_CACHE_DURATION_MS,
+      requestAudioType: options.requestAudioType ?? true,
+      ping: options.ping ?? true,
+      pingIntervalMs: options.pingIntervalMs ?? DEFAULT_PING_INTERVAL_MS,
+      forceIFrameOnStart: options.forceIFrameOnStart ?? false,
+      connectTimeoutMs: options.connectTimeoutMs ?? 1e4,
+      log: options.log ?? (() => {
+      })
+    };
+    this.endpoint = parseRelayUrl(this.opts.url, this.opts.cacheDurationMs);
+  }
+  /** Open TCP, write C0+C1 and the pipelined connect/play/RequestAudioType. Resolves once written. */
+  connect() {
+    return new Promise((resolve, reject) => {
+      const sock = import_node_net.default.createConnection({ host: this.endpoint.host, port: this.endpoint.port });
+      this.socket = sock;
+      sock.setNoDelay(true);
+      sock.setTimeout(this.opts.connectTimeoutMs, () => {
+        if (!this.handshakeDone) this.fail(new Error("handshake timeout"));
+      });
+      sock.once("error", (err) => {
+        this.emit("error", err);
+        reject(err);
+      });
+      sock.on("data", (d) => this.onData(d));
+      sock.on("close", () => this.onClose());
+      sock.once("connect", () => {
+        this.opts.log(`tcp connected ${this.endpoint.host}:${this.endpoint.port}`);
+        sock.write(Buffer.concat([this.buildC0C1(), ...this.buildOpeningSequence()]));
+        this.emit("connected");
+        resolve();
+      });
+    });
+  }
+  close() {
+    this.closed = true;
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    this.pingTimer = null;
+    this.socket?.destroy();
+  }
+  /** onStatus encoder — byte-exact replica of liblvmedia IOT_RTMP_SendMessage (csid 3, fmt 1, ts 0). */
+  buildStatus(code, extra) {
+    const pairs = [
+      ["level", amfString("status")],
+      ["code", amfString(code)],
+      ["description", amfString("desc")]
+    ];
+    if (extra) pairs.push([extra[0], amfString(extra[1])]);
+    const body = Buffer.concat([amfString("onStatus"), amfNumber(++this.transactionId), amfNull(), amfObject(pairs)]);
+    return encodeMessage({ fmt: 1, csid: CSID_COMMAND, type: MSG.COMMAND_AMF0, body });
+  }
+  sendStatus(code, extra) {
+    this.write(this.buildStatus(code, extra));
+    this.opts.log(`>> onStatus ${code}${extra ? ` ${extra[0]}=${extra[1]}` : ""} (txn ${this.transactionId})`);
+  }
+  forceIFrame() {
+    this.sendStatus(LV_STATUS.FORCE_IFRAME_START);
+  }
+  // ---------------------------------------------------------------- outgoing
+  buildC0C1() {
+    this.c1Time = Math.floor(performance.now()) >>> 0;
+    const c1 = Buffer.alloc(1536);
+    c1.writeUInt32BE(this.c1Time, 0);
+    c1.writeUInt32BE(0, 4);
+    (0, import_node_crypto6.randomBytes)(1528).copy(c1, 8);
+    return Buffer.concat([Buffer.from([HANDSHAKE_C0_PRIVATE]), c1]);
+  }
+  buildConnect() {
+    const obj = amfObject([
+      ["app", amfString(this.endpoint.app)],
+      ["tcUrl", amfString(this.endpoint.tcUrl)],
+      ["fpad", amfBoolean(false)],
+      ["capabilities", amfNumber(CONNECT_CAPABILITIES)],
+      ["audioCodecs", amfNumber(CONNECT_AUDIO_CODECS)],
+      ["videoCodecs", amfNumber(CONNECT_VIDEO_CODECS)],
+      ["videoFunction", amfNumber(CONNECT_VIDEO_FUNCTION)]
+    ]);
+    const body = Buffer.concat([amfString("connect"), amfNumber(++this.transactionId), obj]);
+    return encodeMessage({ fmt: 0, csid: CSID_COMMAND, msid: 0, type: MSG.COMMAND_AMF0, body });
+  }
+  buildPlay() {
+    const body = Buffer.concat([
+      amfString("play"),
+      amfNumber(++this.transactionId),
+      amfNull(),
+      amfString(this.endpoint.playpath),
+      amfNumber(PLAY_START_LIVE)
+    ]);
+    return encodeMessage({ fmt: 0, csid: CSID_PLAY, msid: PLAY_STREAM_ID, type: MSG.COMMAND_AMF0, body });
+  }
+  /** Exposed for the byte-exact self-test against the pcap. */
+  buildOpeningSequence() {
+    const seq = [this.buildConnect(), this.buildPlay()];
+    if (this.opts.requestAudioType) seq.push(this.buildStatus(LV_STATUS.REQUEST_AUDIO_TYPE, ["audio_type", "1"]));
+    return seq;
+  }
+  /**
+   * Push one intercom (talk-back) audio frame UPSTREAM to the device — an RTMP
+   * type-8 audio message on the talk chunk stream (csid 4, msid 1), exactly as
+   * liblvmedia's `IOT_RTMP_SendAudio` does. `payload` is the raw codec audio
+   * (default framing = G.711 A-law); `tsMs` is a running millisecond timestamp.
+   * Only meaningful after the server sends {@link LV_STATUS.TALK_READY}.
+   */
+  sendAudioFrame(payload, tsMs, header = TALK_AUDIO_HEADER_G711A) {
+    const body = Buffer.concat([Buffer.from([header]), payload]);
+    this.write(
+      encodeMessage({ fmt: 0, csid: CSID_TALK, msid: PLAY_STREAM_ID, timestamp: tsMs >>> 0, type: MSG.AUDIO, body })
+    );
+  }
+  write(buf) {
+    if (!this.socket || this.socket.destroyed) return;
+    this.socket.write(buf);
+  }
+  sendAck() {
+    const b = Buffer.alloc(4);
+    b.writeUInt32BE(this.bytesIn >>> 0, 0);
+    this.write(encodeMessage({ fmt: 0, csid: CSID_CONTROL, msid: 0, type: MSG.ACK, body: b }));
+    this.bytesAcked = this.bytesIn;
+  }
+  sendPingResponse(serverTs) {
+    const body = Buffer.concat([Buffer.from([0, 7]), serverTs]);
+    this.write(encodeMessage({ fmt: 0, csid: CSID_CONTROL, msid: 0, type: MSG.USER_CONTROL, body }));
+  }
+  startPinging() {
+    if (!this.opts.ping || this.pingTimer) return;
+    this.sendStatus(LV_STATUS.PING_START);
+    this.pingTimer = setInterval(() => this.sendStatus(LV_STATUS.PING_START), this.opts.pingIntervalMs);
+  }
+  // ---------------------------------------------------------------- incoming
+  onData(data) {
+    this.bytesIn += data.length;
+    let payload = data;
+    if (!this.handshakeDone) {
+      this.handshakeBuf = Buffer.concat([this.handshakeBuf, data]);
+      if (this.handshakeBuf.length < HANDSHAKE_S0S1_LEN) return;
+      this.onHandshake(this.handshakeBuf.subarray(0, HANDSHAKE_S0S1_LEN));
+      payload = this.handshakeBuf.subarray(HANDSHAKE_S0S1_LEN);
+      this.handshakeBuf = Buffer.alloc(0);
+      this.handshakeDone = true;
+      if (payload.length === 0) return;
+    }
+    let messages;
+    try {
+      messages = this.reader.feed(payload);
+    } catch (err) {
+      this.fail(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    for (const m of messages) this.dispatch(m);
+    if (this.bytesIn - this.bytesAcked >= this.ackWindow) this.sendAck();
+  }
+  onHandshake(s0s1) {
+    const s0 = s0s1[0];
+    const serverTime = s0s1.readUInt32BE(1);
+    const zero = s0s1.readUInt32BE(5);
+    this.opts.log(`<< S0=0x${s0.toString(16)} S1.time=${serverTime} S1.zero=0x${zero.toString(16)} (client sent 0x04; app logs a mismatch but continues)`);
+  }
+  dispatch(m) {
+    if (!this.firstMessageSeen) {
+      this.firstMessageSeen = true;
+      this.startPinging();
+    }
+    switch (m.type) {
+      case MSG.SET_CHUNK_SIZE: {
+        const size = m.body.readUInt32BE(0) & 2147483647;
+        this.opts.log(`<< SetChunkSize ${size}`);
+        this.reader.chunkSize = size;
+        return;
+      }
+      case MSG.WINDOW_ACK_SIZE:
+        this.ackWindow = Math.min(ACK_THRESHOLD_BYTES, m.body.readUInt32BE(0));
+        this.opts.log(`<< WindowAckSize ${m.body.readUInt32BE(0)}`);
+        return;
+      case MSG.SET_PEER_BW:
+        this.opts.log(`<< SetPeerBandwidth ${m.body.readUInt32BE(0)} limit=${m.body[4]}`);
+        return;
+      case MSG.ACK:
+      case MSG.ABORT:
+        return;
+      case MSG.USER_CONTROL:
+        return this.onUserControl(m.body);
+      case MSG.COMMAND_AMF0:
+        return this.onCommand(m);
+      case MSG.DATA_AMF0:
+        return this.onDataMessage(m.body);
+      case MSG.AUDIO:
+        return this.onAudio(m);
+      case MSG.VIDEO:
+        return this.onVideo(m);
+      default:
+        this.opts.log(`<< unknown message type ${m.type} len=${m.body.length}`);
+    }
+  }
+  onUserControl(body) {
+    const event = body.readUInt16BE(0);
+    const names = { 0: "StreamBegin", 1: "StreamEOF", 2: "StreamDry", 4: "StreamIsRecorded", 6: "PingRequest", 7: "PingResponse" };
+    this.opts.log(`<< UserControl ${names[event] ?? event} ${body.subarray(2).toString("hex")}`);
+    if (event === 6) this.sendPingResponse(body.subarray(2, 6));
+  }
+  onCommand(m) {
+    let values;
+    try {
+      values = decodeAmf0(m.body);
+    } catch (err) {
+      this.opts.log(`<< undecodable command: ${m.body.toString("hex")}`);
+      return;
+    }
+    const [name, txn, , info] = values;
+    this.opts.log(`<< ${String(name)} ${JSON.stringify(values.slice(1))}`);
+    this.emit("command", String(name), values);
+    if (name === "onStatus" && info && typeof info === "object" && !Array.isArray(info)) {
+      const fields = info;
+      this.emit("status", {
+        code: String(fields.code ?? ""),
+        level: String(fields.level ?? ""),
+        description: String(fields.description ?? ""),
+        fields,
+        transactionId: typeof txn === "number" ? txn : 0
+      });
+      if (fields.code === LV_STATUS.PLAY_START && this.opts.forceIFrameOnStart) this.forceIFrame();
+    }
+  }
+  onDataMessage(body) {
+    try {
+      const values = decodeAmf0(body);
+      this.opts.log(`<< data ${JSON.stringify(values).slice(0, 300)}`);
+      const obj = values.find((v) => v && typeof v === "object" && !Array.isArray(v));
+      if (obj) this.emit("metadata", obj);
+    } catch {
+      this.opts.log(`<< undecodable data message len=${body.length}`);
+    }
+  }
+  onAudio(m) {
+    this.emit("audio", { timestamp: m.timestamp, body: m.body });
+    const tag = parseAudioTag(m.body);
+    if (!tag) return;
+    if (tag.soundFormat === 10) {
+      if (tag.aacPacketType === 0) {
+        this.aacConfig = parseAacConfig(tag.data);
+        this.emit("audioInfo", { codec: "aac", sampleRate: aacSampleRate(this.aacConfig), channels: this.aacConfig.channelConfiguration });
+        return;
+      }
+      if (this.aacConfig) this.emit("audioFrame", aacToAdts(tag.data, this.aacConfig));
+      return;
+    }
+    if (tag.soundFormat === 7 || tag.soundFormat === 8) {
+      if (!this.aacConfig) this.emit("audioInfo", { codec: tag.soundFormat === 7 ? "g711a" : "g711u", sampleRate: 8e3, channels: 1 });
+      this.emit("audioFrame", tag.data);
+      return;
+    }
+    this.emit("audioInfo", { codec: "unknown", sampleRate: 0, channels: tag.channels });
+  }
+  onVideo(m) {
+    this.emit("video", { timestamp: m.timestamp, body: m.body });
+    const tag = parseVideoTag(m.body);
+    if (!tag || tag.codecId !== 7) return;
+    if (tag.avcPacketType === 0) {
+      this.avcConfig = parseAvcConfig(tag.data);
+      return;
+    }
+    if (tag.avcPacketType !== 1 || !this.avcConfig) return;
+    const isKeyframe = tag.frameType === 1;
+    this.emit("videoAccessUnit", {
+      data: avccToAnnexB(tag.data, this.avcConfig, isKeyframe),
+      isKeyframe,
+      videoType: "H264",
+      microseconds: m.timestamp * 1e3,
+      time: m.timestamp + tag.compositionTime
+    });
+  }
+  fail(err) {
+    this.opts.log(`!! ${err.message}`);
+    this.emit("error", err);
+    this.close();
+  }
+  onClose() {
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    this.pingTimer = null;
+    if (!this.closed) this.opts.log("socket closed by peer");
+    this.closed = true;
+    this.emit("close");
+  }
+};
+
+// src/video/media/g711.ts
+var ALAW_SEG_END = [31, 63, 127, 255, 511, 1023, 2047, 4095];
+function pcm16ToALaw(sample) {
+  let s = sample;
+  let sign = ~s >> 8 & 128;
+  if (sign === 0) s = -s;
+  if (s > 32635) s = 32635;
+  let aval;
+  if (s >= 256) {
+    let seg = 7;
+    for (let i = 0; i < 8; i++) {
+      if (s <= ALAW_SEG_END[i]) {
+        seg = i;
+        break;
+      }
+    }
+    const mantissa = s >> seg + 3 & 15;
+    aval = seg << 4 | mantissa;
+  } else {
+    aval = s >> 4;
+  }
+  return (aval ^ sign ^ 85) & 255;
+}
+function pcm16leToALaw(pcm) {
+  const count = pcm.length >> 1;
+  const out = Buffer.allocUnsafe(count);
+  for (let i = 0; i < count; i++) {
+    out[i] = pcm16ToALaw(pcm.readInt16LE(i * 2));
+  }
+  return out;
+}
+
+// src/video/media/camera-stream.ts
+var DreameCameraStream = class extends TypedEmitter {
+  #controller;
+  #clientFactory;
+  #log;
+  #client = null;
+  #state = "idle";
+  #videoFrames = 0;
+  #audioFrames = 0;
+  #talkReady = false;
+  #talkWaiters = [];
+  #talkTs = 0;
+  constructor(input) {
+    super();
+    this.#controller = input.controller;
+    this.#log = input.log ?? (() => {
+    });
+    this.#clientFactory = input.clientFactory ?? ((url) => new LvRtmpClient({
+      url,
+      ...input.requestAudioType !== void 0 ? { requestAudioType: input.requestAudioType } : {},
+      ...input.ping !== void 0 ? { ping: input.ping } : {},
+      ...input.log ? { log: input.log } : {}
+    }));
+  }
+  /** True while frames are flowing. */
+  get isRunning() {
+    return this.#state === "running";
+  }
+  /**
+   * Cold-start the monitor, connect to the relay, and begin emitting frames.
+   * Resolves once connected. Throws (and cleans up) if the monitor or relay
+   * connection fails.
+   */
+  async start() {
+    if (this.#state !== "idle") {
+      throw new DreameError(`camera stream cannot start from state '${this.#state}'`);
+    }
+    this.#state = "starting";
+    try {
+      this.#log("[nodedreame:stream] starting");
+      const handle = await this.#controller.open();
+      const client = this.#clientFactory(handle.rtmpUrl);
+      this.#client = client;
+      client.on("videoAccessUnit", (e) => {
+        this.#videoFrames += 1;
+        if (this.#videoFrames === 1) this.#log("[nodedreame:stream] first video access unit");
+        this.emit("videoAccessUnit", e);
+      });
+      client.on("audioFrame", (buf) => {
+        this.#audioFrames += 1;
+        if (this.#audioFrames === 1) this.#log("[nodedreame:stream] first audio frame");
+        this.emit("audioFrame", buf);
+      });
+      client.on("audioInfo", (info) => {
+        this.#log(`[nodedreame:stream] audio ${info.codec} ${info.sampleRate}Hz x${info.channels}`);
+        this.emit("audioInfo", info);
+      });
+      client.on("status", (e) => {
+        if (e.code === LV_STATUS.TALK_READY) {
+          this.#log("[nodedreame:stream] talk channel ready");
+          this.#talkReady = true;
+          const waiters = this.#talkWaiters;
+          this.#talkWaiters = [];
+          for (const w of waiters) w();
+        }
+      });
+      client.on("error", (err) => {
+        this.#log(`[nodedreame:stream] rtmp error: ${err.message}`);
+        this.emit("error", err);
+      });
+      client.on("close", () => {
+        this.#log("[nodedreame:stream] upstream relay closed");
+        if (this.#state === "running") void this.stop();
+      });
+      await client.connect();
+      this.#state = "running";
+      this.#log("[nodedreame:stream] connected to relay");
+      this.emit("started", { rtmpUrl: handle.rtmpUrl });
+      return { rtmpUrl: handle.rtmpUrl };
+    } catch (err) {
+      this.#state = "idle";
+      await this.#safeTeardown();
+      throw err;
+    }
+  }
+  /** Close the relay connection and release the monitor. Idempotent. */
+  async stop() {
+    if (this.#state === "idle" || this.#state === "stopping") return;
+    this.#state = "stopping";
+    this.#log(`[nodedreame:stream] stopping (video=${this.#videoFrames} audio=${this.#audioFrames})`);
+    await this.#safeTeardown();
+    this.#state = "idle";
+    this.emit("stopped");
+  }
+  /**
+   * Open the two-way intercom: send the MIoT start, then resolve once the relay
+   * signals the talk channel is ready (so it's safe to {@link sendTalkPcm}).
+   * Rejects if not ready within `timeoutMs`.
+   */
+  async startTalk(opts) {
+    if (this.#state !== "running") throw new DreameError("stream is not running; start() first");
+    this.#log("[nodedreame:stream] intercom start");
+    await this.#controller.startIntercom(
+      opts?.needRecordSound !== void 0 || opts?.videoCall !== void 0 ? { ...opts.needRecordSound !== void 0 ? { needRecordSound: opts.needRecordSound } : {}, ...opts.videoCall ? { videoCall: true } : {} } : void 0
+    );
+    this.#talkTs = 0;
+    await this.whenTalkReady(opts?.timeoutMs ?? 5e3);
+  }
+  /** Resolve when the talk channel is ready (or reject on timeout). */
+  whenTalkReady(timeoutMs = 5e3) {
+    if (this.#talkReady) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new DreameError("timed out waiting for TalkReady")), timeoutMs);
+      timer.unref?.();
+      this.#talkWaiters.push(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+  /**
+   * Encode 16-bit LE mono PCM (8 kHz) to G.711 A-law and push it upstream.
+   * `tsMs` defaults to a running clock advanced by the frame duration.
+   */
+  sendTalkPcm(pcm16le, tsMs) {
+    const alaw = pcm16leToALaw(pcm16le);
+    this.sendTalkAlaw(alaw, tsMs);
+  }
+  /** Push raw A-law audio upstream (advancing the running talk clock). */
+  sendTalkAlaw(alaw, tsMs) {
+    if (!this.#client) throw new DreameError("stream is not running");
+    const ts = tsMs ?? this.#talkTs;
+    this.#client.sendAudioFrame(alaw, ts);
+    this.#talkTs = ts + Math.round(alaw.length / 8);
+  }
+  /** Close the two-way intercom (MIoT stop). */
+  async stopTalk() {
+    this.#talkReady = false;
+    this.#log("[nodedreame:stream] intercom stop");
+    await this.#controller.stopIntercom();
+  }
+  async #safeTeardown() {
+    this.#talkReady = false;
+    this.#talkWaiters = [];
+    try {
+      this.#client?.close();
+    } catch {
+    }
+    this.#client = null;
+    try {
+      await this.#controller.close();
+    } catch (err) {
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AI_FEATURE_BIT,
   AI_FEATURE_JSON_KEY,
+  ALIYUN_REGION_ID,
   AUTO_SWITCH_JSON_KEY,
   BaseDevice,
   ChargingStatus,
   CleaningMode,
+  DRIVE_DIRECTIONS,
   DefaultCapabilityResolver,
   DreameApiError,
   DreameAuthError,
+  DreameCameraController,
+  DreameCameraStream,
   DreameDeviceOfflineError,
   DreameError,
   DreameTransportError,
+  DreameVideoSession,
   LIBRARY_NAME,
+  LV_STATUS,
+  LvRtmpClient,
+  MONITOR_AIID,
+  MONITOR_PIID,
+  MONITOR_SIID,
+  MONITOR_VENDOR_TOKEN,
   MOWER_MODEL_CAPABILITIES,
   MOWER_TASK_SUBSTATES,
   MiotError,
@@ -6132,33 +8517,65 @@ function createClientDumper(client, options) {
   MowerStatus,
   MowerTaskStatus,
   Nodreame,
+  PET_SOUNDS,
   SuctionLevel,
+  TALK_AUDIO_HEADER_G711A,
   TaskStatus,
+  VACUUM_ACTIONS,
   VACUUM_CONSUMABLES,
   VACUUM_MODEL_CAPABILITIES,
+  VACUUM_MOVE,
+  VACUUM_SIID,
   VacuumCapabilityResolver,
   VacuumDevice,
   WaterVolume,
+  aacSampleRate,
+  aacToAdts,
+  avccToAnnexB,
   consumableSpec,
   createClientDumper,
   createDumper,
+  createIotSession,
   decodeAiFeature,
   decodeAutoSwitch,
   decodeAutoSwitchAll,
+  decodeWifiSignalMap,
   encodeAiFeatureWrite,
   encodeAutoSwitchWrite,
   extractMowerConsumableValues,
+  getAliyunAuthCode,
+  getDeviceVideoProfile,
   getMowerCapabilities,
   getVacuumCapabilities,
+  getVideoAccessToken,
+  getVideoFamilyId,
+  hashAccessCode,
+  isAuthRefusedError,
   isDreameConsumableKey,
+  listDevices,
+  loginByOauth,
+  makeMonitorSession,
   mowerConsumableIndex,
   mowerFaultSeverity,
+  parseAacConfig,
+  parseAvcConfig,
+  parseConnectivity,
   parseMowerConsumables,
   parseMowerHeartbeat,
   parseMowingProgress,
+  parseObstacleData,
+  parsePersonFollow,
+  parseRelayUrl,
+  pcm16ToALaw,
+  pcm16leToALaw,
+  remoteDriveValue,
   renderMowerSvg,
   renderVacuumPng,
+  renderWifiSignalPng,
   resolveCapabilities,
-  supportedAutoSwitchKeys
+  signApiGatewayRequest,
+  streamQuery,
+  supportedAutoSwitchKeys,
+  toVideoProfile
 });
 //# sourceMappingURL=index.cjs.map