@apocaliss92/nodelink-js 0.4.11 → 0.4.13

package/dist/{chunk-HGQ53FB3.js → chunk-R5AJV73A.js}

@@ -1,3 +1,36 @@
+import {
+  ReolinkCgiApi,
+  ReolinkHttpClient,
+  applyStreamPatch,
+  applyXmlTagPatch,
+  buildAbilityInfoExtensionXml,
+  buildBinaryExtensionXml,
+  buildChannelExtensionXml,
+  buildFloodlightManualXml,
+  buildLoginXml,
+  buildLogoutXml,
+  buildPreviewStopXml,
+  buildPreviewStopXmlV11,
+  buildPreviewXml,
+  buildPreviewXmlV11,
+  buildPtzControlXml,
+  buildPtzPresetXml,
+  buildPtzPresetXmlV2,
+  buildRtspUrl,
+  buildSirenManualXml,
+  buildSirenTimesXml,
+  buildStartZoomFocusXml,
+  collectNvrDiagnostics,
+  ensureXmlHeader,
+  getXmlText,
+  normalizeDayNightMode,
+  normalizeOpenClose,
+  parseRecordingFileName,
+  patchNestedTag,
+  runAllDiagnosticsConsecutively,
+  runMultifocalDiagnosticsConsecutively,
+  xmlEscape
+} from "./chunk-2JNXKT3C.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -32,6 +65,7 @@ import {
   BC_CMD_ID_GET_AUDIO_CFG,
   BC_CMD_ID_GET_AUDIO_TASK,
   BC_CMD_ID_GET_AUTO_FOCUS,
+  BC_CMD_ID_GET_AUTO_REBOOT,
   BC_CMD_ID_GET_BATTERY_INFO,
   BC_CMD_ID_GET_BATTERY_INFO_LIST,
   BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
@@ -39,6 +73,8 @@ import {
   BC_CMD_ID_GET_DING_DONG_CFG,
   BC_CMD_ID_GET_DING_DONG_LIST,
   BC_CMD_ID_GET_DING_DONG_SILENT,
+  BC_CMD_ID_GET_DST,
+  BC_CMD_ID_GET_EMAIL,
   BC_CMD_ID_GET_EMAIL_TASK,
   BC_CMD_ID_GET_ENC,
   BC_CMD_ID_GET_FTP_TASK,
@@ -46,6 +82,7 @@ import {
   BC_CMD_ID_GET_KIT_AP_CFG,
   BC_CMD_ID_GET_LED_STATE,
   BC_CMD_ID_GET_MOTION_ALARM,
+  BC_CMD_ID_GET_NTP,
   BC_CMD_ID_GET_ONLINE_USER_LIST,
   BC_CMD_ID_GET_OSD_DATETIME,
   BC_CMD_ID_GET_PIR_INFO,
@@ -61,6 +98,7 @@ import {
   BC_CMD_ID_GET_SUPPORT,
   BC_CMD_ID_GET_SYSTEM_GENERAL,
   BC_CMD_ID_GET_TIMELAPSE_CFG,
+  BC_CMD_ID_GET_VERSION_INFO,
   BC_CMD_ID_GET_VIDEO_INPUT,
   BC_CMD_ID_GET_WHITE_LED,
   BC_CMD_ID_GET_WIFI,
@@ -83,14 +121,21 @@ import {
   BC_CMD_ID_SET_AUDIO_CFG,
   BC_CMD_ID_SET_AUDIO_TASK,
   BC_CMD_ID_SET_AUTO_FOCUS,
+  BC_CMD_ID_SET_AUTO_REBOOT,
   BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD,
   BC_CMD_ID_SET_DING_DONG_CFG,
   BC_CMD_ID_SET_DING_DONG_SILENT,
+  BC_CMD_ID_SET_DST,
+  BC_CMD_ID_SET_EMAIL,
+  BC_CMD_ID_SET_EMAIL_TASK,
   BC_CMD_ID_SET_ENC,
   BC_CMD_ID_SET_LED_STATE,
   BC_CMD_ID_SET_MOTION_ALARM,
+  BC_CMD_ID_SET_NTP,
+  BC_CMD_ID_SET_OSD_DATETIME,
   BC_CMD_ID_SET_PIR_INFO,
   BC_CMD_ID_SET_PRIVACY_MASK,
+  BC_CMD_ID_SET_SYSTEM_GENERAL,
   BC_CMD_ID_SET_VIDEO_INPUT,
   BC_CMD_ID_SET_WHITE_LED_STATE,
   BC_CMD_ID_SET_WHITE_LED_TASK,
@@ -100,6 +145,7 @@ import {
   BC_CMD_ID_TALK_ABILITY,
   BC_CMD_ID_TALK_CONFIG,
   BC_CMD_ID_TALK_RESET,
+  BC_CMD_ID_TEST_EMAIL,
   BC_CMD_ID_UDP_KEEP_ALIVE,
   BC_CMD_ID_VIDEO,
   BC_CMD_ID_VIDEO_STOP,
@@ -108,60 +154,29 @@ import {
   BC_TCP_DEFAULT_PORT,
   BaichuanVideoStream,
   BcMediaAnnexBDecoder,
-  ReolinkCgiApi,
-  ReolinkHttpClient,
   __require,
   aesDecrypt,
   aesEncrypt,
-  applyStreamPatch,
-  applyXmlTagPatch,
   bcDecrypt,
   bcEncrypt,
   bcHeaderHasPayloadOffset,
-  buildAbilityInfoExtensionXml,
-  buildBinaryExtensionXml,
-  buildChannelExtensionXml,
-  buildFloodlightManualXml,
-  buildLoginXml,
-  buildLogoutXml,
-  buildPreviewStopXml,
-  buildPreviewStopXmlV11,
-  buildPreviewXml,
-  buildPreviewXmlV11,
-  buildPtzControlXml,
-  buildPtzPresetXml,
-  buildPtzPresetXmlV2,
-  buildRtspUrl,
-  buildSirenManualXml,
-  buildSirenTimesXml,
-  buildStartZoomFocusXml,
-  collectNvrDiagnostics,
   convertToAnnexB,
   convertToAnnexB2,
   debugLog,
   deriveAesKey,
-  ensureXmlHeader,
   eventTraceLog,
   extractPpsFromAnnexB,
   extractSpsFromAnnexB,
   extractVpsFromAnnexB,
-  getXmlText,
   isH265Irap,
   md5StrModern,
-  normalizeDayNightMode,
   normalizeDebugOptions,
-  normalizeOpenClose,
-  parseRecordingFileName,
-  patchNestedTag,
   recordingsTraceLog,
-  runAllDiagnosticsConsecutively,
-  runMultifocalDiagnosticsConsecutively,
   splitAnnexBToNalPayloads,
   splitAnnexBToNalPayloads2,
   talkTraceLog,
-  traceLog,
-  xmlEscape
-} from "./chunk-EDLMKBG2.js";
+  traceLog
+} from "./chunk-C57QV7IL.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -1870,6 +1885,23 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    *   even if the current client instance is idle/disconnected.
    */
   static streamingRegistry = /* @__PURE__ */ new Map();
+  /**
+   * Per-device set of live BaichuanClient instances.
+   *
+   * Why: when a streaming client unsubscribes (e.g. RTSP grace timer expires
+   * and SocketPool tears the streaming socket down), the global streaming
+   * registry decrements but the GENERAL client of the same device has no
+   * way of knowing — its idle-disconnect timer was last evaluated while
+   * `isDeviceStreamingActive()` was still true (because the streaming socket
+   * was still alive) and wasn't rescheduled. Without this registry the
+   * general socket stays connected, the 60-second session-guard timer keeps
+   * sending getOnlineUserList() to the camera, and a battery camera ends up
+   * waking up every minute (issue #18).
+   *
+   * On streamingRegistry decrement-to-zero we walk this set and kick every
+   * sibling's idle-disconnect timer so it can re-evaluate eligibility.
+   */
+  static deviceClients = /* @__PURE__ */ new Map();
   /**
    * Per-host D2C_DISC backoff state that persists across client instance recreation.
    *
@@ -1984,6 +2016,29 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   // AlarmEventList (cmdId=33) can be very chatty (often sent every second).
   // Track last per-channel alarm state so we only emit on transitions.
   alarmEventState = /* @__PURE__ */ new Map();
+  /** Whether this instance is currently in BaichuanClient.deviceClients. */
+  registeredInDeviceClients = false;
+  registerInDeviceClients() {
+    if (this.registeredInDeviceClients) return;
+    const key = this.getDeviceRegistryKey();
+    let set = _BaichuanClient.deviceClients.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      _BaichuanClient.deviceClients.set(key, set);
+    }
+    set.add(this);
+    this.registeredInDeviceClients = true;
+  }
+  unregisterFromDeviceClients() {
+    if (!this.registeredInDeviceClients) return;
+    const key = this.getDeviceRegistryKey();
+    const set = _BaichuanClient.deviceClients.get(key);
+    if (set) {
+      set.delete(this);
+      if (set.size === 0) _BaichuanClient.deviceClients.delete(key);
+    }
+    this.registeredInDeviceClients = false;
+  }
   constructor(options) {
     super();
     this.opts = options;
@@ -1998,6 +2053,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         code: err?.code
       });
     });
