@apocaliss92/nodelink-js 0.4.10 → 0.4.12

package/dist/index.cjs

@@ -34,7 +34,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 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_LOGIN, 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_COVER_PREVIEW, BC_CMD_ID_COVER_STANDALONE_458, BC_CMD_ID_COVER_STANDALONE_459, BC_CMD_ID_COVER_STANDALONE_460, BC_CMD_ID_COVER_STANDALONE_461, BC_CMD_ID_COVER_STANDALONE_462, BC_CMD_ID_COVER_RESPONSE, 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_ALARM_EVENT_LIST, 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_SET_RECORD, BC_CMD_ID_SET_RECORD_CFG, BC_CMD_ID_SET_EMAIL_TASK, BC_CMD_ID_GET_PUSH_TASK, BC_CMD_ID_SET_PUSH_TASK, 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_LOGIN, 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_COVER_PREVIEW, BC_CMD_ID_COVER_STANDALONE_458, BC_CMD_ID_COVER_STANDALONE_459, BC_CMD_ID_COVER_STANDALONE_460, BC_CMD_ID_COVER_STANDALONE_461, BC_CMD_ID_COVER_STANDALONE_462, BC_CMD_ID_COVER_RESPONSE, 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_ALARM_EVENT_LIST, 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_SET_RECORD, BC_CMD_ID_SET_RECORD_CFG, BC_CMD_ID_SET_EMAIL_TASK, BC_CMD_ID_GET_PUSH_TASK, BC_CMD_ID_SET_PUSH_TASK, 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";
@@ -109,9 +109,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;
@@ -480,6 +482,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;
@@ -495,6 +506,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);
     }
