@apocaliss92/nodelink-js 0.4.22 → 0.4.24

package/dist/{chunk-EZ7WNPLB.js → chunk-JYHK2ZSH.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-S2UTGNFN.js";
+} from "./chunk-AHY4L7JI.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -94,10 +94,12 @@ import {
   BC_CMD_ID_GET_REC_ENC_CFG,
   BC_CMD_ID_GET_SIREN_STATUS,
   BC_CMD_ID_GET_SLEEP_STATE,
+  BC_CMD_ID_GET_SNAPSHOT,
   BC_CMD_ID_GET_STREAM_INFO_LIST,
   BC_CMD_ID_GET_SUPPORT,
   BC_CMD_ID_GET_SYSTEM_GENERAL,
   BC_CMD_ID_GET_TIMELAPSE_CFG,
+  BC_CMD_ID_GET_UID,
   BC_CMD_ID_GET_VERSION_INFO,
   BC_CMD_ID_GET_VIDEO_INPUT,
   BC_CMD_ID_GET_WHITE_LED,
@@ -176,7 +178,7 @@ import {
   splitAnnexBToNalPayloads2,
   talkTraceLog,
   traceLog
-} from "./chunk-C57QV7IL.js";
+} from "./chunk-GVWJGQPT.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -8319,6 +8321,353 @@ function decideSleepInferenceTransition(input) {
   };
 }
 