+    this.registerInDeviceClients();
   }
   newSocketSessionId(transport) {
     const short = randomUUID().split("-")[0] ?? randomUUID().slice(0, 8);
@@ -2254,6 +2310,18 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         activeStreamClients: nextCount
       });
     this.contributesToGlobalStreamingRegistry = shouldContribute;
+    if (!shouldContribute && nextCount === 0) {
+      const siblings = _BaichuanClient.deviceClients.get(key);
+      if (siblings) {
+        for (const sib of siblings) {
+          if (sib === this) continue;
+          try {
+            sib.kickIdleDisconnectTimer();
+          } catch {
+          }
+        }
+      }
+    }
   }
   /**
    * True if the device should be considered "awake" due to active streaming.
@@ -2718,6 +2786,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       `transport=tcp host=${this.opts.host} port=${port}${sid ? ` sid=${sid}` : ""}${remote ? ` remote=${remote}` : ""}${peer ? ` peer=${peer}` : ""}`
     );
     this.logSocketState("tcp_connected");
+    this.registerInDeviceClients();
     this.startKeepAlive();
     this.kickIdleDisconnectTimer();
   }
@@ -3034,6 +3103,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         this.logDebug("udp_close_error", e);
       }
     }
+    this.unregisterFromDeviceClients();
   }
   handleFrame(frame) {
     const now = Date.now();
@@ -8275,6 +8345,304 @@ function parseXmlFragmentToJson(xml) {
   return parsed.root;
 }
 
+// src/reolink/baichuan/utils/email.ts
+var parseInt01 = (text) => {
+  if (text === void 0) return void 0;
+  return text.trim() === "1" ? 1 : 0;
+};
+var parseNumberSafe = (text) => {
+  if (text === void 0) return void 0;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : void 0;
+};
+var VALID_ATTACHMENT_TYPES = [
+  "picture",
+  "video",
+  "none"
+];
+var VALID_TEXT_TYPES = ["withText", "noText"];
+var normalizeAttachmentType = (text) => {
+  const t = (text ?? "").trim();
+  return VALID_ATTACHMENT_TYPES.includes(t) ? t : "picture";
+};
+var normalizeTextType = (text) => {
+  const t = (text ?? "").trim();
+  return VALID_TEXT_TYPES.includes(t) ? t : "withText";
+};
+function parseEmailConfigFromXml(xml) {
+  const cfg = {
+    smtpServer: getXmlText(xml, "smtpServer") ?? "",
+    userName: getXmlText(xml, "userName") ?? "",
+    password: getXmlText(xml, "password") ?? "",
+    address1: getXmlText(xml, "address1") ?? "",
+    address2: getXmlText(xml, "address2") ?? "",
+    address3: getXmlText(xml, "address3") ?? "",
+    smtpPort: parseNumberSafe(getXmlText(xml, "smtpPort")) ?? 0,
+    sendNickname: getXmlText(xml, "sendNickname") ?? "",
+    attachment: parseInt01(getXmlText(xml, "attachment")) ?? 0,
+    attachmentType: normalizeAttachmentType(getXmlText(xml, "attachmentType")),
+    textType: normalizeTextType(getXmlText(xml, "textType")),
+    ssl: parseInt01(getXmlText(xml, "ssl")) ?? 0,
+    interval: parseNumberSafe(getXmlText(xml, "interval")) ?? 30
+  };
+  const senderMaxLen = parseNumberSafe(getXmlText(xml, "senderMaxLen"));
+  if (senderMaxLen !== void 0) cfg.senderMaxLen = senderMaxLen;
+  const pwdMaxLen = parseNumberSafe(getXmlText(xml, "pwdMaxLen"));
+  if (pwdMaxLen !== void 0) cfg.pwdMaxLen = pwdMaxLen;
+  const ability = parseNumberSafe(getXmlText(xml, "emailAttachAbility"));
+  if (ability !== void 0) cfg.emailAttachAbility = ability;
+  return cfg;
+}
+function buildSetEmailXml(current, patch) {
+  const merged = { ...current, ...patch };
+  return ensureXmlHeader(
+    `<body><Email version="1.1"><smtpServer>${xmlEscape(merged.smtpServer)}</smtpServer><userName>${xmlEscape(merged.userName)}</userName><password>${xmlEscape(merged.password)}</password><address1>${xmlEscape(merged.address1)}</address1><address2>${xmlEscape(merged.address2)}</address2><address3>${xmlEscape(merged.address3)}</address3><smtpPort>${merged.smtpPort}</smtpPort><sendNickname>${xmlEscape(merged.sendNickname)}</sendNickname><attachment>${merged.attachment}</attachment><attachmentType>${merged.attachmentType}</attachmentType><textType>${merged.textType}</textType><ssl>${merged.ssl}</ssl><interval>${merged.interval}</interval></Email></body>`
+  );
+}
+function parseEmailTaskFromXml(xml) {
+  const channelId = parseNumberSafe(getXmlText(xml, "channelId")) ?? 0;
+  const enable = parseInt01(getXmlText(xml, "enable")) ?? 0;
+  const items = [];
+  const itemRe = /<item>([\s\S]*?)<\/item>/g;
+  let match;
+  while ((match = itemRe.exec(xml)) !== null) {
+    const block = match[1] ?? "";
+    items.push({
+      type: getXmlText(block, "type") ?? "none",
+      valueTable: getXmlText(block, "valueTable") ?? ""
+    });
+  }
+  return { channelId, enable, typeScheduleList: items };
+}
+function buildEmailScheduleValueTable(spec) {
+  if (spec.kind === "always") return "1".repeat(168);
+  const grid = new Array(168).fill("0");
+  if (spec.kind === "never") return grid.join("");
+  for (const w of spec.windows) {
+    const startH = Math.max(0, Math.min(24, w.startHour));
+    const endH = Math.max(startH, Math.min(24, w.endHour));
+    for (const d of w.days) {
+      if (d < 0 || d > 6) continue;
+      for (let h = startH; h < endH; h++) {
+        grid[d * 24 + h] = "1";
+      }
+    }
+  }
+  return grid.join("");
+}
+function buildSetEmailTaskXml(task) {
+  const items = task.typeScheduleList.map(
+    (item) => `<item><type>${xmlEscape(item.type)}</type><valueTable>${xmlEscape(item.valueTable)}</valueTable></item>`
+  ).join("");
+  return ensureXmlHeader(
+    `<body><EmailTask version="1.1"><channelId>${task.channelId}</channelId><enable>${task.enable}</enable><typeScheduleList>${items}</typeScheduleList></EmailTask></body>`
+  );
+}
+
+// src/reolink/baichuan/utils/ntp.ts
+var parseNumberSafe2 = (text) => {
+  if (text === void 0) return void 0;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : void 0;
+};
+var parseInt012 = (text) => {
+  if (text === void 0) return void 0;
+  return text.trim() === "1" ? 1 : 0;
+};
+function parseNtpConfigFromXml(xml) {
+  return {
+    enable: parseInt012(getXmlText(xml, "enable")) ?? 0,
+    server: getXmlText(xml, "server") ?? "",
+    synchronizeInterval: parseNumberSafe2(getXmlText(xml, "synchronizeInterval")) ?? 1440,
+    port: parseNumberSafe2(getXmlText(xml, "port")) ?? 123
+  };
+}
+function buildSetNtpXml(current, patch) {
+  const merged = { ...current, ...patch };
+  return ensureXmlHeader(
+    `<body><Ntp version="1.1"><enable>${merged.enable}</enable><server>${xmlEscape(merged.server)}</server><synchronizeInterval>${merged.synchronizeInterval}</synchronizeInterval><port>${merged.port}</port></Ntp></body>`
+  );
+}
+
+// src/reolink/baichuan/utils/dst.ts
+var parseNumberSafe3 = (text) => {
+  if (text === void 0) return void 0;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : void 0;
+};
+var parseInt013 = (text) => {
+  if (text === void 0) return void 0;
+  return text.trim() === "1" ? 1 : 0;
+};
+var VALID_WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var normalizeWeekday = (text) => {
+  const t = (text ?? "").trim();
+  return VALID_WEEKDAYS.includes(t) ? t : "Sunday";
+};
+function parseDstConfigFromXml(xml) {
+  const cfg = {
+    enable: parseInt013(getXmlText(xml, "enable")) ?? 0,
+    offset: parseNumberSafe3(getXmlText(xml, "offset")) ?? 1,
+    startMonth: parseNumberSafe3(getXmlText(xml, "startMonth")) ?? 3,
+    startWeekIndex: parseNumberSafe3(getXmlText(xml, "startWeekIndex")) ?? 5,
+    startWeekday: normalizeWeekday(getXmlText(xml, "startWeekday")),
+    startHour: parseNumberSafe3(getXmlText(xml, "startHour")) ?? 2,
+    startMinute: parseNumberSafe3(getXmlText(xml, "startMinute")) ?? 0,
+    startSecond: parseNumberSafe3(getXmlText(xml, "startSecond")) ?? 0,
+    endMonth: parseNumberSafe3(getXmlText(xml, "endMonth")) ?? 10,
+    endWeekIndex: parseNumberSafe3(getXmlText(xml, "endWeekIndex")) ?? 4,
+    endWeekday: normalizeWeekday(getXmlText(xml, "endWeekday")),
+    endHour: parseNumberSafe3(getXmlText(xml, "endHour")) ?? 3,
+    endMinute: parseNumberSafe3(getXmlText(xml, "endMinute")) ?? 0,
+    endSecond: parseNumberSafe3(getXmlText(xml, "endSecond")) ?? 0
+  };
+  const version = parseNumberSafe3(getXmlText(xml, "version"));
+  if (version !== void 0) cfg.version = version;
+  return cfg;
+}
+function buildSetDstXml(current, patch) {
+  const merged = { ...current, ...patch };
+  return ensureXmlHeader(
+    `<body><Dst version="1.1"><enable>${merged.enable}</enable><offset>${merged.offset}</offset><startMonth>${merged.startMonth}</startMonth><startWeekIndex>${merged.startWeekIndex}</startWeekIndex><startWeekday>${xmlEscape(merged.startWeekday)}</startWeekday><startHour>${merged.startHour}</startHour><startMinute>${merged.startMinute}</startMinute><startSecond>${merged.startSecond}</startSecond><endMonth>${merged.endMonth}</endMonth><endWeekIndex>${merged.endWeekIndex}</endWeekIndex><endWeekday>${xmlEscape(merged.endWeekday)}</endWeekday><endHour>${merged.endHour}</endHour><endMinute>${merged.endMinute}</endMinute><endSecond>${merged.endSecond}</endSecond></Dst></body>`
+  );
+}
+
+// src/reolink/baichuan/utils/autoReboot.ts
+var parseNumberSafe4 = (text) => {
+  if (text === void 0) return void 0;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : void 0;
+};
+var parseInt014 = (text) => {
+  if (text === void 0) return void 0;
+  return text.trim() === "1" ? 1 : 0;
+};
+var VALID_WEEKDAYS2 = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+  "everyday"
+];
+var normalizeWeekday2 = (text) => {
+  const t = (text ?? "").trim();
+  return VALID_WEEKDAYS2.includes(t) ? t : "Sunday";
+};
+function parseAutoRebootFromXml(xml) {
+  return {
+    enable: parseInt014(getXmlText(xml, "enable")) ?? 0,
+    weekDay: normalizeWeekday2(getXmlText(xml, "weekDay")),
+    hour: parseNumberSafe4(getXmlText(xml, "hour")) ?? 0,
+    minute: parseNumberSafe4(getXmlText(xml, "minute")) ?? 0,
+    second: parseNumberSafe4(getXmlText(xml, "second")) ?? 0
+  };
+}
+function buildSetAutoRebootXml(current, patch) {
+  const merged = { ...current, ...patch };
+  return ensureXmlHeader(
+    `<body><AutoReboot version="1.1"><enable>${merged.enable}</enable><weekDay>${xmlEscape(merged.weekDay)}</weekDay><hour>${merged.hour}</hour><minute>${merged.minute}</minute><second>${merged.second}</second></AutoReboot></body>`
+  );
+}
+
+// src/reolink/baichuan/utils/systemGeneral.ts
+var parseNumberSafe5 = (text) => {
+  if (text === void 0) return void 0;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : void 0;
+};
+var parseInt015 = (text) => {
+  if (text === void 0) return void 0;
+  return text.trim() === "1" ? 1 : 0;
+};
+var VALID_OSD_FORMATS = ["DMY", "MDY", "YMD"];
+var normalizeOsdFormat = (text) => {
+  const t = (text ?? "").trim();
+  return VALID_OSD_FORMATS.includes(t) ? t : "YMD";
+};
+function parseSystemGeneralFromXml(xml) {
+  return {
+    timeZone: parseNumberSafe5(getXmlText(xml, "timeZone")) ?? 0,
+    osdFormat: normalizeOsdFormat(getXmlText(xml, "osdFormat")),
+    year: parseNumberSafe5(getXmlText(xml, "year")) ?? 0,
+    month: parseNumberSafe5(getXmlText(xml, "month")) ?? 0,
+    day: parseNumberSafe5(getXmlText(xml, "day")) ?? 0,
+    hour: parseNumberSafe5(getXmlText(xml, "hour")) ?? 0,
+    minute: parseNumberSafe5(getXmlText(xml, "minute")) ?? 0,
+    second: parseNumberSafe5(getXmlText(xml, "second")) ?? 0,
+    deviceId: parseNumberSafe5(getXmlText(xml, "deviceId")) ?? 0,
+    timeFormat: parseInt015(getXmlText(xml, "timeFormat")) ?? 0,
+    language: getXmlText(xml, "language") ?? "English",
+    deviceName: getXmlText(xml, "deviceName") ?? "",
+    loginLock: parseInt015(getXmlText(xml, "loginLock")) ?? 0,
+    lockTime: parseNumberSafe5(getXmlText(xml, "lockTime")) ?? 0,
+    allowedTimes: parseNumberSafe5(getXmlText(xml, "allowedTimes")) ?? 0,
+    isDst: parseInt015(getXmlText(xml, "isDst")) ?? 0
+  };
+}
+function buildSetSystemGeneralXml(patch) {
+  const parts = [];
+  const isDeviceNameOnly = patch.deviceName !== void 0 && patch.timeZone === void 0 && patch.osdFormat === void 0 && patch.timeFormat === void 0 && patch.language === void 0 && patch.loginLock === void 0 && patch.lockTime === void 0 && patch.allowedTimes === void 0 && patch.manualTime === void 0;
+  if (isDeviceNameOnly) {
+    parts.push("<year>0</year>");
+    parts.push(`<deviceName>${xmlEscape(patch.deviceName)}</deviceName>`);
+    parts.push("<deviceNameOnly>1</deviceNameOnly>");
+  } else if (patch.manualTime !== void 0) {
+    const mt = patch.manualTime;
+    if (patch.timeZone !== void 0)
+      parts.push(`<timeZone>${patch.timeZone}</timeZone>`);
+    if (patch.osdFormat !== void 0)
+      parts.push(`<osdFormat>${patch.osdFormat}</osdFormat>`);
+    parts.push(`<year>${mt.year}</year>`);
+    parts.push(`<month>${mt.month}</month>`);
+    parts.push(`<day>${mt.day}</day>`);
+    parts.push(`<hour>${mt.hour}</hour>`);
+    parts.push(`<minute>${mt.minute}</minute>`);
+    parts.push(`<second>${mt.second}</second>`);
+    if (patch.timeFormat !== void 0)
+      parts.push(`<timeFormat>${patch.timeFormat}</timeFormat>`);
+    if (patch.language !== void 0)
+      parts.push(`<language>${xmlEscape(patch.language)}</language>`);
+    if (patch.deviceName !== void 0)
+      parts.push(`<deviceName>${xmlEscape(patch.deviceName)}</deviceName>`);
+    if (patch.loginLock !== void 0)
+      parts.push(`<loginLock>${patch.loginLock}</loginLock>`);
+    if (patch.lockTime !== void 0)
+      parts.push(`<lockTime>${patch.lockTime}</lockTime>`);
+    if (patch.allowedTimes !== void 0)
+      parts.push(`<allowedTimes>${patch.allowedTimes}</allowedTimes>`);
+  } else {
+    if (patch.timeZone !== void 0)
+      parts.push(`<timeZone>${patch.timeZone}</timeZone>`);
+    if (patch.osdFormat !== void 0)
+      parts.push(`<osdFormat>${patch.osdFormat}</osdFormat>`);
+    if (patch.timeFormat !== void 0)
+      parts.push(`<timeFormat>${patch.timeFormat}</timeFormat>`);
+    if (patch.language !== void 0)
+      parts.push(`<language>${xmlEscape(patch.language)}</language>`);
+    if (patch.loginLock !== void 0)
+      parts.push(`<loginLock>${patch.loginLock}</loginLock>`);
+    if (patch.lockTime !== void 0)
+      parts.push(`<lockTime>${patch.lockTime}</lockTime>`);
+    if (patch.allowedTimes !== void 0)
+      parts.push(`<allowedTimes>${patch.allowedTimes}</allowedTimes>`);
+    parts.push("<year>0</year>");
+  }
+  return ensureXmlHeader(
+    `<body><SystemGeneral version="1.1">${parts.join("")}</SystemGeneral></body>`
+  );
+}
+
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 import { Jimp, JimpMime } from "jimp";
 
@@ -8335,6 +8703,31 @@ var parseAbilityInfoXml = (xml) => {
   return abilities;
 };
 
+// src/reolink/baichuan/utils/versionInfo.ts
+function parseVersionInfo(xml) {
+  const out = {};
+  const set = (key) => {
+    const v = getXmlText(xml, key);
+    if (v !== void 0) out[key] = v;
+  };
+  set("name");
+  set("type");
+  set("serialNumber");
+  set("buildDay");
+  set("hardwareVersion");
+  set("cfgVersion");
+  set("firmwareVersion");
+  set("detail");
+  set("IEClient");
+  set("cc3200Version");
+  set("spVersion");
+  set("pakSuffix");
+  set("itemNo");
+  set("aiVersion");
+  set("helpVersion");
+  return out;
+}
+
 // src/reolink/baichuan/utils/logging.ts
 var formatErrorForLog = (e) => {
   if (e instanceof Error) {
@@ -8589,6 +8982,204 @@ var buildChannelPushDataLogSnapshot = (channelPushData) => {
   return { result: resultObj, storedChannels: Object.keys(resultObj) };
 };
 
+// src/reolink/baichuan/utils/detection.ts
+import * as lz4 from "lz4js";
+
+// src/reolink/baichuan/utils/aiClassMap.ts
+function type1ToLabel(type1) {
+  switch (type1) {
+    case 1:
+      return "people";
+    case 2:
+      return "vehicle";
+    case 3:
+      return "animal";
+    case 11259375:
+      return "face";
+    default:
+      return "unknown";
+  }
+}
+
+// src/reolink/baichuan/utils/detection.ts
+var MARKER_LENGTH = 8;
+var IFRAME_PREFIX_LENGTH = 8;
+var COUNTER_OFFSET = 8;
+var BASELINE_SIZE = 128;
+var FRAME_SIZE_TLV = Buffer.from([3, 4, 0]);
+var LZ4F_MAGIC = Buffer.from([4, 34, 77, 24]);
+var CONFIDENCE_DIVISOR = 100;
+var DEFAULT_AI_FRAME_WIDTH = 896;
+var DEFAULT_AI_FRAME_HEIGHT = 480;
+var LZ4_DECOMPRESS_MAX = 256 * 1024;
+function walkBoxes(buf, start, end, type1, type2, out) {
+  let pos = start;
+  while (pos + 3 <= end) {
+    const t = buf[pos];
+    if (t === 0) return;
+    const length = buf[pos + 1] | buf[pos + 2] << 8;
+    const recordEnd = pos + 3 + length;
+    if (recordEnd > end) return;
+    const isBoxType4 = t === 4 && (length === 10 || length === 13 || length === 14);
+    const isBoxType2 = t === 2 && length === 10;
+    if ((isBoxType4 || isBoxType2) && type1 !== 0 && type2 !== 0) {
+      const x1 = buf.readUInt16LE(pos + 3);
+      const y1 = buf.readUInt16LE(pos + 5);
+      const x2 = buf.readUInt16LE(pos + 7);
+      const y2 = buf.readUInt16LE(pos + 9);
+      const conf = buf.readUInt16LE(pos + 11);
+      if (x2 > x1 && y2 > y1) {
+        out.push({ x1, y1, x2, y2, conf, label: type1ToLabel(type1) });
+      }
+      pos = recordEnd;
+      continue;
+    }
+    if (type1 === 255 && type2 === 2 && t === 2 && length >= LZ4F_MAGIC.length && buf[pos + 3] === LZ4F_MAGIC[0] && buf[pos + 4] === LZ4F_MAGIC[1] && buf[pos + 5] === LZ4F_MAGIC[2] && buf[pos + 6] === LZ4F_MAGIC[3]) {
+      try {
+        const decompressed = lz4.decompress(
+          buf.subarray(pos + 3, recordEnd),
+          LZ4_DECOMPRESS_MAX
+        );
+        const decBuf = Buffer.from(decompressed);
+        walkBoxes(decBuf, 0, decBuf.length, 0, 0, out);
+      } catch {
+      }
+      pos = recordEnd;
+      continue;
+    }
+    if (length > 0) {
+      let nextT1 = type1;
+      let nextT2 = type2;
+      if (type1 === 0) nextT1 = t;
+      else if (type2 === 0) nextT2 = t;
+      walkBoxes(buf, pos + 3, recordEnd, nextT1, nextT2, out);
+    }
+    pos = recordEnd;
+  }
+}
+function decodeDetectionHeader(raw, frameType) {
+  const markerOffset = frameType === "Iframe" ? IFRAME_PREFIX_LENGTH : 0;
+  const blockLength = raw.length - markerOffset;
+  const empty = {
+    state: "invalid-marker",
+    markerOffset,
+    blockLength,
+    boxes: []
+  };
+  if (blockLength < MARKER_LENGTH) return empty;
+  if (!hasStandardMarker(raw, markerOffset)) return empty;
+  if (blockLength < COUNTER_OFFSET + 4) return empty;
+  const counter = raw.readUInt32LE(markerOffset + COUNTER_OFFSET);
+  const rawBoxes = [];
+  walkBoxes(raw, markerOffset, raw.length, 0, 0, rawBoxes);
+  let aiFrameWidth = DEFAULT_AI_FRAME_WIDTH;
+  let aiFrameHeight = DEFAULT_AI_FRAME_HEIGHT;
+  let frameSizeFound = false;
+  const searchStart = markerOffset + MARKER_LENGTH;
+  for (let i = searchStart; i + 7 <= raw.length; i++) {
+    if (raw[i] === FRAME_SIZE_TLV[0] && raw[i + 1] === FRAME_SIZE_TLV[1] && raw[i + 2] === FRAME_SIZE_TLV[2]) {
+      const w = raw.readUInt16LE(i + 3);
+      const h = raw.readUInt16LE(i + 5);
+      if (w >= 64 && w <= 8192 && h >= 64 && h <= 8192) {
+        aiFrameWidth = w;
+        aiFrameHeight = h;
+        frameSizeFound = true;
+        break;
+      }
+    }
+  }
+  const specificity = {
+    face: 4,
+    animal: 3,
+    people: 2,
+    vehicle: 1,
+    unknown: 0
+  };
+  const dedup = /* @__PURE__ */ new Map();
+  for (const rb of rawBoxes) {
+    if (rb.x2 > aiFrameWidth || rb.y2 > aiFrameHeight) continue;
+    const key = `${rb.x1}_${rb.y1}_${rb.x2}_${rb.y2}`;
+    const prev = dedup.get(key);
+    if (!prev || (specificity[rb.label] ?? 0) > (specificity[prev.label] ?? 0)) {
+      dedup.set(key, rb);
+    }
+  }
+  const boxes = [];
+  for (const rb of dedup.values()) {
+    boxes.push({
+      x: rb.x1 / aiFrameWidth,
+      y: rb.y1 / aiFrameHeight,
+      width: (rb.x2 - rb.x1) / aiFrameWidth,
+      height: (rb.y2 - rb.y1) / aiFrameHeight,
+      ...rb.conf > 0 && rb.conf <= 100 ? { confidence: rb.conf / CONFIDENCE_DIVISOR } : {},
+      ...rb.label !== "unknown" ? { label: rb.label } : {}
+    });
+  }
+  let state;
+  if (boxes.length > 0) state = "overlay-decoded";
+  else if (blockLength === BASELINE_SIZE) state = "no-overlay";
+  else state = "overlay-undecoded";
+  return {
+    state,
+    markerOffset,
+    blockLength,
+    counter,
+    ...frameSizeFound ? { aiFrameWidth, aiFrameHeight } : {},
+    boxes
+  };
+}
+function hasStandardMarker(raw, offset) {
+  if (raw.length < offset + MARKER_LENGTH) return false;
+  return raw[offset] === 255 && raw[offset + 2] === 0 && raw[offset + 3] === 1 && raw[offset + 4] === 11 && raw[offset + 5] === 0 && raw[offset + 6] === 1 && raw[offset + 7] === 8;
+}
+
+// src/reolink/baichuan/utils/encOptions.ts
+function buildEncOptions(list, channel) {
+  const result = { channel };
+  const main = aggregateByType(list, "mainStream");
+  const sub = aggregateByType(list, "subStream");
+  const third = aggregateByType(list, "thirdStream");
+  if (main) result.mainStream = main;
+  if (sub) result.subStream = sub;
+  if (third) result.thirdStream = third;
+  return result;
+}
+function aggregateByType(list, type) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const stream of list.streams) {
+    for (const eb of stream.encodeTables) {
+      if (eb.type !== type) continue;
+      const mapped = mapEncodeTable(eb);
+      if (!mapped) continue;
+      const key = `${mapped.width}x${mapped.height}`;
+      if (!seen.has(key)) seen.set(key, mapped);
+    }
+  }
+  if (seen.size === 0) return void 0;
+  return {
+    type,
+    resolutions: [...seen.values()],
+    encoderTypes: ["vbr", "cbr"],
+    encoderProfiles: ["high", "main", "baseline"]
+  };
+}
+function mapEncodeTable(eb) {
+  if (eb.width == null || eb.height == null) return void 0;
+  const videoEncTypes = (eb.videoEncTypeList ?? (eb.videoEncType != null ? [eb.videoEncType] : [])).map(
+    (t) => t === 0 ? "h264" : t === 1 ? "h265" : void 0
+  ).filter((t) => t !== void 0);
+  return {
+    width: eb.width,
+    height: eb.height,
+    videoEncTypes,
+    ...eb.defaultFramerate != null ? { defaultFramerate: eb.defaultFramerate } : {},
+    ...eb.defaultBitrate != null ? { defaultBitrate: eb.defaultBitrate } : {},
+    ...eb.defaultGop != null ? { defaultGop: eb.defaultGop } : {},
+    framerateOptions: eb.framerateTable ?? [],
+    bitrateOptions: eb.bitrateTable ?? []
+  };
+}
+
 // src/reolink/baichuan/utils/events.ts
 var mapToSimpleEvent = (event) => {
   const timestamp = event.timestamp ?? Date.now();
@@ -10688,6 +11279,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   sessionGuardIntervalTimer;
   simpleEventListeners = /* @__PURE__ */ new Set();
   simpleEventSubscribed = false;
+  // Detection events are sourced from BcMedia additionalHeader on active video
+  // streams. Unlike simpleEvent, no Baichuan subscribe command is needed — the
+  // data flows whenever a stream is open. Active streams register themselves via
+  // _registerVideoStreamForDetection (called from BaichuanVideoStream.start).
+  detectionEventListeners = /* @__PURE__ */ new Set();
+  detectionEventStreamHooks = /* @__PURE__ */ new Map();
+  // Auto-managed substream for `onObjectDetections` listeners. Reference-counted
+  // by the listener set: the substream is opened on the first listener and torn
+  // down with the last one. Mirrors `onSimpleEvent`'s subscribe/unsubscribe
+  // lifecycle so a caller never has to manage a video stream just to read AI
+  // detections.
+  objectDetectionListeners = /* @__PURE__ */ new Set();
+  objectDetectionStream;
+  objectDetectionStreamStartInFlight;
+  objectDetectionInternalListener;
   simpleEventSubscribeInFlight;
   simpleEventUnsubscribeInFlight;
   simpleEventResubscribeTimer;
@@ -12123,6 +12729,205 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       }
     }
   }