@@ -506,6 +526,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}`;
   });
 }
@@ -1117,10 +1154,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.
@@ -1181,6 +1223,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;
@@ -2085,6 +2134,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++) {
@@ -2218,6 +2271,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;
@@ -2249,6 +2311,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()).
@@ -2911,6 +2981,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);
@@ -2992,6 +3072,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) {
@@ -3034,6 +3126,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)) {
@@ -3053,6 +3147,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 {
@@ -3150,6 +3250,13 @@ var init_BaichuanVideoStream = __esm({
           }
         }
         this.active = false;
+        if (this.detectionTeardown) {
+          try {
+            this.detectionTeardown();
+          } catch {
+          }
+          this.detectionTeardown = void 0;
+        }
         this.emit("close");
       }
       isActive() {
@@ -7377,12 +7484,12 @@ var init_ReolinkCgiApi = __esm({
           "getVideoclipThumbnailJpeg",
           `Extracting thumbnail from VOD URL (FLV): ${vodUrl.substring(0, 100)}... (seek=${seekSeconds}s)`
         );
-        const { spawn: spawn12 } = await import("child_process");
+        const { spawn: spawn13 } = await import("child_process");
         return new Promise((resolve, reject) => {
           const chunks = [];
           let stderr = "";
           let timedOut = false;
-          const ffmpeg = spawn12(ffmpegPath, [
+          const ffmpeg = spawn13(ffmpegPath, [
             "-y",
             "-analyzeduration",
             "10000000",
@@ -8040,6 +8147,7 @@ __export(index_exports, {
   BC_CMD_ID_GET_SUPPORT: () => BC_CMD_ID_GET_SUPPORT,
   BC_CMD_ID_GET_SYSTEM_GENERAL: () => BC_CMD_ID_GET_SYSTEM_GENERAL,
   BC_CMD_ID_GET_TIMELAPSE_CFG: () => BC_CMD_ID_GET_TIMELAPSE_CFG,
+  BC_CMD_ID_GET_VERSION_INFO: () => BC_CMD_ID_GET_VERSION_INFO,
   BC_CMD_ID_GET_VIDEO_INPUT: () => BC_CMD_ID_GET_VIDEO_INPUT,
   BC_CMD_ID_GET_WHITE_LED: () => BC_CMD_ID_GET_WHITE_LED,
   BC_CMD_ID_GET_WIFI: () => BC_CMD_ID_GET_WIFI,
@@ -8070,6 +8178,7 @@ __export(index_exports, {
   BC_CMD_ID_SET_ENC: () => BC_CMD_ID_SET_ENC,
   BC_CMD_ID_SET_LED_STATE: () => BC_CMD_ID_SET_LED_STATE,
   BC_CMD_ID_SET_MOTION_ALARM: () => BC_CMD_ID_SET_MOTION_ALARM,
+  BC_CMD_ID_SET_OSD_DATETIME: () => BC_CMD_ID_SET_OSD_DATETIME,
   BC_CMD_ID_SET_PIR_INFO: () => BC_CMD_ID_SET_PIR_INFO,
   BC_CMD_ID_SET_PRIVACY_MASK: () => BC_CMD_ID_SET_PRIVACY_MASK,
   BC_CMD_ID_SET_PUSH_TASK: () => BC_CMD_ID_SET_PUSH_TASK,
@@ -8178,6 +8287,7 @@ __export(index_exports, {
   decideSleepInferenceTransition: () => decideSleepInferenceTransition,
   decideVideoclipTranscodeMode: () => decideVideoclipTranscodeMode,
   decodeHeader: () => decodeHeader,
+  decodeMotionScopeBitmap: () => decodeMotionScopeBitmap,
   deriveAesKey: () => deriveAesKey,
   detectIosClient: () => detectIosClient,
   detectVideoCodecFromNal: () => detectVideoCodecFromNal,
@@ -8190,6 +8300,7 @@ __export(index_exports, {
   discoverViaUdpBroadcast: () => discoverViaUdpBroadcast,
   discoverViaUdpDirect: () => discoverViaUdpDirect,
   encodeHeader: () => encodeHeader,
+  encodeMotionScopeBitmap: () => encodeMotionScopeBitmap,
   ensureXmlHeader: () => ensureXmlHeader,
   extractH264ParamSetsFromAccessUnit: () => extractH264ParamSetsFromAccessUnit,
   extractH265ParamSetsFromAccessUnit: () => extractH265ParamSetsFromAccessUnit,
@@ -8198,6 +8309,7 @@ __export(index_exports, {
   extractVpsFromAnnexB: () => extractVpsFromAnnexB,
   flattenAbilitiesForChannel: () => flattenAbilitiesForChannel,
   formatMjpegFrame: () => formatMjpegFrame,
+  fullCoverageScope: () => fullCoverageScope,
   getConstructedVideoStreamOptions: () => getConstructedVideoStreamOptions,
   getGlobalLogger: () => getGlobalLogger,
   getH265NalType: () => getH265NalType,
@@ -8241,6 +8353,7 @@ __export(index_exports, {
   splitAnnexBToNals: () => splitAnnexBToNals,
   splitH265AnnexBToNalPayloads: () => splitAnnexBToNalPayloads2,
   testChannelStreams: () => testChannelStreams,
+  upsertXmlTag: () => upsertXmlTag,
   xmlEscape: () => xmlEscape,
   xmlIndicatesFloodlight: () => xmlIndicatesFloodlight,
   zipDirectory: () => zipDirectory
@@ -9969,6 +10082,23 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.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.
    *
@@ -10083,6 +10213,29 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.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;
@@ -10097,6 +10250,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.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);
@@ -10353,6 +10507,18 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.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.
@@ -10817,6 +10983,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.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();
   }
@@ -11133,6 +11300,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
         this.logDebug("udp_close_error", e);
       }
     }
+    this.unregisterFromDeviceClients();
   }
   handleFrame(frame) {
     const now = Date.now();
@@ -16410,6 +16578,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();
@@ -16716,6 +16910,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 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();
@@ -18839,6 +19231,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;
@@ -20274,6 +20681,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;
@@ -20656,6 +21262,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();
@@ -21003,6 +21612,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 };
@@ -23663,7 +24319,7 @@ ${stderr}`)
    * Convert a raw video keyframe to JPEG using ffmpeg.
    */
   async convertFrameToJpeg(params) {
-    const { spawn: spawn12 } = await import("child_process");
+    const { spawn: spawn13 } = await import("child_process");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const inputFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     return new Promise((resolve, reject) => {
@@ -23685,7 +24341,7 @@ ${stderr}`)
         "2",
         "pipe:1"
       ];
-      const proc = spawn12(ffmpeg, args, {
+      const proc = spawn13(ffmpeg, args, {
         stdio: ["pipe", "pipe", "pipe"]
       });
       const chunks = [];
@@ -23828,7 +24484,7 @@ ${stderr}`)
    * Internal helper to mux video+audio into MP4 using ffmpeg.
    */
   async muxToMp4(params) {
-    const { spawn: spawn12 } = await import("child_process");
+    const { spawn: spawn13 } = await import("child_process");
     const { randomUUID: randomUUID3 } = await import("crypto");
     const fs6 = await import("fs/promises");
     const os2 = await import("os");
@@ -23880,7 +24536,7 @@ ${stderr}`)
         outputPath
       );
       await new Promise((resolve, reject) => {
-        const p = spawn12(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
+        const p = spawn13(ffmpeg, args, { stdio: ["ignore", "ignore", "pipe"] });
         let stderr = "";
         p.stderr.on("data", (d) => {
           stderr += d.toString();
@@ -24687,6 +25343,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;
@@ -25338,22 +26015,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({
@@ -26697,12 +27414,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);
@@ -26719,6 +27448,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,
@@ -27326,6 +28056,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,
@@ -27518,6 +28313,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,
@@ -34596,6 +35426,17 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   // Native stream
   nativeFanout = null;
   nativeStreamActive = false;
+  // Set only by stopNativeStream() (explicit teardown) so the fanout's onEnd
+  // callback can short-circuit cleanup/restart logic. NOT set by the inactivity-
+  // timeout force-restart path — that flow wants onEnd to run and decide
+  // whether to restart based on prestartStream / connected clients.
+  nativeStreamStopping = false;
+  // Pending retry timer for the unbounded auto-restart loop. When a stream
+  // start fails transiently (camera in maintenance reboot, idle-disconnect
+  // race, etc.) we keep trying with exponential backoff until either the
+  // server is stopped or a frame finally arrives.
+  nativeStreamRetryTimer;
+  nativeStreamRetryDelayMs = 0;
   dedicatedSessionRelease;
   detectedVideoType;
   // Client tracking
@@ -34664,6 +35505,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     if (!this.active) return;
     this.active = false;
     clearTimeout(this.stopGraceTimer);
+    this.clearNativeStreamRetry();
     this.stopStreamHealthMonitor();
     for (const [id, sock] of this.clientSockets) {
       sock.destroy();
@@ -34992,6 +35834,46 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   // -----------------------------------------------------------------------
   // Native stream management
   // -----------------------------------------------------------------------
+  /**
+   * Schedule another startNativeStream() attempt after the given delay.
+   * Idempotent: a no-op if a retry is already scheduled, the server is no
+   * longer active, or an explicit stop is in progress. Implements unbounded
+   * exponential backoff (5s → 60s) so a camera that stays unreachable for
+   * minutes (e.g. nightly maintenance reboot) eventually recovers without
+   * manual intervention — see issue #16.
+   */
+  scheduleNativeStreamRetry(reason) {
+    if (!this.active) return;
+    if (this.nativeStreamStopping) return;
+    if (this.nativeStreamRetryTimer) return;
+    const delay = this.nativeStreamRetryDelayMs > 0 ? this.nativeStreamRetryDelayMs : 5e3;
+    this.logger.info?.(
+      `[Go2rtcTcpServer] scheduling native stream retry in ${(delay / 1e3).toFixed(0)}s (reason=${reason})`
+    );
+    this.nativeStreamRetryTimer = setTimeout(() => {
+      this.nativeStreamRetryTimer = void 0;
+      if (!this.active) return;
+      if (this.nativeStreamStopping) return;
+      this.startNativeStream().catch((err) => {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] retry of startNativeStream threw: ${err instanceof Error ? err.message : err}`
+        );
+      });
+    }, delay);
+    this.nativeStreamRetryDelayMs = Math.min(delay * 2, 6e4);
+  }
+  /**
+   * Cancel any pending retry timer and reset the backoff. Called on explicit
+   * stop and on first-frame-received so the next failure starts the backoff
+   * window from scratch.
+   */
+  clearNativeStreamRetry() {
+    if (this.nativeStreamRetryTimer) {
+      clearTimeout(this.nativeStreamRetryTimer);
+      this.nativeStreamRetryTimer = void 0;
+    }
+    this.nativeStreamRetryDelayMs = 0;
+  }
   async startNativeStream() {
     if (this.nativeStreamActive) return;
     if (!this.api.isReady) {
@@ -35008,8 +35890,9 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         await this.api.ensureConnected();
       } catch (e) {
         this.logger.warn?.(
-          `[Go2rtcTcpServer] ensureConnected failed, aborting stream start: ${e}`
+          `[Go2rtcTcpServer] ensureConnected failed: ${e}`
         );
+        this.scheduleNativeStreamRetry("ensureConnected failed");
         return;
       }
     }
