@apocaliss92/nodelink-js 0.4.10 → 0.4.12

package/dist/cli/rtsp-server.cjs

@@ -60,7 +60,7 @@ var init_urls = __esm({
 function bcHeaderHasPayloadOffset(messageClass) {
   return messageClass === BC_CLASS_MODERN_24 || messageClass === BC_CLASS_MODERN_24_ALT || messageClass === BC_CLASS_FILE_DOWNLOAD;
 }
-var BC_TCP_DEFAULT_PORT, BC_MAGIC, BC_MAGIC_REV, BC_XML_KEY, BC_AES_IV, BC_CLASS_LEGACY, BC_CLASS_MODERN_20, BC_CLASS_MODERN_24, BC_CLASS_MODERN_24_ALT, BC_CLASS_FILE_DOWNLOAD, BC_CMD_ID_LOGOUT, BC_CMD_ID_VIDEO, BC_CMD_ID_VIDEO_STOP, BC_CMD_ID_FILE_INFO_LIST_REPLAY, BC_CMD_ID_FILE_INFO_LIST_STOP, BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO, BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD, BC_CMD_ID_FILE_INFO_LIST_OPEN, BC_CMD_ID_FILE_INFO_LIST_GET, BC_CMD_ID_FILE_INFO_LIST_CLOSE, BC_CMD_ID_FIND_REC_VIDEO_OPEN, BC_CMD_ID_FIND_REC_VIDEO_GET, BC_CMD_ID_FIND_REC_VIDEO_CLOSE, BC_CMD_ID_TALK_ABILITY, BC_CMD_ID_TALK_RESET, BC_CMD_ID_TALK_CONFIG, BC_CMD_ID_TALK, BC_CMD_ID_PTZ_CONTROL, BC_CMD_ID_PTZ_CONTROL_PRESET, BC_CMD_ID_GET_PTZ_PRESET, BC_CMD_ID_GET_PTZ_POSITION, BC_CMD_ID_GET_ZOOM_FOCUS, BC_CMD_ID_SET_ZOOM_FOCUS, BC_CMD_ID_GET_BATTERY_INFO_LIST, BC_CMD_ID_GET_BATTERY_INFO, BC_CMD_ID_UDP_KEEP_ALIVE, BC_CMD_ID_GET_PIR_INFO, BC_CMD_ID_SET_PIR_INFO, BC_CMD_ID_GET_MOTION_ALARM, BC_CMD_ID_SET_MOTION_ALARM, BC_CMD_ID_GET_AI_ALARM, BC_CMD_ID_SET_AI_ALARM, BC_CMD_ID_GET_AUDIO_ALARM, BC_CMD_ID_AUDIO_ALARM_PLAY, BC_CMD_ID_GET_WHITE_LED, BC_CMD_ID_SET_WHITE_LED_STATE, BC_CMD_ID_SET_WHITE_LED_TASK, BC_CMD_ID_FLOODLIGHT_STATUS_LIST, BC_CMD_ID_ABILITY_INFO, BC_CMD_ID_SUPPORT, BC_CMD_ID_PING, BC_CMD_ID_CHANNEL_INFO_ALL, BC_CMD_ID_GET_OSD_DATETIME, BC_CMD_ID_GET_RECORD_CFG, BC_CMD_ID_GET_ABILITY_SUPPORT, BC_CMD_ID_GET_FTP_TASK, BC_CMD_ID_GET_RECORD, BC_CMD_ID_GET_HDD_INFO_LIST, BC_CMD_ID_GET_WIFI_SIGNAL, BC_CMD_ID_GET_WIFI, BC_CMD_ID_GET_ONLINE_USER_LIST, BC_CMD_ID_GET_DAY_RECORDS, BC_CMD_ID_GET_STREAM_INFO_LIST, BC_CMD_ID_GET_LED_STATE, BC_CMD_ID_GET_EMAIL_TASK, BC_CMD_ID_GET_AUDIO_TASK, BC_CMD_ID_GET_AUDIO_CFG, BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_TIMELAPSE_CFG, BC_CMD_ID_GET_AI_DENOISE, BC_CMD_ID_GET_KIT_AP_CFG, BC_CMD_ID_GET_REC_ENC_CFG, BC_CMD_ID_GET_ACCESS_USER_LIST, BC_CMD_ID_GET_SLEEP_STATE, BC_CMD_ID_GET_VIDEO_INPUT, BC_CMD_ID_GET_SYSTEM_GENERAL, BC_CMD_ID_GET_SUPPORT, BC_CMD_ID_GET_AI_CFG, BC_CMD_ID_SET_AI_CFG, BC_CMD_ID_GET_SIREN_STATUS, BC_CMD_ID_SET_AUDIO_TASK, BC_CMD_ID_SET_VIDEO_INPUT, BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_ENC, BC_CMD_ID_SET_ENC, BC_CMD_ID_GET_PRIVACY_MASK, BC_CMD_ID_SET_PRIVACY_MASK, BC_CMD_ID_SET_AI_DENOISE, BC_CMD_ID_SET_LED_STATE, BC_CMD_ID_SET_AUDIO_CFG, BC_CMD_ID_GET_AUTO_FOCUS, BC_CMD_ID_SET_AUTO_FOCUS, BC_CMD_ID_CMD_123, BC_CMD_ID_CMD_209, BC_CMD_ID_CMD_265, BC_CMD_ID_CMD_440, BC_CMD_ID_PUSH_VIDEO_INPUT, BC_CMD_ID_PUSH_SERIAL, BC_CMD_ID_PUSH_NET_INFO, BC_CMD_ID_PUSH_DINGDONG_LIST, BC_CMD_ID_PUSH_SLEEP_STATUS, BC_CMD_ID_PUSH_COORDINATE_POINT_LIST, BC_CMD_ID_DING_DONG_CTRL, BC_CMD_ID_GET_DING_DONG_LIST, BC_CMD_ID_DING_DONG_OPT, BC_CMD_ID_GET_DING_DONG_CFG, BC_CMD_ID_SET_DING_DONG_CFG, BC_CMD_ID_QUICK_REPLY_PLAY, BC_CMD_ID_GET_DING_DONG_SILENT, BC_CMD_ID_SET_DING_DONG_SILENT;
+var BC_TCP_DEFAULT_PORT, BC_MAGIC, BC_MAGIC_REV, BC_XML_KEY, BC_AES_IV, BC_CLASS_LEGACY, BC_CLASS_MODERN_20, BC_CLASS_MODERN_24, BC_CLASS_MODERN_24_ALT, BC_CLASS_FILE_DOWNLOAD, BC_CMD_ID_LOGOUT, BC_CMD_ID_VIDEO, BC_CMD_ID_VIDEO_STOP, BC_CMD_ID_FILE_INFO_LIST_REPLAY, BC_CMD_ID_FILE_INFO_LIST_STOP, BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO, BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD, BC_CMD_ID_FILE_INFO_LIST_OPEN, BC_CMD_ID_FILE_INFO_LIST_GET, BC_CMD_ID_FILE_INFO_LIST_CLOSE, BC_CMD_ID_FIND_REC_VIDEO_OPEN, BC_CMD_ID_FIND_REC_VIDEO_GET, BC_CMD_ID_FIND_REC_VIDEO_CLOSE, BC_CMD_ID_TALK_ABILITY, BC_CMD_ID_TALK_RESET, BC_CMD_ID_TALK_CONFIG, BC_CMD_ID_TALK, BC_CMD_ID_PTZ_CONTROL, BC_CMD_ID_PTZ_CONTROL_PRESET, BC_CMD_ID_GET_PTZ_PRESET, BC_CMD_ID_GET_PTZ_POSITION, BC_CMD_ID_GET_ZOOM_FOCUS, BC_CMD_ID_SET_ZOOM_FOCUS, BC_CMD_ID_GET_BATTERY_INFO_LIST, BC_CMD_ID_GET_BATTERY_INFO, BC_CMD_ID_UDP_KEEP_ALIVE, BC_CMD_ID_GET_PIR_INFO, BC_CMD_ID_SET_PIR_INFO, BC_CMD_ID_GET_MOTION_ALARM, BC_CMD_ID_SET_MOTION_ALARM, BC_CMD_ID_GET_AI_ALARM, BC_CMD_ID_SET_AI_ALARM, BC_CMD_ID_GET_AUDIO_ALARM, BC_CMD_ID_AUDIO_ALARM_PLAY, BC_CMD_ID_GET_WHITE_LED, BC_CMD_ID_SET_WHITE_LED_STATE, BC_CMD_ID_SET_WHITE_LED_TASK, BC_CMD_ID_FLOODLIGHT_STATUS_LIST, BC_CMD_ID_ABILITY_INFO, BC_CMD_ID_SUPPORT, BC_CMD_ID_PING, BC_CMD_ID_CHANNEL_INFO_ALL, BC_CMD_ID_GET_OSD_DATETIME, BC_CMD_ID_SET_OSD_DATETIME, BC_CMD_ID_GET_RECORD_CFG, BC_CMD_ID_GET_ABILITY_SUPPORT, BC_CMD_ID_GET_FTP_TASK, BC_CMD_ID_GET_VERSION_INFO, BC_CMD_ID_GET_RECORD, BC_CMD_ID_GET_HDD_INFO_LIST, BC_CMD_ID_GET_WIFI_SIGNAL, BC_CMD_ID_GET_WIFI, BC_CMD_ID_GET_ONLINE_USER_LIST, BC_CMD_ID_GET_DAY_RECORDS, BC_CMD_ID_GET_STREAM_INFO_LIST, BC_CMD_ID_GET_LED_STATE, BC_CMD_ID_GET_EMAIL_TASK, BC_CMD_ID_GET_AUDIO_TASK, BC_CMD_ID_GET_AUDIO_CFG, BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_TIMELAPSE_CFG, BC_CMD_ID_GET_AI_DENOISE, BC_CMD_ID_GET_KIT_AP_CFG, BC_CMD_ID_GET_REC_ENC_CFG, BC_CMD_ID_GET_ACCESS_USER_LIST, BC_CMD_ID_GET_SLEEP_STATE, BC_CMD_ID_GET_VIDEO_INPUT, BC_CMD_ID_GET_SYSTEM_GENERAL, BC_CMD_ID_GET_SUPPORT, BC_CMD_ID_GET_AI_CFG, BC_CMD_ID_SET_AI_CFG, BC_CMD_ID_GET_SIREN_STATUS, BC_CMD_ID_SET_AUDIO_TASK, BC_CMD_ID_SET_VIDEO_INPUT, BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD, BC_CMD_ID_GET_ENC, BC_CMD_ID_SET_ENC, BC_CMD_ID_GET_PRIVACY_MASK, BC_CMD_ID_SET_PRIVACY_MASK, BC_CMD_ID_SET_AI_DENOISE, BC_CMD_ID_SET_LED_STATE, BC_CMD_ID_SET_AUDIO_CFG, BC_CMD_ID_GET_AUTO_FOCUS, BC_CMD_ID_SET_AUTO_FOCUS, BC_CMD_ID_CMD_123, BC_CMD_ID_CMD_209, BC_CMD_ID_CMD_265, BC_CMD_ID_CMD_440, BC_CMD_ID_PUSH_VIDEO_INPUT, BC_CMD_ID_PUSH_SERIAL, BC_CMD_ID_PUSH_NET_INFO, BC_CMD_ID_PUSH_DINGDONG_LIST, BC_CMD_ID_PUSH_SLEEP_STATUS, BC_CMD_ID_PUSH_COORDINATE_POINT_LIST, BC_CMD_ID_DING_DONG_CTRL, BC_CMD_ID_GET_DING_DONG_LIST, BC_CMD_ID_DING_DONG_OPT, BC_CMD_ID_GET_DING_DONG_CFG, BC_CMD_ID_SET_DING_DONG_CFG, BC_CMD_ID_QUICK_REPLY_PLAY, BC_CMD_ID_GET_DING_DONG_SILENT, BC_CMD_ID_SET_DING_DONG_SILENT;
 var init_constants = __esm({
   "src/protocol/constants.ts"() {
     "use strict";
@@ -126,9 +126,11 @@ var init_constants = __esm({
     BC_CMD_ID_PING = 93;
     BC_CMD_ID_CHANNEL_INFO_ALL = 145;
     BC_CMD_ID_GET_OSD_DATETIME = 44;
+    BC_CMD_ID_SET_OSD_DATETIME = 45;
     BC_CMD_ID_GET_RECORD_CFG = 54;
     BC_CMD_ID_GET_ABILITY_SUPPORT = 58;
     BC_CMD_ID_GET_FTP_TASK = 70;
+    BC_CMD_ID_GET_VERSION_INFO = 80;
     BC_CMD_ID_GET_RECORD = 81;
     BC_CMD_ID_GET_HDD_INFO_LIST = 102;
     BC_CMD_ID_GET_WIFI_SIGNAL = 115;
@@ -488,10 +490,15 @@ var init_BcMediaCodec = __esm({
       strict;
       amountSkipped = 0;
       logger;
+      onUnknownChunk;
       constructor(strict = false, logger) {
         this.strict = strict;
         this.logger = logger;
       }
+      /** Register a listener that fires for every unknown chunk before recovery. */
+      setUnknownChunkListener(listener) {
+        this.onUnknownChunk = listener;
+      }
       /**
        * Push data into the codec buffer and try to parse complete BcMedia packets.
        * Returns an array of complete BcMedia packets found.
@@ -552,6 +559,13 @@ var init_BcMediaCodec = __esm({
               }
             }
             if (next > 0) {
+              if (this.onUnknownChunk) {
+                this.onUnknownChunk({
+                  magic,
+                  preview: Buffer.from(this.buffer.subarray(0, Math.min(256, next))),
+                  skipped: next
+                });
+              }
               this.amountSkipped += next;
               this.buffer = this.buffer.subarray(next);
               continue;
@@ -1414,6 +1428,10 @@ var init_BcMediaAnnexBDecoder = __esm({
 });
 
 // src/baichuan/stream/BaichuanVideoStream.ts
+var BaichuanVideoStream_exports = {};
+__export(BaichuanVideoStream_exports, {
+  BaichuanVideoStream: () => BaichuanVideoStream
+});
 function removeEmulationPreventionBytes(rbsp) {
   const out = [];
   for (let i = 0; i < rbsp.length; i++) {
@@ -1547,6 +1565,15 @@ var init_BaichuanVideoStream = __esm({
       acceptAnyStreamType;
       lockedChannelId;
       bcMediaCodec;
+      /**
+       * Diagnostic-only accessor for the BcMedia codec. Used by tools that need to
+       * inspect unknown chunks (for example to discover undocumented audio
+       * sub-packets the parser currently skips). Not part of the supported public
+       * surface — do not rely on it in application code.
+       */
+      get _bcMediaCodec() {
+        return this.bcMediaCodec;
+      }
       debugH264LogsLeft;
       debugSavedSamples;
       warnedNonAnnexBOnce = false;
@@ -1578,6 +1605,14 @@ var init_BaichuanVideoStream = __esm({
       // Stateful AES decryptor for fragmented BcMedia packets (full_aes mode)
       // In CFB mode, continuation frames must use the cipher state from previous frames.
       aesStreamDecryptor = null;
+      // Latest frame dimensions reported by BcMedia InfoV1/V2 packets.
+      // Used to attach width/height context to the `additionalHeader` event so
+      // consumers can normalize box coordinates to a fraction of the stream size.
+      latestFrameWidth;
+      latestFrameHeight;
+      // Teardown returned by ReolinkBaichuanApi._registerVideoStreamForDetection.
+      // Called from stop() to detach the detection bridge.
+      detectionTeardown;
       /**
        * Pending startup error stashed when emitSafeError is called before any
        * "error" listener is registered (e.g. camera returns 400 during start()).
@@ -2240,6 +2275,16 @@ var init_BaichuanVideoStream = __esm({
                 }
                 videoType = detectedCodec;
               }
+              if (media.additionalHeader && media.additionalHeader.length > 0) {
+                this.emit("additionalHeader", {
+                  raw: media.additionalHeader,
+                  frameType: "Iframe",
+                  videoType,
+                  microseconds: media.microseconds,
+                  ...this.latestFrameWidth !== void 0 ? { frameWidth: this.latestFrameWidth } : {},
+                  ...this.latestFrameHeight !== void 0 ? { frameHeight: this.latestFrameHeight } : {}
+                });
+              }
               const annexBData = videoType === "H265" ? convertToAnnexB2(media.data) : convertToAnnexB(media.data);
               const isKeyframe = true;
               maybeCacheParamSets(annexBData, "Iframe", videoType);
@@ -2321,6 +2366,18 @@ var init_BaichuanVideoStream = __esm({
               }
             } else if (media.type === "Pframe") {
               const chunk = media.data;
+              if (media.additionalHeader && media.additionalHeader.length > 0) {
+                const detected = detectVideoCodecFromNal(chunk);
+                const videoTypeForHeader = detected ?? media.videoType;
+                this.emit("additionalHeader", {
+                  raw: media.additionalHeader,
+                  frameType: "Pframe",
+                  videoType: videoTypeForHeader,
+                  microseconds: media.microseconds,
+                  ...this.latestFrameWidth !== void 0 ? { frameWidth: this.latestFrameWidth } : {},
+                  ...this.latestFrameHeight !== void 0 ? { frameHeight: this.latestFrameHeight } : {}
+                });
+              }
               let videoType = media.videoType;
               const detectedCodec = detectVideoCodecFromNal(chunk);
               if (detectedCodec && detectedCodec !== videoType) {
@@ -2363,6 +2420,8 @@ var init_BaichuanVideoStream = __esm({
               this.emit("audioFrame", media.data);
             }
             if (media.type === "InfoV1" || media.type === "InfoV2") {
+              if (media.videoWidth > 0) this.latestFrameWidth = media.videoWidth;
+              if (media.videoHeight > 0) this.latestFrameHeight = media.videoHeight;
             }
           }
           if (totalFramesReceived <= 10 || totalFramesReceived % 20 === 0 && (videoFramesEmitted > 0 || audioFramesEmitted > 0)) {
@@ -2382,6 +2441,12 @@ var init_BaichuanVideoStream = __esm({
         this.client.on("push", this.videoFrameHandler);
         this.active = true;
         this.startWatchdog();
+        if (this.api && typeof this.api._registerVideoStreamForDetection === "function") {
+          this.detectionTeardown = this.api._registerVideoStreamForDetection(this, {
+            channel: this.channel,
+            profile: this.profile
+          });
+        }
         this.lastMediaAtMs = Date.now();
         if (this.api) {
           try {
@@ -2479,6 +2544,13 @@ var init_BaichuanVideoStream = __esm({
           }
         }
         this.active = false;
+        if (this.detectionTeardown) {
+          try {
+            this.detectionTeardown();
+          } catch {
+          }
+          this.detectionTeardown = void 0;
+        }
         this.emit("close");
       }
       isActive() {
@@ -2714,6 +2786,15 @@ function applyXmlTagPatch(xml, tag, value) {
   const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
   return xml.replace(re, `<${tag}>${v}</${tag}>`);
 }
+function upsertXmlTag(xml, tag, value) {
+  if (value === void 0) return xml;
+  const v = typeof value === "boolean" ? value ? 1 : 0 : value;
+  const re = new RegExp(`<${tag}>[^<]*</${tag}>`);
+  if (re.test(xml)) {
+    return xml.replace(re, `<${tag}>${v}</${tag}>`);
+  }
+  return `${xml}<${tag}>${v}</${tag}>`;
+}
 function patchNestedTag(xml, parent, child, value) {
   if (value === void 0) return xml;
   const v = typeof value === "boolean" ? value ? 1 : 0 : value;
@@ -2729,6 +2810,15 @@ function applyStreamPatch(xml, streamTag, patch) {
   );
   return xml.replace(re, (_match, open, body, close) => {
     let next = body;
+    if (patch.audio !== void 0) {
+      next = applyXmlTagPatch(next, "audio", patch.audio);
+    }
+    if (patch.width !== void 0) {
+      next = applyXmlTagPatch(next, "width", patch.width);
+    }
+    if (patch.height !== void 0) {
+      next = applyXmlTagPatch(next, "height", patch.height);
+    }
     if (patch.bitRate !== void 0) {
       next = applyXmlTagPatch(next, "bitRate", patch.bitRate);
     }
@@ -2740,6 +2830,23 @@ function applyStreamPatch(xml, streamTag, patch) {
       const intVal = patch.videoEncType === "h265" ? 1 : 0;
       next = applyXmlTagPatch(next, "videoEncType", intVal);
     }
+    if (patch.encoderType !== void 0) {
+      next = upsertXmlTag(next, "encoderType", patch.encoderType);
+    }
+    if (patch.encoderProfile !== void 0) {
+      next = upsertXmlTag(next, "encoderProfile", patch.encoderProfile);
+    }
+    if (patch.gop !== void 0) {
+      const gopBlockRe = /(<gop[^>]*>)([\s\S]*?)(<\/gop>)/;
+      if (gopBlockRe.test(next)) {
+        next = next.replace(
+          gopBlockRe,
+          (_m, gOpen, gBody, gClose) => `${gOpen}${applyXmlTagPatch(gBody, "cur", patch.gop)}${gClose}`
+        );
+      } else {
+        next = `${next}<gop><cur>${patch.gop}</cur></gop>`;
+      }
+    }
     return `${open}${next}${close}`;
   });
 }
@@ -12313,6 +12420,23 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
    *   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.
    *
@@ -12427,6 +12551,29 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
   // 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;
@@ -12441,6 +12588,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
         code: err?.code
       });
     });
+    this.registerInDeviceClients();
   }
   newSocketSessionId(transport) {
     const short = (0, import_node_crypto2.randomUUID)().split("-")[0] ?? (0, import_node_crypto2.randomUUID)().slice(0, 8);
@@ -12697,6 +12845,18 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
         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.
@@ -13161,6 +13321,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
       `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();
   }
@@ -13477,6 +13638,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
         this.logDebug("udp_close_error", e);
       }
     }
+    this.unregisterFromDeviceClients();
   }
   handleFrame(frame) {
     const now = Date.now();
@@ -15804,6 +15966,32 @@ var parseAbilityInfoXml = (xml) => {
   return abilities;
 };
 
+// src/reolink/baichuan/utils/versionInfo.ts
+init_xml();
+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/aiState.ts
 init_constants();
 init_xml();
@@ -16110,6 +16298,204 @@ var buildChannelPushDataLogSnapshot = (channelPushData) => {
   return { result: resultObj, storedChannels: Object.keys(resultObj) };
 };
 
+// src/reolink/baichuan/utils/detection.ts
+var lz4 = __toESM(require("lz4js"), 1);
+
+// 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 main2 = aggregateByType(list, "mainStream");
+  const sub = aggregateByType(list, "subStream");
+  const third = aggregateByType(list, "thirdStream");
+  if (main2) result.mainStream = main2;
+  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();
@@ -18233,6 +18619,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;
@@ -19668,6 +20069,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 Promise.resolve().then(() => (init_BaichuanVideoStream(), BaichuanVideoStream_exports));
+      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;
@@ -20050,6 +20650,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();
@@ -20397,6 +21000,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 };
@@ -24081,6 +24731,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;
@@ -24732,22 +25403,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({
@@ -26091,12 +26802,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);
@@ -26113,6 +26836,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,
@@ -26720,6 +27444,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,
@@ -26912,6 +27701,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,