+  /**
+   * Subscribe to per-frame detection events sourced from the BcMedia
+   * `additionalHeader` block on active video streams.
+   *
+   * Mirrors {@link onSimpleEvent} but is fed by the streaming side-channel:
+   * one event fires for every I-frame / P-frame that carries an overlay block.
+   * Coordinates are reported in normalized [0, 1] fractions of the source
+   * frame, so the same box renders correctly on mainStream, subStream, and
+   * externStream.
+   *
+   * Unlike `onSimpleEvent`, no Baichuan subscribe command is involved — events
+   * only flow while a video stream is open. The library hooks every
+   * `BaichuanVideoStream` created via this API for the listener's lifetime.
+   */
+  onDetection(callback) {
+    this.detectionEventListeners.add(callback);
+  }
+  /**
+   * Remove a single detection callback, or all of them if `callback` is omitted.
+   */
+  offDetection(callback) {
+    if (callback) {
+      this.detectionEventListeners.delete(callback);
+    } else {
+      this.detectionEventListeners.clear();
+    }
+  }
+  /**
+   * Subscribe to AI object detections (people / vehicle / animal / face boxes
+   * with class label and confidence) without managing a video stream yourself.
+   *
+   * Mirrors {@link onSimpleEvent} end-to-end: the API opens a dedicated
+   * substream behind the scenes on the first listener, forwards every box-bearing
+   * `additionalHeader` to your callback, and tears the stream down when the last
+   * listener unsubscribes. The substream is the lightest profile (typically
+   * 640×360) so the additional bandwidth/CPU overhead is minimal.
+   *
+   * Each event carries normalized `[0, 1]` box coordinates, a class label, and
+   * a confidence score — render-ready without further conversion.
+   */
+  async onObjectDetections(callback) {
+    this.objectDetectionListeners.add(callback);
+    this.logger.debug?.(
+      `[ReolinkBaichuanApi] onObjectDetections: registering listener (total=${this.objectDetectionListeners.size})`
+    );
+    await this.ensureObjectDetectionStream();
+  }
+  /**
+   * Remove one detection callback, or all of them if `callback` is omitted.
+   * When the last listener is removed the auto-managed substream is closed.
+   */
+  async offObjectDetections(callback) {
+    if (callback) {
+      this.objectDetectionListeners.delete(callback);
+    } else {
+      this.objectDetectionListeners.clear();
+    }
+    if (this.objectDetectionListeners.size === 0) {
+      await this.tearDownObjectDetectionStream();
+    }
+  }
+  async ensureObjectDetectionStream() {
+    if (this.objectDetectionStream) return;
+    if (this.objectDetectionStreamStartInFlight) {
+      await this.objectDetectionStreamStartInFlight;
+      return;
+    }
+    this.objectDetectionStreamStartInFlight = (async () => {
+      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-HGPU2MZ3.js");
+      const sessionKey = `live:object-detections:ch0:sub`;
+      const dedicated = await this.createDedicatedSession(sessionKey);
+      const stream = new BaichuanVideoStream2({
+        client: dedicated.client,
+        api: this,
+        channel: 0,
+        profile: "sub",
+        logger: this.logger
+      });
+      this.objectDetectionInternalListener = (event) => {
+        for (const cb of this.objectDetectionListeners) {
+          try {
+            void Promise.resolve(cb(event)).catch((e) => {
+              (this.logger.warn ?? this.logger.error).call(
+                this.logger,
+                "[ReolinkBaichuanApi] onObjectDetections handler error",
+                formatErrorForLog(e)
+              );
+            });
+          } catch (e) {
+            (this.logger.warn ?? this.logger.error).call(
+              this.logger,
+              "[ReolinkBaichuanApi] onObjectDetections handler error",
+              formatErrorForLog(e)
+            );
+          }
+        }
+      };
+      this.detectionEventListeners.add(this.objectDetectionInternalListener);
+      try {
+        await stream.start();
+      } catch (e) {
+        if (this.objectDetectionInternalListener) {
+          this.detectionEventListeners.delete(
+            this.objectDetectionInternalListener
+          );
+          this.objectDetectionInternalListener = void 0;
+        }
+        await dedicated.release().catch(() => {
+        });
+        throw e;
+      }
+      this.objectDetectionStream = {
+        stop: () => stream.stop(),
+        release: () => dedicated.release()
+      };
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] onObjectDetections: substream started (key=${sessionKey})`
+      );
+    })();
+    try {
+      await this.objectDetectionStreamStartInFlight;
+    } finally {
+      this.objectDetectionStreamStartInFlight = void 0;
+    }
+  }
+  async tearDownObjectDetectionStream() {
+    const handle = this.objectDetectionStream;
+    this.objectDetectionStream = void 0;
+    if (this.objectDetectionInternalListener) {
+      this.detectionEventListeners.delete(this.objectDetectionInternalListener);
+      this.objectDetectionInternalListener = void 0;
+    }
+    if (!handle) return;
+    try {
+      await handle.stop();
+    } catch (e) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] onObjectDetections: stream stop error: ${formatErrorForLog(e)}`
+      );
+    }
+    try {
+      await handle.release();
+    } catch (e) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] onObjectDetections: session release error: ${formatErrorForLog(e)}`
+      );
+    }
+    this.logger.debug?.(
+      `[ReolinkBaichuanApi] onObjectDetections: substream torn down`
+    );
+  }
+  /**
+   * Internal: invoked by BaichuanVideoStream when it starts so the API can hook
+   * its `additionalHeader` event. Returns a teardown function the stream calls
+   * on stop. Not intended for direct use by consumers.
+   */
+  _registerVideoStreamForDetection(stream, context) {
+    const listener = (info) => {
+      if (this.detectionEventListeners.size === 0) return;
+      const decoded = decodeDetectionHeader(info.raw, info.frameType);
+      const event = {
+        channel: context.channel,
+        microseconds: info.microseconds,
+        profile: context.profile,
+        boxes: decoded.boxes,
+        ...info.frameWidth !== void 0 ? { frameWidth: info.frameWidth } : {},
+        ...info.frameHeight !== void 0 ? { frameHeight: info.frameHeight } : {},
+        decodeState: decoded.state,
+        rawHeader: info.raw
+      };
+      this.dispatchDetectionEvent(event);
+    };
+    stream.on("additionalHeader", listener);
+    const teardown = () => {
+      stream.off("additionalHeader", listener);
+      this.detectionEventStreamHooks.delete(stream);
+    };
+    this.detectionEventStreamHooks.set(stream, teardown);
+    return teardown;
+  }
+  dispatchDetectionEvent(evt) {
+    for (const cb of this.detectionEventListeners) {
+      try {
+        void Promise.resolve(cb(evt)).catch((e) => {
+          (this.logger.warn ?? this.logger.error).call(
+            this.logger,
+            "[ReolinkBaichuanApi] onDetection handler error",
+            formatErrorForLog(e)
+          );
+        });
+      } catch (e) {
+        (this.logger.warn ?? this.logger.error).call(
+          this.logger,
+          "[ReolinkBaichuanApi] onDetection handler error",
+          formatErrorForLog(e)
+        );
+      }
+    }
+  }
   startSimpleEventResubscribeTimer() {
     if (this.simpleEventResubscribeTimer) return;
     if (this.simpleEventListeners.size === 0) return;
@@ -12505,6 +13310,9 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     this.stopUdpSleepInference();
     this.stopSimpleEventWatchdog();
     this.stopSimpleEventResubscribeTimer();
+    this.objectDetectionListeners.clear();
+    await this.tearDownObjectDetectionStream().catch(() => {
+    });
     await this.cleanup();
     await this.stopAllActiveStreams();
     await this.cleanupSocketPool();
@@ -12852,6 +13660,53 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const xml = `<?xml version="1.0" encoding="UTF-8" ?><body><${tag} version="1.1"><enable>${params.enable ? 1 : 0}</enable></${tag}></body>`;
     await this.sendXml({ cmdId: 36, payloadXml: xml });
   }
+  /**
+   * Full port-config setter (cmd_id 36). Patches one or more of the six
+   * service ports the camera serves — Server (Baichuan), HTTP, HTTPS,
+   * RTSP, RTMP, ONVIF. Each entry takes an optional `port` (number) and
+   * `enable` (boolean); fields the caller doesn't pass are left alone.
+   *
+   * Sends one block per port that has any field set, then issues a
+   * single cmd_36 with the merged body. The camera accepts multiple
+   * `<XxxPort>` siblings in the same payload.
+   *
+   * Wire format observed on E1 Zoom:
+   *
+   *   <body>
+   *     <RtspPort version="1.1">
+   *       <rtspPort>554</rtspPort>
+   *       <enable>1</enable>
+   *     </RtspPort>
+   *     <HttpsPort version="1.1">
+   *       <enable>0</enable>
+   *     </HttpsPort>
+   *     ...
+   *   </body>
+   */
+  async setPortConfig(patch) {
+    const blocks = [];
+    const append = (tag, portField, cfg) => {
+      if (!cfg) return;
+      if (cfg.port === void 0 && cfg.enable === void 0) return;
+      const inner = [];
+      if (cfg.port !== void 0) {
+        inner.push(`<${portField}>${cfg.port}</${portField}>`);
+      }
+      if (cfg.enable !== void 0) {
+        inner.push(`<enable>${cfg.enable ? 1 : 0}</enable>`);
+      }
+      blocks.push(`<${tag} version="1.1">${inner.join("")}</${tag}>`);
+    };
+    append("ServerPort", "serverPort", patch.server);
+    append("HttpPort", "httpPort", patch.http);
+    append("HttpsPort", "httpsPort", patch.https);
+    append("RtspPort", "rtspPort", patch.rtsp);
+    append("RtmpPort", "rtmpPort", patch.rtmp);
+    append("OnvifPort", "onvifPort", patch.onvif);
+    if (blocks.length === 0) return;
+    const xml = `<?xml version="1.0" encoding="UTF-8" ?><body>${blocks.join("")}</body>`;
+    await this.sendXml({ cmdId: 36, payloadXml: xml });
+  }
   /** GetDevInfo via Baichuan: host cmd_id 80, channel cmd_id 318 */
   async getInfo(channel, options) {
     const req = { cmdId: channel == null ? 80 : 318 };
@@ -16536,6 +17391,27 @@ ${stderr}`)
       );
     }
   }