+// src/reolink/baichuan/utils/privacyMask.ts
+var DEFAULT_SHELTER_CANVAS = {
+  width: 540,
+  height: 304
+};
+function decodeShelterCoord(value) {
+  const v = (value | 0) >>> 0;
+  return { pixel: v >>> 16, canvas: v & 65535 };
+}
+function encodeShelterCoord(pixel, canvas) {
+  const p = Math.min(65535, Math.max(0, Math.floor(pixel)));
+  const c = Math.min(65535, Math.max(0, Math.floor(canvas)));
+  return p * 65536 + c;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function decodeRect(raw, canvas, idKey) {
+  const xRaw = Number(raw["topLeftX"] ?? 0) | 0;
+  const yRaw = Number(raw["topLeftY"] ?? 0) | 0;
+  const wRaw = Number(raw["width"] ?? 0) | 0;
+  const hRaw = Number(raw["height"] ?? 0) | 0;
+  const xPixel = decodeShelterCoord(xRaw).pixel;
+  const yPixel = decodeShelterCoord(yRaw).pixel;
+  const wPixel = decodeShelterCoord(wRaw).pixel;
+  const hPixel = decodeShelterCoord(hRaw).pixel;
+  return {
+    id: Number(raw[idKey] ?? 0) | 0,
+    enable: Number(raw["enable"] ?? 0) === 1,
+    layer: Number(raw["layer"] ?? 0) | 0,
+    color: Number(raw["color"] ?? 0) | 0,
+    x: canvas.width > 0 ? xPixel / canvas.width : 0,
+    y: canvas.height > 0 ? yPixel / canvas.height : 0,
+    width: canvas.width > 0 ? wPixel / canvas.width : 0,
+    height: canvas.height > 0 ? hPixel / canvas.height : 0
+  };
+}
+function extractCanvasFromShelterXml(xml) {
+  const xMatch = xml.match(/<topLeftX>(\d+)<\/topLeftX>/g) ?? [];
+  const yMatch = xml.match(/<topLeftY>(\d+)<\/topLeftY>/g) ?? [];
+  let canvasX = 0;
+  let canvasY = 0;
+  for (const tag of xMatch) {
+    const v = Number(tag.replace(/<\/?topLeftX>/g, "")) | 0;
+    if (v > 0) {
+      canvasX = v & 65535;
+      break;
+    }
+  }
+  for (const tag of yMatch) {
+    const v = Number(tag.replace(/<\/?topLeftY>/g, "")) | 0;
+    if (v > 0) {
+      canvasY = v & 65535;
+      break;
+    }
+  }
+  return {
+    width: canvasX > 0 ? canvasX : DEFAULT_SHELTER_CANVAS.width,
+    height: canvasY > 0 ? canvasY : DEFAULT_SHELTER_CANVAS.height
+  };
+}
+function parseRectTags(block) {
+  const out = {};
+  const grab = (tag) => {
+    const m = block.match(new RegExp(`<${tag}>([^<]*)<\\/${tag}>`));
+    if (m && m[1] !== void 0) out[tag] = m[1];
+  };
+  grab("id");
+  grab("name");
+  grab("enable");
+  grab("layer");
+  grab("color");
+  grab("topLeftX");
+  grab("topLeftY");
+  grab("width");
+  grab("height");
+  grab("pPos");
+  grab("tPos");
+  grab("zPos");
+  return out;
+}
+function decodePrivacyMaskZones(xml) {
+  const canvas = extractCanvasFromShelterXml(xml);
+  const enable = Number(getXmlText(xml, "enable") ?? "0") === 1;
+  const trackEnable = Number(getXmlText(xml, "trackEnable") ?? "0") === 1;
+  const maxTrackShelterNum = Number(getXmlText(xml, "maxTrackShelterNum") ?? "0") | 0;
+  const rawMaxNum = getXmlText(xml, "maxNum");
+  const maxNum = rawMaxNum !== void 0 ? Number(rawMaxNum) | 0 : maxTrackShelterNum > 0 ? maxTrackShelterNum : 4;
+  const shelterList = [];
+  const shelterListBlock = xml.match(
+    /<shelterList>([\s\S]*?)<\/shelterList>/
+  )?.[1];
+  if (shelterListBlock) {
+    const blocks = shelterListBlock.matchAll(
+      /<Shelter>([\s\S]*?)<\/Shelter>/g
+    );
+    for (const m of blocks) {
+      const tags = parseRectTags(m[1] ?? "");
+      const decoded = decodeRect(tags, canvas, "id");
+      shelterList.push(decoded);
+    }
+  }
+  const trackShelterList = [];
+  const trackBlock = xml.match(
+    /<trackShelterList>([\s\S]*?)<\/trackShelterList>/
+  )?.[1];
+  if (trackBlock) {
+    const blocks = trackBlock.matchAll(
+      /<trackShelter>([\s\S]*?)<\/trackShelter>/g
+    );
+    for (const m of blocks) {
+      const tags = parseRectTags(m[1] ?? "");
+      const base = decodeRect(
+        tags,
+        canvas,
+        "name"
+      );
+      trackShelterList.push({
+        ...base,
+        pPos: Number(tags.pPos ?? -1) | 0,
+        tPos: Number(tags.tPos ?? -1) | 0,
+        zPos: Number(tags.zPos ?? -1) | 0
+      });
+    }
+  }
+  return {
+    enable,
+    maxNum,
+    shelterList,
+    trackEnable,
+    maxTrackShelterNum,
+    trackShelterList,
+    canvas
+  };
+}
+function denormalizeRect(rect, canvas) {
+  const xPx = Math.min(canvas.width, Math.round(clamp01(rect.x) * canvas.width));
+  const yPx = Math.min(canvas.height, Math.round(clamp01(rect.y) * canvas.height));
+  const wPx = Math.min(
+    canvas.width - xPx,
+    Math.round(clamp01(rect.width) * canvas.width)
+  );
+  const hPx = Math.min(
+    canvas.height - yPx,
+    Math.round(clamp01(rect.height) * canvas.height)
+  );
+  return {
+    topLeftX: encodeShelterCoord(xPx, canvas.width),
+    topLeftY: encodeShelterCoord(yPx, canvas.height),
+    width: encodeShelterCoord(wPx, canvas.width),
+    height: encodeShelterCoord(hPx, canvas.height)
+  };
+}
+function encodeShelterListXml(rects, canvas, maxNum) {
+  if (maxNum <= 0) return "<shelterList />";
+  const sorted = [...rects].sort((a, b) => a.id - b.id).slice(0, maxNum);
+  const byId = new Map(sorted.map((r) => [r.id, r]));
+  const parts = [];
+  parts.push("<shelterList>");
+  for (let id = 0; id < maxNum; id++) {
+    const r = byId.get(id);
+    if (r && r.enable) {
+      const { topLeftX, topLeftY, width, height } = denormalizeRect(r, canvas);
+      parts.push(
+        `<Shelter><id>${id}</id><enable>1</enable><layer>${r.layer | 0}</layer><color>${r.color | 0}</color><topLeftX>${topLeftX}</topLeftX><topLeftY>${topLeftY}</topLeftY><width>${width}</width><height>${height}</height></Shelter>`
+      );
+    } else if (r) {
+      const { topLeftX, topLeftY, width, height } = denormalizeRect(r, canvas);
+      parts.push(
+        `<Shelter><id>${id}</id><enable>0</enable><layer>${r.layer | 0}</layer><color>${r.color | 0}</color><topLeftX>${topLeftX}</topLeftX><topLeftY>${topLeftY}</topLeftY><width>${width}</width><height>${height}</height></Shelter>`
+      );
+    } else {
+      parts.push(
+        `<Shelter><id>${id}</id><enable>0</enable><layer>0</layer><color>0</color><topLeftX>0</topLeftX><topLeftY>0</topLeftY><width>0</width><height>0</height></Shelter>`
+      );
+    }
+  }
+  parts.push("</shelterList>");
+  return parts.join("");
+}
+function encodeTrackShelterListXml(rects, canvas, maxNum) {
+  if (maxNum <= 0) return "<trackShelterList />";
+  const sorted = [...rects].sort((a, b) => a.id - b.id).slice(0, maxNum);
+  const byId = new Map(sorted.map((r) => [r.id, r]));
+  const parts = [];
+  parts.push("<trackShelterList>");
+  for (let id = 0; id < maxNum; id++) {
+    const r = byId.get(id);
+    if (r) {
+      const { topLeftX, topLeftY, width, height } = denormalizeRect(r, canvas);
+      parts.push(
+        `<trackShelter><name>${id}</name><enable>${r.enable ? 1 : 0}</enable><layer>${r.layer | 0}</layer><color>${r.color | 0}</color><topLeftX>${topLeftX}</topLeftX><topLeftY>${topLeftY}</topLeftY><width>${width}</width><height>${height}</height><pPos>${r.pPos | 0}</pPos><tPos>${r.tPos | 0}</tPos><zPos>${r.zPos | 0}</zPos></trackShelter>`
+      );
+    } else {
+      parts.push(
+        `<trackShelter><name>${id}</name><enable>0</enable><layer>0</layer><color>0</color><topLeftX>0</topLeftX><topLeftY>0</topLeftY><width>0</width><height>0</height><pPos>-1</pPos><tPos>-1</tPos><zPos>-1</zPos></trackShelter>`
+      );
+    }
+  }
+  parts.push("</trackShelterList>");
+  return parts.join("");
+}
+function patchShelterXml(shelterXml, patch, canvas, maxNum, maxTrackShelterNum) {
+  let out = shelterXml;
+  if (patch.enable !== void 0) {
+    out = out.replace(
+      /<enable>[^<]*<\/enable>/,
+      `<enable>${patch.enable ? 1 : 0}</enable>`
+    );
+  }
+  if (patch.shelterList !== void 0) {
+    const fragment = encodeShelterListXml(patch.shelterList, canvas, maxNum);
+    out = out.replace(/<shelterList[\s\S]*?(?:\/>|<\/shelterList>)/, fragment);
+  }
+  if (patch.trackEnable !== void 0) {
+    out = out.replace(
+      /<trackEnable>[^<]*<\/trackEnable>/,
+      `<trackEnable>${patch.trackEnable ? 1 : 0}</trackEnable>`
+    );
+  }
+  if (patch.trackShelterList !== void 0) {
+    const fragment = encodeTrackShelterListXml(
+      patch.trackShelterList,
+      canvas,
+      maxTrackShelterNum
+    );
+    out = out.replace(
+      /<trackShelterList[\s\S]*?(?:\/>|<\/trackShelterList>)/,
+      fragment
+    );
+  }
+  return out;
+}
+
+// src/reolink/baichuan/utils/aiDetectCfg.ts
+function decodeAiDetectCfg(xml) {
+  const type = getXmlText(xml, "type");
+  if (type == null) throw new Error("AiDetectCfg: missing <type>");
+  return {
+    chn: Number(getXmlText(xml, "chn") ?? "0") | 0,
+    type,
+    sensitivity: Number(getXmlText(xml, "sensitivity") ?? "0") | 0,
+    stayTime: Number(getXmlText(xml, "stayTime") ?? "0") | 0,
+    minTargetWidth: Number(getXmlText(xml, "minTargetWidth") ?? "0"),
+    minTargetHeight: Number(getXmlText(xml, "minTargetHeight") ?? "0"),
+    maxTargetWidth: Number(getXmlText(xml, "maxTargetWidth") ?? "0"),
+    maxTargetHeight: Number(getXmlText(xml, "maxTargetHeight") ?? "0"),
+    width: Number(getXmlText(xml, "width") ?? "0") | 0,
+    height: Number(getXmlText(xml, "height") ?? "0") | 0,
+    area: getXmlText(xml, "area") ?? ""
+  };
+}
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function fmtFraction(value) {
+  const v = clamp012(value);
+  const e = v.toExponential(6);
+  return e.replace(/e([+-])(\d)$/, "e$10$2");
+}
+function patchAiDetectCfgXml(currentXml, patch) {
+  let out = currentXml;
+  if (patch.sensitivity !== void 0) {
+    out = out.replace(
+      /<sensitivity>[^<]*<\/sensitivity>/,
+      `<sensitivity>${patch.sensitivity | 0}</sensitivity>`
+    );
+  }
+  if (patch.stayTime !== void 0) {
+    out = out.replace(
+      /<stayTime>[^<]*<\/stayTime>/,
+      `<stayTime>${patch.stayTime | 0}</stayTime>`
+    );
+  }
+  if (patch.minTargetWidth !== void 0) {
+    out = out.replace(
+      /<minTargetWidth>[^<]*<\/minTargetWidth>/,
+      `<minTargetWidth>${fmtFraction(patch.minTargetWidth)}</minTargetWidth>`
+    );
+  }
+  if (patch.minTargetHeight !== void 0) {
+    out = out.replace(
+      /<minTargetHeight>[^<]*<\/minTargetHeight>/,
+      `<minTargetHeight>${fmtFraction(patch.minTargetHeight)}</minTargetHeight>`
+    );
+  }
+  if (patch.maxTargetWidth !== void 0) {
+    out = out.replace(
+      /<maxTargetWidth>[^<]*<\/maxTargetWidth>/,
+      `<maxTargetWidth>${fmtFraction(patch.maxTargetWidth)}</maxTargetWidth>`
+    );
+  }
+  if (patch.maxTargetHeight !== void 0) {
+    out = out.replace(
+      /<maxTargetHeight>[^<]*<\/maxTargetHeight>/,
+      `<maxTargetHeight>${fmtFraction(patch.maxTargetHeight)}</maxTargetHeight>`
+    );
+  }
+  if (patch.area !== void 0) {
+    out = out.replace(
+      /<area>[^<]*<\/area>/,
+      `<area>${patch.area}</area>`
+    );
+  }
+  return out;
+}
+
+// src/reolink/baichuan/utils/motionSensitivity.ts
+function clampInt(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function clampSensitivity(value) {
+  return clampInt(value, 0, 50);
+}
+function clampHour(value) {
+  return clampInt(value, 0, 23);
+}
+function clampMinute(value) {
+  return clampInt(value, 0, 59);
+}
+function encodeMotionSensitivityListXml(bands) {
+  if (bands.length === 0) return "<sensitivityInfoList />";
+  const sorted = [...bands].sort((a, b) => a.id - b.id);
+  const parts = ["<sensitivityInfoList>"];
+  for (const b of sorted) {
+    parts.push(
+      `<sensitivityInfo><id>${b.id | 0}</id><sensitivity>${clampSensitivity(b.sensitivity)}</sensitivity><beginHour>${clampHour(b.beginHour)}</beginHour><beginMinute>${clampMinute(b.beginMinute)}</beginMinute><endHour>${clampHour(b.endHour)}</endHour><endMinute>${clampMinute(b.endMinute)}</endMinute></sensitivityInfo>`
+    );
+  }
+  parts.push("</sensitivityInfoList>");
+  return parts.join("");
+}
+function patchMotionSensitivityListXml(currentXml, bands) {
+  const fragment = encodeMotionSensitivityListXml(bands);
+  return currentXml.replace(
+    /<sensitivityInfoList[\s\S]*?(?:\/>|<\/sensitivityInfoList>)/,
+    fragment
+  );
+}
+
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 import { spawn as spawn2 } from "child_process";
 import { mkdir } from "fs/promises";
@@ -8819,15 +9168,14 @@ var getAiStateViaGetAiAlarm = async (params) => {
       0
     );
   };
+  const isSupportedResponse = (xml) => {
+    return /<AiDetectCfg[\s>]/i.test(xml) && getXmlText(xml, "type") != null;
+  };
   for (const type of candidateTypes) {
     try {
       const xml = await tryOnce(type, ch);
-      if (xml) {
-        return {
-          channel: ch,
-          alarm_state: Number(getXmlText(xml, "alarm_state") ?? "0"),
-          support: Number(getXmlText(xml, "support") ?? "0")
-        };
+      if (xml && isSupportedResponse(xml)) {
+        return { channel: ch, alarm_state: 0, support: 1 };
       }
     } catch (e) {
       if (looksLikeConnectionDrop(e)) throw e;
@@ -8837,12 +9185,8 @@ var getAiStateViaGetAiAlarm = async (params) => {
   for (const type of candidateTypes) {
     try {
       const xml = await tryOnce(type, void 0);
-      if (xml) {
-        return {
-          channel: ch,
-          alarm_state: Number(getXmlText(xml, "alarm_state") ?? "0"),
-          support: Number(getXmlText(xml, "support") ?? "0")
-        };
+      if (xml && isSupportedResponse(xml)) {
+        return { channel: ch, alarm_state: 0, support: 1 };
       }
     } catch (e) {
       if (looksLikeConnectionDrop(e)) throw e;
@@ -12924,7 +13268,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       return;
     }
     entry.startInFlight = (async () => {
-      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-HGPU2MZ3.js");
+      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-NTIGPHYJ.js");
       const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
       const dedicated = await this.createDedicatedSession(sessionKey);
       const stream = new BaichuanVideoStream2({
@@ -14625,7 +14969,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Note: Snapshot uses a special message ID system for binary responses
    */
   async getSnapshot(channel, options) {
-    const cmdId = 109;
+    const cmdId = BC_CMD_ID_GET_SNAPSHOT;
     if (channel === void 0) {
       const composite = options?.compositeOptions;
       const widerChannel = composite?.widerChannel ?? 0;
@@ -18228,6 +18572,12 @@ ${stderr}`)
         `<valueTable>${opts.valueTable}</valueTable>`
       );
     }
+    if (opts.sensitivitySchedule !== void 0) {
+      modifiedXml = patchMotionSensitivityListXml(
+        modifiedXml,
+        opts.sensitivitySchedule
+      );
+    }
     await this.sendXml({
       cmdId: BC_CMD_ID_SET_MOTION_ALARM,
       channel: ch,
@@ -18275,6 +18625,72 @@ ${stderr}`)
       payloadXml: modifiedXml
     });
   }
+  /**
+   * SetAiDetectionFull (cmd_id=343 — same as `setAiDetection`).
+   *
+   * Pcap-confirmed (May 2026, E1 Zoom): the Reolink app sends the full
+   * `<AiDetectCfg>` block via cmd_id=343 for ALL fields — area mask,
+   * min/maxTarget* thresholds, sensitivity, stayTime — in one round-trip.
+   * There's no separate "full setter" command (we previously suspected
+   * cmd_id=345 but that's used for something else not yet identified).
+   *
+   * Wire format note: min/maxTarget* fractions are serialized in
+   * scientific notation with 6 decimal places (e.g. "5.000000e-01" for
+   * 0.5). The helper {@link patchAiDetectCfgXml} handles the formatting.
+   *
+   * @param channel 0-based channel
+   * @param aiType one of "people" / "vehicle" / "dog_cat" / "face" / "package"
+   * @param patch partial edit; any omitted field is preserved as-is
+   */
+  async setAiDetectionFull(channel, aiType, patch) {
+    const ch = this.normalizeChannel(channel);
+    const resolvedAiType = await this.resolveAiTypeForSetAiDetection(
+      ch,
+      aiType
+    );
+    const getXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<AiDetectCfg version="1.1">
+<chn>${ch}</chn>
+<type>${xmlEscape(resolvedAiType)}</type>
+</AiDetectCfg>
+</body>`;
+    const currentXml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_AI_ALARM,
+      channel: ch,
+      payloadXml: getXml
+    });
+    const patchedXml = patchAiDetectCfgXml(currentXml, patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_AI_ALARM,
+      channel: ch,
+      payloadXml: patchedXml
+    });
+  }
+  /**
+   * GetAiDetectionFull (cmd_id=342). Typed version of `getAiAlarmRaw`
+   * returning the full {@link AiDetectCfgZone} for a single AI type.
+   */
+  async getAiDetectionFull(channel, aiType) {
+    const ch = this.normalizeChannel(channel);
+    const resolvedAiType = await this.resolveAiTypeForSetAiDetection(
+      ch,
+      aiType
+    );
+    const getXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<AiDetectCfg version="1.1">
+<chn>${ch}</chn>
+<type>${xmlEscape(resolvedAiType)}</type>
+</AiDetectCfg>
+</body>`;
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_AI_ALARM,
+      channel: ch,
+      payloadXml: getXml
+    });
+    return decodeAiDetectCfg(xml);
+  }
   // --------------------
   // Siren/Audio Alarm APIs
   // --------------------
@@ -19517,7 +19933,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-HO3VI6D5.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-ILDDJZL7.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -19533,7 +19949,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-HO3VI6D5.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-ILDDJZL7.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -19855,6 +20271,69 @@ ${xml}`
       ...timeoutOpts
     });
   }
+  /**
+   * GetMaskZones (cmdId=52) returning a typed structure with normalized
+   * 0..1 rectangles instead of the raw camera fixed-point integers.
+   *
+   * The camera-side coord system is `(pixel << 16) | canvas_dim` where
+   * `canvas_dim` is the firmware-specific mask canvas (E1 Zoom = 540×304).
+   * The returned `canvas` block remembers those dims so callers can
+   * round-trip without re-fetching.
+   *
+   * @see decodePrivacyMaskZones — pure helper exported for UI consumers.
+   */
+  async getMaskZones(channel, options) {
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_PRIVACY_MASK,
+      ...channel != null ? { channel } : {},
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return decodePrivacyMaskZones(xml);
+  }
+  /**
+   * SetMaskZones (cmdId=53, read-modify-write of cmdId=52).
+   *
+   * Edits the rectangular shelter list and/or PTZ-tracking shelter list
+   * in one call. Coordinates are normalized 0..1 of the camera mask
+   * canvas — the lib re-fetches the current Shelter block, extracts the
+   * canvas dims from the wire (low-16 of any non-zero coord), and
+   * denormalizes back to the camera's pixel × canvas encoding.
+   *
+   * Pass `enable`/`trackEnable` to toggle the master enable flags without
+   * touching the rectangle data. Pass `shelterList`/`trackShelterList` to
+   * replace the corresponding list — missing slots are padded with
+   * disabled zero-rects matching the camera's idle pattern.
+   *
+   * @param channel 0-based channel
+   * @param patch partial edit; any omitted field is preserved as-is
+   * @param options.canvas override the auto-detected mask canvas (only
+   *   needed when the GET response has no non-zero coords to extract from)
+   * @param options.timeoutMs custom request timeout
+   */
+  async setMaskZones(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    const currentXml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_PRIVACY_MASK,
+      channel: ch,
+      ...timeoutOpts
+    });
+    const current = decodePrivacyMaskZones(currentXml);
+    const canvas = options?.canvas ?? current.canvas;
+    const patchedXml = patchShelterXml(
+      currentXml,
+      patch,
+      canvas,
+      current.maxNum,
+      current.maxTrackShelterNum
+    );
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_PRIVACY_MASK,
+      channel: ch,
+      payloadXml: ensureXmlHeader(patchedXml),
+      ...timeoutOpts
+    });
+  }
   /**
    * GetAudioNoise via Baichuan (cmdId=439). Reads `enable` + `level`
    * from the aiDenoise block. Mirrors reolink_aio's `GetAudioNoise`.
@@ -20541,6 +21020,18 @@ ${xml}`
     });
     return parseVersionInfo(xml);
   }
+  /**
+   * GetUid (cmd_id=114). Returns the device UID / serial visible in the
+   * Reolink app. Response shape: `<Uid><uid>9527000XXXXX</uid></Uid>`.
+   * Device-global — no channel parameter.
+   */
+  async getUid(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_UID,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return (getXmlText(xml, "uid") ?? "").trim();
+  }
   async getLedState(channel, options) {
     const rawXml = await this.sendPcapDerivedSettingsGetXml({
       cmdId: BC_CMD_ID_GET_LED_STATE,
@@ -23985,6 +24476,18 @@ export {
   computeDeviceCapabilities,
   xmlIndicatesFloodlight,
   decideSleepInferenceTransition,
+  DEFAULT_SHELTER_CANVAS,
+  decodeShelterCoord,
+  encodeShelterCoord,
+  extractCanvasFromShelterXml,
+  decodePrivacyMaskZones,
+  encodeShelterListXml,
+  encodeTrackShelterListXml,
+  patchShelterXml,
+  decodeAiDetectCfg,
+  patchAiDetectCfgXml,
+  encodeMotionSensitivityListXml,
+  patchMotionSensitivityListXml,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -24006,4 +24509,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-EZ7WNPLB.js.map
+//# sourceMappingURL=chunk-JYHK2ZSH.js.map