@@ -35039,6 +35922,9 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         ...dedicatedClient ? { client: dedicatedClient } : {}
       }),
       onFrame: (frame) => {
+        if (!hadFrames) {
+          this.clearNativeStreamRetry();
+        }
         hadFrames = true;
         this.lastFrameAt = Date.now();
         this.totalFramesReceived++;
@@ -35082,7 +35968,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         this.logger.warn?.(`[Go2rtcTcpServer] native stream error: ${error}`);
       },
       onEnd: () => {
-        if (!this.nativeStreamActive) return;
+        if (this.nativeStreamStopping) return;
         this.nativeStreamActive = false;
         this.nativeFanout = null;
         this.stopStreamHealthMonitor();
@@ -35124,18 +36010,24 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     this.startStreamHealthMonitor();
   }
   async stopNativeStream() {
+    this.nativeStreamStopping = true;
     this.nativeStreamActive = false;
+    this.clearNativeStreamRetry();
     this.stopStreamHealthMonitor();
     const fanout = this.nativeFanout;
     this.nativeFanout = null;
-    if (fanout) {
-      await fanout.stop();
-    }
-    this.prebuffer = [];
-    if (this.dedicatedSessionRelease) {
-      await this.dedicatedSessionRelease().catch(() => {
-      });
-      this.dedicatedSessionRelease = void 0;
+    try {
+      if (fanout) {
+        await fanout.stop();
+      }
+      this.prebuffer = [];
+      if (this.dedicatedSessionRelease) {
+        await this.dedicatedSessionRelease().catch(() => {
+        });
+        this.dedicatedSessionRelease = void 0;
+      }
+    } finally {
+      this.nativeStreamStopping = false;
     }
   }
   // -----------------------------------------------------------------------
@@ -35325,10 +36217,15 @@ var BaichuanHttpStreamServer = class extends import_node_events7.EventEmitter {
       // Force a known frame rate on raw H.264 input so the muxer gets valid PTS/DTS.
       "-r",
       String(this.inputFps),
+      // `+genpts` generates uniform PTS from `-r` for raw Annex-B input. We
+      // deliberately do NOT pass `-use_wallclock_as_timestamps 1`: that
+      // overrides the generated PTS with the host wallclock at frame ARRIVAL
+      // time, and the network stream is bursty so the resulting PTS is
+      // uneven. With `-r` forcing a target rate downstream, ffmpeg then
+      // drops/duplicates frames to match — visible as the periodic stutter
+      // reported on local-restreamer recordings (issue #11).
       "-fflags",
       "+genpts",
-      "-use_wallclock_as_timestamps",
-      "1",
       "-f",
       "h264",
       // Input format (H.264 Annex-B)
@@ -36007,8 +36904,195 @@ var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-var import_node_events10 = require("events");
+var import_node_events11 = require("events");
 init_BcMediaAnnexBDecoder();
+
+// src/baichuan/stream/AacToOpusTranscoder.ts
+var import_node_child_process11 = require("child_process");
+var import_node_dgram3 = require("dgram");
+var import_node_events10 = require("events");
+var AacToOpusTranscoder = class extends import_node_events10.EventEmitter {
+  opts;
+  socket = null;
+  ffmpeg = null;
+  port = 0;
+  starting = null;
+  stopped = false;
+  constructor(options = {}) {
+    super();
+    this.opts = {
+      ffmpegPath: options.ffmpegPath ?? "ffmpeg",
+      opusSampleRate: options.opusSampleRate ?? 48e3,
+      opusChannels: options.opusChannels ?? 2,
+      opusFrameMs: options.opusFrameMs ?? 20,
+      opusBitrate: options.opusBitrate ?? 64e3,
+      ...options.logger !== void 0 ? { logger: options.logger } : {}
+    };
+  }
+  log(level, message) {
+    this.opts.logger?.(level, `[AacToOpusTranscoder] ${message}`);
+  }
+  /**
+   * Allocate the UDP loopback socket and spawn ffmpeg. Must be awaited before
+   * the first call to `feedAac`.
+   */
+  async start() {
+    if (this.starting) return this.starting;
+    this.starting = this._start();
+    return this.starting;
+  }
+  async _start() {
+    if (this.stopped) throw new Error("transcoder stopped");
+    this.socket = (0, import_node_dgram3.createSocket)("udp4");
+    await new Promise((resolve, reject) => {
+      this.socket.once("error", reject);
+      this.socket.bind({ address: "127.0.0.1", port: 0 }, () => {
+        this.socket.removeListener("error", reject);
+        this.port = this.socket.address().port;
+        resolve();
+      });
+    });
+    this.log("info", `UDP loopback bound on 127.0.0.1:${this.port}`);
+    this.socket.on("message", (rtpPacket) => this.handleRtp(rtpPacket));
+    this.socket.on("error", (err) => {
+      this.log("error", `socket error: ${err.message}`);
+      this.emit("error", err);
+    });
+    const args = [
+      "-loglevel",
+      "warning",
+      "-fflags",
+      "nobuffer",
+      "-f",
+      "aac",
+      "-i",
+      "pipe:0",
+      "-c:a",
+      "libopus",
+      "-ar",
+      String(this.opts.opusSampleRate),
+      "-ac",
+      String(this.opts.opusChannels),
+      "-application",
+      "audio",
+      "-frame_duration",
+      String(this.opts.opusFrameMs),
+      "-b:a",
+      String(this.opts.opusBitrate),
+      // Important: disable VBR so the output rate matches the configured
+      // bitrate consistently — easier on the browser jitter buffer.
+      "-vbr",
+      "off",
+      "-f",
+      "rtp",
+      `rtp://127.0.0.1:${this.port}`
+    ];
+    this.log("info", `spawning ffmpeg with: ${this.opts.ffmpegPath} ${args.join(" ")}`);
+    this.ffmpeg = (0, import_node_child_process11.spawn)(this.opts.ffmpegPath, args, {
+      stdio: ["pipe", "ignore", "pipe"]
+    });
+    this.ffmpeg.on("error", (err) => {
+      this.log("error", `ffmpeg spawn error: ${err.message}`);
+      this.emit("error", err);
+    });
+    this.ffmpeg.stderr?.on("data", (chunk) => {
+      this.log("debug", `ffmpeg stderr: ${chunk.toString().trim()}`);
+    });
+    this.ffmpeg.on("exit", (code) => {
+      this.log(code === 0 ? "info" : "warn", `ffmpeg exited code=${code}`);
+      this.emit("exit", code);
+    });
+  }
+  /**
+   * Feed one or more concatenated ADTS AAC frames to ffmpeg. Returns the
+   * number of bytes written. Safe to call before a frame is fully buffered.
+   */
+  feedAac(buf) {
+    if (this.stopped) return false;
+    if (!this.ffmpeg?.stdin || !this.ffmpeg.stdin.writable) {
+      this.log("debug", "drop AAC frame \u2014 ffmpeg stdin not writable");
+      return false;
+    }
+    return this.ffmpeg.stdin.write(buf);
+  }
+  /**
+   * Close stdin (ffmpeg exits cleanly on EOF) and tear down the UDP socket.
+   */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    try {
+      this.ffmpeg?.stdin?.end();
+    } catch {
+    }
+    if (this.ffmpeg && this.ffmpeg.exitCode === null) {
+      await new Promise((resolve) => {
+        const t = setTimeout(() => {
+          this.ffmpeg?.kill("SIGKILL");
+          resolve();
+        }, 500);
+        this.ffmpeg?.once("exit", () => {
+          clearTimeout(t);
+          resolve();
+        });
+      });
+    }
+    this.ffmpeg = null;
+    if (this.socket) {
+      try {
+        this.socket.close();
+      } catch {
+      }
+      this.socket = null;
+    }
+    this.log("info", "stopped");
+  }
+  /**
+   * Parse an RTP packet ffmpeg emitted on the loopback socket and surface
+   * its Opus payload. RTP header layout (RFC 3550):
+   *
+   *   0                   1                   2                   3
+   *   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+   *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   *  |V=2|P|X|  CC   |M|     PT      |       sequence number         |
+   *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   *  |                           timestamp                           |
+   *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   *  |           synchronization source (SSRC) identifier            |
+   *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   *
+   * We honor the CC, X (extension) and P (padding) bits to compute the
+   * payload offset / length correctly even if ffmpeg ever emits those.
+   */
+  handleRtp(packet) {
+    if (packet.length < 12) return;
+    const b0 = packet[0];
+    const b1 = packet[1];
+    const version = b0 >> 6;
+    if (version !== 2) return;
+    const padding = (b0 & 32) !== 0;
+    const extension = (b0 & 16) !== 0;
+    const csrcCount = b0 & 15;
+    const marker = (b1 & 128) !== 0;
+    let offset = 12 + csrcCount * 4;
+    if (extension) {
+      if (packet.length < offset + 4) return;
+      const extLen = packet.readUInt16BE(offset + 2);
+      offset += 4 + extLen * 4;
+    }
+    let end = packet.length;
+    if (padding) {
+      const pad = packet[packet.length - 1];
+      end -= pad;
+    }
+    if (offset >= end) return;
+    const timestamp = packet.readUInt32BE(4);
+    const payload = Buffer.from(packet.subarray(offset, end));
+    this.emit("packet", { payload, timestamp, marker });
+  }
+};
+
+// src/baichuan/stream/BaichuanWebRTCServer.ts
 init_H264Converter();
 function parseAnnexBNalUnits(annexB) {
   const nalUnits = [];
@@ -36044,7 +37128,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends import_node_events10.EventEmitter {
+var BaichuanWebRTCServer = class extends import_node_events11.EventEmitter {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -36282,6 +37366,14 @@ Error: ${err}`
       }
       session.dataChannel = null;
     }
+    if (session.audioTranscoder) {
+      try {
+        await session.audioTranscoder.stop();
+      } catch (err) {
+        this.log("debug", `Error stopping audio transcoder: ${err}`);
+      }
+      session.audioTranscoder = null;
+    }
     if (session.cleanup) {
       session.cleanup();
     }
@@ -36408,6 +37500,17 @@ Error: ${err}`
         }
         if (frame.audio) {
           session.stats.audioFrames++;
+          if (session.stats.audioFrames === 1) {
+            const head = frame.data && frame.data.length > 0 ? frame.data.subarray(0, Math.min(8, frame.data.length)).toString("hex") : "(empty)";
+            this.log(
+              "info",
+              `First audio frame for ${session.id}: codec=${frame.codec ?? "?"} bytes=${frame.data?.length ?? 0} head=${head}`
+            );
+          }
+          if (this.options.ffmpegPath !== "" && frame.data && frame.data.length > 0) {
+            await this.ensureAudioTranscoder(session, werift);
+            session.audioTranscoder?.feedAac(frame.data);
+          }
         } else {
           if (frame.data) {
             if (!session.videoCodec && frame.videoType) {
@@ -36478,7 +37581,7 @@ Error: ${err}`
             if (now - lastLogTime >= 5e3) {
               this.log(
                 "debug",
-                `WebRTC session ${session.id} [${session.videoCodec}]: sent ${session.stats.videoFrames} frames, ${packetsSentSinceLastLog} packets, ${Math.round(session.stats.bytesSent / 1024)} KB`
+                `WebRTC session ${session.id} [${session.videoCodec}]: sent ${session.stats.videoFrames} video frames, ${packetsSentSinceLastLog} packets, ${Math.round(session.stats.bytesSent / 1024)} KB | audio frames=${session.stats.audioFrames}`
               );
               lastLogTime = now;
               packetsSentSinceLastLog = 0;
@@ -36494,6 +37597,77 @@ Error: ${err}`
     }
     this.log("info", `Native stream ended for session ${session.id}`);
   }
+  /**
+   * Lazily start the AAC → Opus transcoder for `session` and wire it to the
+   * audio RTP track. ffmpeg writes RTP-formatted Opus packets back to a UDP
+   * loopback the transcoder owns; we strip the RTP header and rewrap the
+   * Opus payload with our audioTrack's SSRC so the browser receives a
+   * coherent stream.
+   */
+  async ensureAudioTranscoder(session, werift) {
+    if (session.audioTranscoder !== void 0) return;
+    const { RtpPacket, RtpHeader } = werift;
+    const ssrc = session.audioTrack?.ssrc ?? Math.floor(Math.random() * 4294967295);
+    const transcoder = new AacToOpusTranscoder({
+      ...this.options.ffmpegPath ? { ffmpegPath: this.options.ffmpegPath } : {},
+      logger: (level, msg) => this.log(level, msg)
+    });
+    session.audioRtpSequence = Math.floor(Math.random() * 65535);
+    session.audioRtpTimestampBase = 0;
+    transcoder.on("packet", ({ payload, timestamp, marker }) => {
+      try {
+        if (session.audioRtpTimestampBase === void 0 || session.audioRtpTimestampBase === 0) {
+          session.audioRtpTimestampBase = timestamp;
+        }
+        const localTs = timestamp - session.audioRtpTimestampBase >>> 0;
+        const seq = session.audioRtpSequence;
+        session.audioRtpSequence = seq + 1 & 65535;
+        const header = new RtpHeader({
+          version: 2,
+          padding: false,
+          extension: false,
+          marker,
+          // Werift assigns 111 to Opus by default in the receiver SDP, but it
+          // also accepts other PTs. Use 111 for compatibility with the offer
+          // we generated earlier.
+          payloadType: 111,
+          sequenceNumber: seq,
+          timestamp: localTs,
+          ssrc
+        });
+        const rtp = new RtpPacket(header, payload);
+        session.audioTrack?.writeRtp(rtp);
+        if (!session.audioStartedLogged) {
+          session.audioStartedLogged = true;
+          this.log(
+            "info",
+            `Audio RTP started for ${session.id} (PT=111, ssrc=${ssrc})`
+          );
+        }
+      } catch (err) {
+        this.log(
+          "warn",
+          `audio writeRtp failed for ${session.id}: ${err.message}`
+        );
+      }
+    });
+    transcoder.on("error", (err) => {
+      this.log("error", `audio transcoder error for ${session.id}: ${err.message}`);
+    });
+    transcoder.on("exit", (code) => {
+      this.log("info", `audio transcoder exited (${code}) for ${session.id}`);
+    });
+    try {
+      await transcoder.start();
+      session.audioTranscoder = transcoder;
+    } catch (err) {
+      this.log(
+        "error",
+        `failed to start audio transcoder for ${session.id}: ${err.message}`
+      );
+      session.audioTranscoder = null;
+    }
+  }
   /**
    * Send H.264 frame via RTP media track
    * Returns the number of RTP packets sent
@@ -36781,21 +37955,21 @@ Error: ${err}`
         `Sending ${codec} frame ${frameNumber}: ${packet.length} bytes, keyframe=${isKeyframe}`
       );
     }
-    const MAX_CHUNK_SIZE = 16e3;
+    const CHUNK_HEADER_LEN = 4;
+    const MAX_PAYLOAD_PER_CHUNK = 16e3 - CHUNK_HEADER_LEN;
     try {
-      if (packet.length <= MAX_CHUNK_SIZE) {
-        session.videoDataChannel.send(packet);
-      } else {
-        const totalChunks = Math.ceil(packet.length / MAX_CHUNK_SIZE);
-        for (let i = 0; i < totalChunks; i++) {
-          const start = i * MAX_CHUNK_SIZE;
-          const end = Math.min(start + MAX_CHUNK_SIZE, packet.length);
-          const chunk = packet.subarray(start, end);
-          const chunkHeader = Buffer.alloc(2);
-          chunkHeader.writeUInt8(i, 0);
-          chunkHeader.writeUInt8(totalChunks, 1);
-          session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
-        }
+      const totalChunks = Math.max(
+        1,
+        Math.ceil(packet.length / MAX_PAYLOAD_PER_CHUNK)
+      );
+      for (let i = 0; i < totalChunks; i++) {
+        const start = i * MAX_PAYLOAD_PER_CHUNK;
+        const end = Math.min(start + MAX_PAYLOAD_PER_CHUNK, packet.length);
+        const chunk = packet.subarray(start, end);
+        const chunkHeader = Buffer.alloc(CHUNK_HEADER_LEN);
+        chunkHeader.writeUInt16BE(i, 0);
+        chunkHeader.writeUInt16BE(totalChunks, 2);
+        session.videoDataChannel.send(Buffer.concat([chunkHeader, chunk]));
       }
       return true;
     } catch (err) {
@@ -36946,12 +38120,12 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-var import_node_events11 = require("events");
+var import_node_events12 = require("events");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 init_BcMediaAnnexBDecoder();
 init_H264Converter();
 init_H265Converter();
@@ -37026,7 +38200,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events11.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events12.EventEmitter {
   api;
   channel;
   profile;
@@ -37383,10 +38557,17 @@ var BaichuanHlsServer = class extends import_node_events11.EventEmitter {
       "-hide_banner",
       "-loglevel",
       "warning",
+      // `+genpts` makes ffmpeg generate uniform PTS from the declared `-r`
+      // when the raw H.264/H.265 input has none. We deliberately do NOT use
+      // `-use_wallclock_as_timestamps 1` here: it replaces the generated
+      // PTS with the host wallclock at FRAME ARRIVAL time, and because the
+      // camera ships frames in bursty network reads, the resulting PTS
+      // sequence is uneven. With `-r 25` (or anything else) forcing a
+      // target rate downstream, ffmpeg then drops/duplicates frames to
+      // match — visible as the periodic stutter / pulsing reported on
+      // local-restreamer recordings (issue #11).
       "-fflags",
       "+genpts",
-      "-use_wallclock_as_timestamps",
-      "1",
       "-r",
       "25",
       "-f",
@@ -37421,7 +38602,7 @@ var BaichuanHlsServer = class extends import_node_events11.EventEmitter {
       this.segmentPattern,
       this.playlistPath
     );
-    const p = (0, import_node_child_process11.spawn)(this.ffmpegPath, args, {
+    const p = (0, import_node_child_process12.spawn)(this.ffmpegPath, args, {
       stdio: ["pipe", "ignore", "pipe"]
     });
     p.on("error", (err) => {
@@ -38043,10 +39224,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events12 = require("events");
-var import_node_child_process12 = require("child_process");
+var import_node_events13 = require("events");
+var import_node_child_process13 = require("child_process");
 var net5 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events12.EventEmitter {
+var CompositeRtspServer = class extends import_node_events13.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -38151,7 +39332,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process12.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process13.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -38259,6 +39440,86 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
     return this.connectedClients.size;
   }
 };
+
+// src/reolink/baichuan/utils/motionZone.ts
+function decodeMotionScopeBitmap(valueTable, columns, rows, width = columns, height = rows) {
+  const trimmed = valueTable.trim().replace(/[^A-Za-z0-9+/=]/g, "");
+  const bytes = base64DecodeToBytes(trimmed);
+  const totalBits = columns * rows;
+  if (bytes.length * 8 < totalBits) {
+    throw new Error(
+      `valueTable too short: have ${bytes.length * 8} bits, need ${totalBits}`
+    );
+  }
+  const w = Math.min(width, columns);
+  const h = Math.min(height, rows);
+  const cells = new Array(w * h);
+  for (let r = 0; r < h; r++) {
+    for (let c = 0; c < w; c++) {
+      const bitIndex = r * columns + c;
+      const byteIdx = bitIndex >> 3;
+      const bitIdx = 7 - (bitIndex & 7);
+      cells[r * w + c] = (bytes[byteIdx] ?? 0) >> bitIdx & 1 ? true : false;
+    }
+  }
+  return { width: w, height: h, columns, rows, cells };
+}
+function encodeMotionScopeBitmap(scope) {
+  const bytes = new Uint8Array(Math.ceil(scope.columns * scope.rows / 8));
+  for (let r = 0; r < scope.height; r++) {
+    for (let c = 0; c < scope.width; c++) {
+      const on = scope.cells[r * scope.width + c];
+      if (!on) continue;
+      const bitIndex = r * scope.columns + c;
+      const byteIdx = bitIndex >> 3;
+      const bitIdx = 7 - (bitIndex & 7);
+      bytes[byteIdx] = (bytes[byteIdx] ?? 0) | 1 << bitIdx;
+    }
+  }
+  return base64EncodeBytes(bytes);
+}
+function fullCoverageScope(columns, rows, width = columns, height = rows) {
+  return {
+    width,
+    height,
+    columns,
+    rows,
+    cells: new Array(width * height).fill(true)
+  };
+}
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64EncodeBytes(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i] ?? 0;
+    const b1 = bytes[i + 1] ?? 0;
+    const b2 = bytes[i + 2] ?? 0;
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | b1 >> 4];
+    out += i + 1 < bytes.length ? B64_ALPHABET[(b1 & 15) << 2 | b2 >> 6] : "=";
+    out += i + 2 < bytes.length ? B64_ALPHABET[b2 & 63] : "=";
+  }
+  return out;
+}
+function base64DecodeToBytes(b64) {
+  const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, "=");
+  const stripped = padded.replace(/=+$/, "");
+  const out = new Uint8Array(Math.floor(stripped.length * 6 / 8));
+  let bits = 0;
+  let value = 0;
+  let outIdx = 0;
+  for (const ch of stripped) {
+    const idx = B64_ALPHABET.indexOf(ch);
+    if (idx < 0) continue;
+    value = value << 6 | idx;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[outIdx++] = value >> bits & 255;
+    }
+  }
+  return out.subarray(0, outIdx);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AesStreamDecryptor,
@@ -38336,6 +39597,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   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,
@@ -38366,6 +39628,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   BC_CMD_ID_SET_ENC,
   BC_CMD_ID_SET_LED_STATE,
   BC_CMD_ID_SET_MOTION_ALARM,
+  BC_CMD_ID_SET_OSD_DATETIME,
   BC_CMD_ID_SET_PIR_INFO,
   BC_CMD_ID_SET_PRIVACY_MASK,
   BC_CMD_ID_SET_PUSH_TASK,
@@ -38474,6 +39737,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   decideSleepInferenceTransition,
   decideVideoclipTranscodeMode,
   decodeHeader,
+  decodeMotionScopeBitmap,
   deriveAesKey,
   detectIosClient,
   detectVideoCodecFromNal,
@@ -38486,6 +39750,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   discoverViaUdpBroadcast,
   discoverViaUdpDirect,
   encodeHeader,
+  encodeMotionScopeBitmap,
   ensureXmlHeader,
   extractH264ParamSetsFromAccessUnit,
   extractH265ParamSetsFromAccessUnit,
@@ -38494,6 +39759,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   extractVpsFromAnnexB,
   flattenAbilitiesForChannel,
   formatMjpegFrame,
+  fullCoverageScope,
   getConstructedVideoStreamOptions,
   getGlobalLogger,
   getH265NalType,
@@ -38537,6 +39803,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   splitAnnexBToNals,
   splitH265AnnexBToNalPayloads,
   testChannelStreams,
+  upsertXmlTag,
   xmlEscape,
   xmlIndicatesFloodlight,
   zipDirectory