+  async gotoPtzPreset(arg1, arg2) {
+    const ch = arg2 === void 0 ? this.normalizeChannel(void 0) : this.normalizeChannel(arg1);
+    const presetId = arg2 === void 0 ? arg1 : arg2;
+    const channelId = ch;
+    const payloadXml = buildPtzPresetXmlV2(channelId, presetId, "toPos");
+    const extensionXml = buildChannelExtensionXml(channelId);
+    const frame = await this.client.sendFrame({
+      cmdId: BC_CMD_ID_PTZ_CONTROL_PRESET,
+      channel: ch,
+      channelIdOverride: channelId,
+      extensionXml,
+      payloadXml,
+      messageClass: BC_CLASS_MODERN_24,
+      streamType: 0
+    });
+    if (frame.header.responseCode !== 200) {
+      throw new Error(
+        `PTZ goto preset rejected (response_code ${frame.header.responseCode})`
+      );
+    }
+  }
   async deletePtzPreset(arg1, arg2) {
     const ch = arg2 === void 0 ? this.normalizeChannel(void 0) : this.normalizeChannel(arg1);
     const presetId = arg2 === void 0 ? arg1 : arg2;
@@ -17187,22 +18063,62 @@ ${stderr}`)
     const channel = typeof arg1 === "number" ? arg1 : arg3;
     const enabled = typeof arg1 === "number" ? arg2 : arg1;
     const sensitivity = typeof arg1 === "number" ? arg3 : arg2;
-    const ch = this.normalizeChannel(channel);
+    return await this.setMotionAlarmFull({
+      ...channel !== void 0 ? { channel } : {},
+      enabled,
+      ...sensitivity !== void 0 ? { sensitivity } : {}
+    });
+  }
+  /**
+   * Set motion alarm with full control, including the detection-zone grid.
+   *
+   * Wire format observed on E1 Zoom (cmd_id=47 SetMdAlarm body):
+   *
+   *   <MD version="1.1">
+   *     <channelId>0</channelId>
+   *     <enable>1</enable>
+   *     <usepir>0</usepir>
+   *     <width>60</width> <height>33</height>
+   *     <scope>
+   *       <columns>96</columns> <rows>64</rows>
+   *       <valueTable>{base64 6144-bit bitmap}</valueTable>
+   *     </scope>
+   *     ... other camera-specific fields ...
+   *   </MD>
+   *
+   * We do a read-modify-write of the GET response so any camera-specific
+   * extension fields are preserved untouched. Pass `valueTable` to update
+   * the detection zone — see `encodeMotionScopeBitmap` for the bitmap layout.
+   *
+   * @param channel - 0-based channel
+   * @param enabled - toggle motion detection on/off (optional)
+   * @param sensitivity - 0-50, higher = more sensitive (optional)
+   * @param valueTable - base64-encoded grid bitmap; size must match
+   *   `<scope><columns>×<rows></scope>` from the GET (optional)
+   */
+  async setMotionAlarmFull(opts) {
+    const ch = this.normalizeChannel(opts.channel);
     const currentXml = await this.sendXml({
       cmdId: BC_CMD_ID_GET_MOTION_ALARM,
       channel: ch
     });
     let modifiedXml = currentXml;
-    if (enabled !== void 0) {
+    if (opts.enabled !== void 0) {
       modifiedXml = modifiedXml.replace(
         /<enable>[^<]*<\/enable>/,
-        `<enable>${enabled ? "1" : "0"}</enable>`
+        `<enable>${opts.enabled ? "1" : "0"}</enable>`
       );
     }
-    if (sensitivity !== void 0) {
+    if (opts.sensitivity !== void 0) {
       modifiedXml = modifiedXml.replace(
         /<sensitivityDefault>[^<]*<\/sensitivityDefault>/,
-        `<sensitivityDefault>${sensitivity}</sensitivityDefault>`
+        `<sensitivityDefault>${opts.sensitivity}</sensitivityDefault>`
+      );
+    }
+    if (opts.valueTable !== void 0) {
+      modifiedXml = modifiedXml.replace(
+        /<valueTable>[^<]*<\/valueTable>/,
+        `<valueTable>${opts.valueTable}</valueTable>`
       );
     }
     await this.sendXml({
@@ -18477,7 +19393,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-RNIDFEJK.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-BQOWJ23L.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -18493,7 +19409,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-RNIDFEJK.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-BQOWJ23L.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -18546,12 +19462,24 @@ ${xml}`
   }
   /**
    * SetEnc via Baichuan (cmdId=57). Read-modify-write — preserves
-   * unspecified fields. Mirrors reolink_aio's `SetEnc`.
+   * unspecified fields. Mirrors reolink_aio's `SetEnc` plus the additional
+   * `width`/`height`/`encoderType`/`encoderProfile`/`gop`/`thirdStream`
+   * fields observed in the official mobile app (see `pcap/resolution.pcapng`).
+   *
+   * Field meaning per stream:
+   *  - `audio`           — 0/1 toggle
+   *  - `width`/`height`  — resolution in pixels. Must be one of the
+   *                        resolutions returned by {@link getStreamInfoList}.
+   *  - `bitRate`         — kbps. Must match the table from `getStreamInfoList`.
+   *  - `frameRate`       — fps. Must match the table from `getStreamInfoList`.
+   *  - `videoEncType`    — `"h264"` or `"h265"`
+   *  - `encoderType`     — `"vbr"` or `"cbr"`
+   *  - `encoderProfile`  — `"high"`, `"main"`, or `"baseline"`
+   *  - `gop`             — keyframe interval in seconds (sets `<gop><cur>`)
    *
    * @param channel - Channel number (0-based)
-   * @param patch - Fields to update on `mainStream` and/or `subStream`,
-   *   plus a top-level `audio` toggle (0/1). Pass only what you want
-   *   to change.
+   * @param patch - Fields to update. Pass only the fields you want to change;
+   *   everything else is preserved from the device's current configuration.
    */
   async setEnc(channel, patch, options) {
     const ch = this.normalizeChannel(channel);
@@ -18568,6 +19496,7 @@ ${xml}`
     }
     xml = applyStreamPatch(xml, "mainStream", patch.mainStream);
     xml = applyStreamPatch(xml, "subStream", patch.subStream);
+    xml = applyStreamPatch(xml, "thirdStream", patch.thirdStream);
     await this.sendXml({
       cmdId: BC_CMD_ID_SET_ENC,
       channel: ch,
@@ -19175,6 +20104,71 @@ ${xml}`
       `PCAP-derived settings GET failed for cmdId=${params.cmdId}: ${String(lastErr)}`
     );
   }
+  /**
+   * Update the OSD timestamp + channel-name overlay via cmd_id=45
+   * (SetOsdDatetime). The schema is the same `<body><OsdDatetime>` +
+   * `<OsdChannelName>` block returned by `getOsdDatetime` — we
+   * read-modify-write so any extension fields the camera sent are
+   * preserved.
+   *
+   * Position is in **camera pixel coordinates** (e.g. (1,1) for top-left,
+   * not preset strings). Set `enable=0` to hide the overlay; the camera
+   * keeps the stored position so re-enabling later restores it.
+   */
+  async setOsdDatetime(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    let xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_OSD_DATETIME,
+      channel: ch,
+      ...timeoutOpts
+    });
+    const patchBlock = (block, fields) => {
+      const start = xml.indexOf(`<${block}`);
+      if (start < 0) return;
+      const end = xml.indexOf(`</${block}>`, start);
+      if (end < 0) return;
+      let body = xml.slice(start, end);
+      for (const [tag, value] of Object.entries(fields)) {
+        if (value === void 0) continue;
+        const raw = typeof value === "boolean" ? value ? "1" : "0" : String(value);
+        const escaped = raw.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        if (body.includes(`<${tag}>`)) {
+          body = body.replace(
+            new RegExp(`<${tag}>[^<]*<\\/${tag}>`),
+            `<${tag}>${escaped}</${tag}>`
+          );
+        } else {
+          body += `<${tag}>${escaped}</${tag}>`;
+        }
+      }
+      xml = xml.slice(0, start) + body + xml.slice(end);
+    };
+    if (patch.datetime) {
+      patchBlock("OsdDatetime", {
+        enable: patch.datetime.enable,
+        topLeftX: patch.datetime.topLeftX,
+        topLeftY: patch.datetime.topLeftY,
+        language: patch.datetime.language
+      });
+    }
+    if (patch.channelName) {
+      patchBlock("OsdChannelName", {
+        name: patch.channelName.name,
+        enable: patch.channelName.enable,
+        topLeftX: patch.channelName.topLeftX,
+        topLeftY: patch.channelName.topLeftY,
+        enWatermark: patch.channelName.enWatermark,
+        enBgcolor: patch.channelName.enBgcolor
+      });
+    }
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_OSD_DATETIME,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...timeoutOpts
+    });
+  }
   async getOsdDatetime(channel, options) {
     const rawXml = await this.sendPcapDerivedSettingsGetXml({
       cmdId: BC_CMD_ID_GET_OSD_DATETIME,
@@ -19367,6 +20361,41 @@ ${xml}`
     });
     return { streams };
   }
+  /**
+   * Return the set of values `setEnc` will accept on each stream of `channel`.
+   * Aggregates `getStreamInfoList` (cmd_146) into a UI-friendly shape:
+   * per-stream resolutions with their allowed codecs/framerates/bitrates plus
+   * the enumerated encoder modes/profiles Reolink exposes.
+   *
+   * Useful for populating selectors and validating user input before calling
+   * `setEnc` — picking an unsupported combination causes the camera to reject
+   * the SET_ENC command (responseCode != 200).
+   */
+  async getEncOptions(channel, options) {
+    const list = await this.getStreamInfoList(channel, options);
+    return buildEncOptions(list, channel);
+  }
+  /**
+   * Read the camera's `<VersionInfo>` block (cmd_id=80). Returns the
+   * friendly name, model code (e.g. `"E1 Zoom"`), serial number, firmware
+   * version, hardware revision, build day, AI model bundle version, etc.
+   *
+   * This is the same info the Reolink mobile app shows in "About this
+   * device" — distinct from `getSystemGeneral` (cmd_104) which carries
+   * time/locale.
+   *
+   * No channel parameter: this command is device-global on NVRs/Hubs and
+   * camera-global on standalone cameras. Pass an explicit channel via the
+   * underlying `sendXml` only if a specific firmware demands it (none we've
+   * tested do).
+   */
+  async getVersionInfo(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_VERSION_INFO,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseVersionInfo(xml);
+  }
   async getLedState(channel, options) {
     const rawXml = await this.sendPcapDerivedSettingsGetXml({
       cmdId: BC_CMD_ID_GET_LED_STATE,
@@ -19449,7 +20478,279 @@ ${xml}`
       ...channel != null ? { channel } : {},
       ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
     });
-    return parseXmlFragmentToJson(xml);
+    return parseEmailTaskFromXml(xml);
+  }
+  /**
+   * SetEmailTask via Baichuan (cmdId=216). Updates the email alarm schedule
+   * (per-event-type 7×24 valueTable + master enable).
+   *
+   * Reolink expects the FULL `typeScheduleList` — pass the array from a prior
+   * GET and only flip the entries you care about. Slots you don't track must
+   * be sent back unchanged to avoid the camera dropping them.
+   */
+  async setEmailTask(channel, task, options) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildSetEmailTaskXml({ ...task, channelId: ch });
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_EMAIL_TASK,
+      channel: ch,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * Convenience wrapper that patches the schedule of one or more trigger
+   * types on the camera's EmailTask without touching the others.
+   *
+   * Pass a high-level schedule spec (`always` / `never` / explicit windows)
+   * and the trigger types it should apply to. The method:
+   *
+   * 1. Reads the current EmailTask via GET (so we keep every existing slot).
+   * 2. Builds the new `valueTable` once from `schedule`.
+   * 3. Replaces the `valueTable` of every matching `type` in the list.
+   * 4. Appends entries for any requested type not already present.
+   * 5. Writes the merged list back via SET.
+   *
+   * Returns the list of types that were actually touched.
+   */
+  async patchEmailSchedule(channel, spec, options) {
+    const current = await this.getEmailTask(channel, options);
+    const newValueTable = buildEmailScheduleValueTable(spec.schedule);
+    const targetSet = new Set(spec.types);
+    const touched = [];
+    const updatedList = current.typeScheduleList.map((item) => {
+      if (targetSet.has(item.type)) {
+        touched.push(item.type);
+        return { ...item, valueTable: newValueTable };
+      }
+      return item;
+    });
+    for (const t of spec.types) {
+      if (!current.typeScheduleList.some((item) => item.type === t)) {
+        updatedList.push({ type: t, valueTable: newValueTable });
+        touched.push(t);
+      }
+    }
+    await this.setEmailTask(
+      channel,
+      {
+        channelId: current.channelId,
+        enable: spec.enable ?? current.enable,
+        typeScheduleList: updatedList
+      },
+      options
+    );
+    return { touchedTypes: touched };
+  }
+  // ====================================================================
+  // Email server (cmdId 42/43/141), NTP (38/39), DST (106/107),
+  // SystemGeneral SET (105), AutoReboot (100/101).
+  // Schemas derived from Reolink Client pcap (2026-05-16).
+  // ====================================================================
+  /**
+   * Read the SMTP email configuration (cmdId=42). Returns the full `<Email>`
+   * block including capability hints (`senderMaxLen`, `pwdMaxLen`,
+   * `emailAttachAbility`).
+   */
+  async getEmail(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_EMAIL,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseEmailConfigFromXml(xml);
+  }
+  /**
+   * Patch the SMTP email configuration (cmdId=43). Reads the current config
+   * first then merges the patch — Reolink rejects partial `<Email>` blocks.
+   */
+  async setEmail(patch, options) {
+    const current = await this.getEmail(options);
+    const payloadXml = buildSetEmailXml(current, patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_EMAIL,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * Send a test email using either the current config or an override patch
+   * (cmdId=141). Returns true when the camera reports 200 (test succeeded),
+   * false when it reports 482 (test failed — server unreachable / bad creds).
+   * Other non-200 codes propagate as exceptions via `sendXml`.
+   */
+  async testEmail(patch, options) {
+    const current = await this.getEmail(options);
+    const payloadXml = buildSetEmailXml(current, patch ?? {});
+    const timeoutMs = options?.timeoutMs ?? 6e4;
+    try {
+      await this.sendXml({
+        cmdId: BC_CMD_ID_TEST_EMAIL,
+        payloadXml,
+        timeoutMs
+      });
+      return true;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("response_code 482") || msg.includes("response_code=482")) {
+        return false;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Read the NTP server configuration (cmdId=38).
+   */
+  async getNtp(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_NTP,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseNtpConfigFromXml(xml);
+  }
+  /**
+   * Patch the NTP server configuration (cmdId=39). Reads the current state
+   * first and merges the patch — Reolink rejects partial `<Ntp>` blocks.
+   */
+  async setNtp(patch, options) {
+    const current = await this.getNtp(options);
+    const payloadXml = buildSetNtpXml(current, patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_NTP,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * Patch SystemGeneral (cmdId=105). Supports partial payloads: include only
+   * the fields you want to change. By default the builder emits `<year>0</year>`
+   * as the "do not set manual clock" marker; pass `manualTime` to actually
+   * set the date/time. Setting only `deviceName` automatically uses the
+   * Reolink Client's `deviceNameOnly=1` shape.
+   */
+  async setSystemGeneral(patch, options) {
+    const payloadXml = buildSetSystemGeneralXml(patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_SYSTEM_GENERAL,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * Read the Daylight Saving Time configuration (cmdId=106).
+   */
+  async getDst(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_DST,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseDstConfigFromXml(xml);
+  }
+  /**
+   * Patch the DST configuration (cmdId=107). Reads the current state first
+   * and merges the patch.
+   */
+  async setDst(patch, options) {
+    const current = await this.getDst(options);
+    const payloadXml = buildSetDstXml(current, patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_DST,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * Read the auto-reboot schedule (cmdId=101).
+   */
+  async getAutoReboot(options) {
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_AUTO_REBOOT,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseAutoRebootFromXml(xml);
+  }
+  /**
+   * Patch the auto-reboot schedule (cmdId=100).
+   */
+  async setAutoReboot(patch, options) {
+    const current = await this.getAutoReboot(options);
+    const payloadXml = buildSetAutoRebootXml(current, patch);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_AUTO_REBOOT,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * High-level helper that configures the camera to deliver motion alerts via
+   * SMTP to the local nodelink manager. Orchestrates `setEmail` + `setEmailTask`
+   * in a single call so UI code can offer "auto-configure" without juggling
+   * the underlying commands.
+   *
+   * Pass `runTest: true` to also send a test email (cmdId=141). Returns a
+   * structured result describing each leg of the flow so the caller can show
+   * granular feedback.
+   *
+   * @param params Auto-configuration parameters
+   * @param channel Logical channel (default 0). Used for the EmailTask SET.
+   */
+  async setupEmailPushToManager(params, channel, options) {
+    const port = params.managerPort ?? 2525;
+    const domain = params.domain ?? "nodelink.local";
+    const recipient = `${params.recipientLocalPart}@${domain}`;
+    const triggers = params.triggerTypes ?? ["MD", "people", "vehicle"];
+    const attachmentType = params.attachmentType ?? "picture";
+    const interval = params.interval ?? 30;
+    const emailPatch = {
+      smtpServer: params.managerHost,
+      smtpPort: port,
+      userName: params.authUsername ?? recipient,
+      password: params.authPassword ?? "",
+      address1: recipient,
+      address2: "",
+      address3: "",
+      sendNickname: params.sendNickname ?? params.recipientLocalPart,
+      attachment: attachmentType === "none" ? 0 : 1,
+      attachmentType,
+      textType: "withText",
+      ssl: 0,
+      interval
+    };
+    await this.setEmail(emailPatch, options);
+    const fullWeekOn = "1".repeat(168);
+    const current = await this.getEmailTask(channel, options);
+    const triggerSet = new Set(triggers);
+    const touched = [];
+    const updatedList = current.typeScheduleList.map((item) => {
+      if (triggerSet.has(item.type)) {
+        touched.push(item.type);
+        return { ...item, valueTable: fullWeekOn };
+      }
+      return item;
+    });
+    for (const t of triggers) {
+      if (!current.typeScheduleList.some((item) => item.type === t)) {
+        updatedList.push({ type: t, valueTable: fullWeekOn });
+        touched.push(t);
+      }
+    }
+    await this.setEmailTask(
+      channel,
+      {
+        channelId: current.channelId,
+        enable: 1,
+        typeScheduleList: updatedList
+      },
+      options
+    );
+    const result = {
+      setEmail: { applied: true },
+      setEmailTask: { applied: true, touchedTypes: touched }
+    };
+    if (params.runTest) {
+      const ok = await this.testEmail(emailPatch, options);
+      result.testEmail = { success: ok };
+    }
+    return result;
   }
   /**
    * Get siren-on-motion state via AudioTask (cmdId=232).
@@ -19718,7 +21019,7 @@ ${xml}`
       cmdId: BC_CMD_ID_GET_SYSTEM_GENERAL,
       ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
     });
-    return parseXmlFragmentToJson(xml);
+    return parseSystemGeneralFromXml(xml);
   }
   /**
    * Get device support/capability flags.
@@ -22560,4 +23861,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-HGQ53FB3.js.map
+//# sourceMappingURL=chunk-R5AJV73A.js.map