@apocaliss92/nodelink-js 0.1.20 → 0.2.2

package/dist/{chunk-EHWVA3SG.js → chunk-MN7GUZT7.js}

@@ -10,6 +10,8 @@ import {
   BC_CMD_ID_CMD_209,
   BC_CMD_ID_CMD_265,
   BC_CMD_ID_CMD_440,
+  BC_CMD_ID_DING_DONG_CTRL,
+  BC_CMD_ID_DING_DONG_OPT,
   BC_CMD_ID_FILE_INFO_LIST_CLOSE,
   BC_CMD_ID_FILE_INFO_LIST_DL_VIDEO,
   BC_CMD_ID_FILE_INFO_LIST_DOWNLOAD,
@@ -33,6 +35,9 @@ import {
   BC_CMD_ID_GET_BATTERY_INFO_LIST,
   BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
   BC_CMD_ID_GET_DAY_RECORDS,
+  BC_CMD_ID_GET_DING_DONG_CFG,
+  BC_CMD_ID_GET_DING_DONG_LIST,
+  BC_CMD_ID_GET_DING_DONG_SILENT,
   BC_CMD_ID_GET_EMAIL_TASK,
   BC_CMD_ID_GET_FTP_TASK,
   BC_CMD_ID_GET_HDD_INFO_LIST,
@@ -68,9 +73,12 @@ import {
   BC_CMD_ID_PUSH_SERIAL,
   BC_CMD_ID_PUSH_SLEEP_STATUS,
   BC_CMD_ID_PUSH_VIDEO_INPUT,
+  BC_CMD_ID_QUICK_REPLY_PLAY,
   BC_CMD_ID_SET_AI_ALARM,
   BC_CMD_ID_SET_AI_CFG,
   BC_CMD_ID_SET_AUDIO_TASK,
+  BC_CMD_ID_SET_DING_DONG_CFG,
+  BC_CMD_ID_SET_DING_DONG_SILENT,
   BC_CMD_ID_SET_MOTION_ALARM,
   BC_CMD_ID_SET_PIR_INFO,
   BC_CMD_ID_SET_WHITE_LED_STATE,
@@ -136,7 +144,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-YPU7RAEY.js";
+} from "./chunk-NLTB7GTA.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -1807,6 +1815,13 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    *   and may leave device-side sessions in a bad state.
    */
   static coverPreviewQueueTail = /* @__PURE__ */ new Map();
+  /**
+   * Global CoverPreview backoff – increases on 400 rejection, resets on success.
+   * Prevents flooding the camera when it's overwhelmed.
+   */
+  static coverPreviewBackoffMs = /* @__PURE__ */ new Map();
+  static COVER_PREVIEW_INITIAL_BACKOFF_MS = 1e3;
+  static COVER_PREVIEW_MAX_BACKOFF_MS = 3e4;
   opts;
   debugCfg;
   logger;
@@ -1954,7 +1969,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     if (!this.isIdleDisconnectEnabled()) return false;
     if (!this.isSocketConnected()) return false;
     if (this.pending.size > 0) return false;
-    if (this.hasActiveVideoSubscriptionsInternal()) return false;
+    if (this.isDeviceStreamingActive()) return false;
     if (this.permits.size > 0) return false;
     return true;
   }
@@ -1968,7 +1983,18 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     const delayMs = Math.max(0, timeoutMs - elapsedMs);
     this.idleDisconnectTimer = setTimeout(() => {
       try {
-        if (!this.isIdleDisconnectEligibleNow()) return;
+        if (!this.isIdleDisconnectEligibleNow()) {
+          this.logDebug("idle_disconnect_blocked", {
+            reason: "not eligible",
+            socketConnected: this.isSocketConnected(),
+            pending: this.pending.size,
+            deviceStreamingActive: this.isDeviceStreamingActive(),
+            localVideoSubs: this.hasActiveVideoSubscriptionsInternal(),
+            permits: this.permits.size,
+            host: this.opts.host
+          });
+          return;
+        }
         if (this.lastUserActivityAtMs == null) return;
         const elapsed2 = Date.now() - this.lastUserActivityAtMs;
         if (elapsed2 < timeoutMs) {
@@ -2082,7 +2108,34 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   async withSerializedCoverPreview(fn) {
     const key = this.getCoverPreviewQueueKey();
     const prevTail = _BaichuanClient.coverPreviewQueueTail.get(key) ?? Promise.resolve();
-    const run = prevTail.catch(() => void 0).then(fn);
+    const run = prevTail.catch(() => void 0).then(async () => {
+      const backoffMs = _BaichuanClient.coverPreviewBackoffMs.get(key) ?? 0;
+      if (backoffMs > 0) {
+        this.logDebug("coverpreview_backoff_wait", { backoffMs });
+        await new Promise((r) => setTimeout(r, backoffMs));
+      }
+      try {
+        const result = await fn();
+        _BaichuanClient.coverPreviewBackoffMs.delete(key);
+        return result;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        const is400 = msg.includes("rejected") && (msg.includes("responseCode=400") || msg.includes("resp_code=400"));
+        if (is400) {
+          const current = _BaichuanClient.coverPreviewBackoffMs.get(key) ?? 0;
+          const next = current === 0 ? _BaichuanClient.COVER_PREVIEW_INITIAL_BACKOFF_MS : Math.min(
+            current * 2,
+            _BaichuanClient.COVER_PREVIEW_MAX_BACKOFF_MS
+          );
+          _BaichuanClient.coverPreviewBackoffMs.set(key, next);
+          this.logDebug("coverpreview_backoff_increased", {
+            previous: current,
+            next
+          });
+        }
+        throw e;
+      }
+    });
     const tail = run.then(
       () => void 0,
       () => void 0
@@ -4404,32 +4457,36 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    * Send CoverPreview command (cmd_id=298) to get an I-frame from a past recording.
    * Similar to sendBinarySnapshot109 but handles the stream header + frame format
    * instead of JPEG.
+   *
+   * Retry is minimal (2 attempts) – the global backoff in `withSerializedCoverPreview`
+   * throttles subsequent requests when the camera is overwhelmed.
+   * PCAP analysis shows the camera routinely rejects the first request with 400.
    */
   async sendBinaryCoverPreview(params) {
     return await this.withSerializedCoverPreview(async () => {
-      const maxRetries = params.maxRetries ?? 5;
-      const retryDelayMs = params.retryDelayMs ?? 1e3;
+      const maxAttempts = 5;
+      const retryDelay = 1500;
       let lastError;
-      for (let attempt = 0; attempt < maxRetries; attempt++) {
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
         try {
           return await this._sendBinaryCoverPreviewOnce(params);
         } catch (e) {
           const msg = e instanceof Error ? e.message : String(e);
           lastError = e instanceof Error ? e : new Error(msg);
-          const is400Rejection = msg.includes("rejected") && (msg.includes("responseCode=400") || msg.includes("resp_code=400"));
-          if (is400Rejection && attempt < maxRetries - 1) {
+          const is400 = msg.includes("rejected") && (msg.includes("responseCode=400") || msg.includes("resp_code=400"));
+          if (is400 && attempt < maxAttempts - 1) {
             this.logDebug("coverpreview_retry_400", {
               attempt: attempt + 1,
-              maxRetries,
-              retryDelayMs
+              maxAttempts,
+              retryDelay
             });
-            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            await new Promise((r) => setTimeout(r, retryDelay));
             continue;
           }
           throw lastError;
         }
       }
-      throw lastError ?? new Error("CoverPreview failed after all retries");
+      throw lastError ?? new Error("CoverPreview failed after all attempts");
     });
   }
   /**
@@ -5343,6 +5400,8 @@ var NativeStreamFanout = class {
       } finally {
         for (const q of this.queues.values()) q.close();
         this.queues.clear();
+        this.running = false;
+        this.opts.onEnd?.();
       }
     })();
   }
@@ -5668,7 +5727,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       this.logger.warn(
         `[BaichuanRtspServer] Could not get stream metadata: ${error}`
       );
-      this.streamMetadata = { frameRate: 25, width: 1920, height: 1080 };
+      this.streamMetadata = { frameRate: 25 };
       this.setFlowVideoType("H264", "metadata unavailable");
     }
     this.clientConnectionServer = net2.createServer((socket) => {
@@ -5700,7 +5759,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
    */
   handleRtspConnection(socket) {
     const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
-    this.logger.info(`[BaichuanRtspServer] RTSP client connected: ${clientId}`);
+    const connectTime = Date.now();
+    this.logger.info(
+      `[rebroadcast] client connected  client=${clientId} path=${this.path} profile=${this.profile} channel=${this.channel}`
+    );
     let sessionId = "";
     let buffer = Buffer.alloc(0);
     let clientFfmpeg;
@@ -5708,6 +5770,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     let clientUdpSocket = null;
     let clientUdpSocketAudio = null;
     const cleanup = () => {
+      const sessionDurationMs = Date.now() - connectTime;
+      const res = this.clientResources.get(clientId);
+      const framesSent = res?.framesSent ?? 0;
+      this.logger.info(
+        `[rebroadcast] client disconnected  client=${clientId} path=${this.path} profile=${this.profile} duration=${sessionDurationMs}ms frames=${framesSent}`
+      );
       this.removeClient(clientId);
       this.authNonces.delete(clientId);
       const resources = this.clientResources.get(clientId);
@@ -5849,7 +5917,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             Public: "DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE, OPTIONS"
           });
         } else if (method === "DESCRIBE") {
-          if (!this.firstFrameReceived && this.connectedClients.size === 0) {
+          if (!this.flow.getFmtp().hasParamSets && this.connectedClients.size === 0) {
             try {
               if (!this.nativeStreamActive) {
                 await this.startNativeStream();
@@ -5931,7 +5999,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
               seenFirstVideoKeyframe: false,
               setupTrack0: false,
               setupTrack1: false,
-              isPlaying: false
+              isPlaying: false,
+              connectTime
             });
           } else {
             existing.rtspSocket = socket;
@@ -5978,8 +6047,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             if (resources) {
               if (isTrack1) resources.setupTrack1 = true;
               else resources.setupTrack0 = true;
-              this.rtspDebugLog(
-                `SETUP done for ${clientId}: track0=${!!resources.setupTrack0} track1=${!!resources.setupTrack1} playing=${!!resources.isPlaying}`
+              const transport2 = useTcpInterleaved ? "TCP/interleaved" : "UDP";
+              const track = isTrack1 ? "track1(audio)" : "track0(video)";
+              this.logger.info(
+                `[rebroadcast] SETUP  client=${clientId} ${track} transport=${transport2} session=${sessionId}`
               );
             }
           }
@@ -6004,8 +6075,9 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             const resources = this.clientResources.get(clientId);
             if (resources) {
               resources.isPlaying = true;
-              this.rtspDebugLog(
-                `PLAY for ${clientId}: track0=${!!resources.setupTrack0} track1=${!!resources.setupTrack1} playing=${!!resources.isPlaying}`
+              const hasAudio = !!resources.setupTrack1;
+              this.logger.info(
+                `[rebroadcast] PLAY  client=${clientId} path=${this.path} profile=${this.profile} channel=${this.channel} codec=${this.flow.sdpCodec} audio=${hasAudio} session=${sessionId}`
               );
             }
           }
@@ -6014,6 +6086,9 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             Range: "npt=0.000-"
           });
         } else if (method === "TEARDOWN") {
+          this.logger.info(
+            `[rebroadcast] TEARDOWN  client=${clientId} session=${sessionId}`
+          );
           cleanup();
           sendResponse(200, "OK", {
             Session: sessionId
@@ -6108,7 +6183,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         this.logger.warn(
           `[BaichuanRtspServer] Could not fetch stream metadata: ${error}`
         );
-        streamMetadata = { frameRate: 25, width: 1920, height: 1080 };
+        streamMetadata = { frameRate: 25 };
       }
     }
     const ffmpegFormat = this.flow.ffmpegFormat;
@@ -6696,15 +6771,17 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
               `Sent ${frameCount} frames to client ${clientId} (frame size: ${frame.data.length} bytes)`
             );
           }
-          const now = Date.now();
-          const timeSinceLastFrame = now - lastFrameTime;
-          const waitTime = targetFrameInterval - timeSinceLastFrame;
-          if (waitTime > 0) {
-            await new Promise(
-              (resolve) => setTimeout(resolve, Math.min(waitTime, targetFrameInterval * 2))
-            );
+          if (!useDirectRtp) {
+            const now = Date.now();
+            const timeSinceLastFrame = now - lastFrameTime;
+            const waitTime = targetFrameInterval - timeSinceLastFrame;
+            if (waitTime > 0) {
+              await new Promise(
+                (resolve) => setTimeout(resolve, Math.min(waitTime, targetFrameInterval * 2))
+              );
+            }
+            lastFrameTime = Date.now();
           }
-          lastFrameTime = Date.now();
           if (useDirectRtp) {
             const videoType = frame.videoType ?? this.flow.videoType;
             const normalizedVideoData = videoType === "H264" ? convertToAnnexB(frame.data) : convertToAnnexB2(frame.data);
@@ -6777,6 +6854,11 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             }
             if (!firstVideoWriteLogged) {
               firstVideoWriteLogged = true;
+              const clientConnectTime = resources?.connectTime ?? Date.now();
+              const ttffMs = Date.now() - clientConnectTime;
+              this.logger.info(
+                `[rebroadcast] first keyframe \u2192 client  client=${clientId} codec=${videoType} ttff=${ttffMs}ms`
+              );
               if (rtspDebug) {
                 const headHex = frame.data.subarray(0, 16).toString("hex");
                 rtspDebugLog(
@@ -6784,6 +6866,9 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
                 );
               }
             }
+            if (resources) {
+              resources.framesSent = (resources.framesSent ?? 0) + 1;
+            }
             sendVideoAccessUnit(videoType, normalizedVideoData, true);
           } else {
             try {
@@ -6868,8 +6953,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     this.firstAudioPromise = new Promise((resolve) => {
       this.firstAudioResolve = resolve;
     });
-    this.rtspDebugLog(
-      `Starting native stream for profile ${this.profile} (waiting for camera to start transmitting...)`
+    this.logger.info(
+      `[rebroadcast] native stream starting  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size}`
     );
     await this.flow.startKeepAlive(this.api);
     this.nativeFanout = new NativeStreamFanout({
@@ -6912,6 +6997,23 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         this.logger.warn(
           `[BaichuanRtspServer] Shared native stream error: ${error}`
         );
+      },
+      onEnd: () => {
+        if (!this.nativeStreamActive) return;
+        this.nativeStreamActive = false;
+        this.firstFrameReceived = false;
+        this.firstFramePromise = null;
+        this.firstFrameResolve = null;
+        this.nativeFanout = null;
+        this.logger.info(
+          `[rebroadcast] native stream ended (camera sleeping or connection lost)  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size}`
+        );
+        if (this.connectedClients.size > 0) {
+          this.logger.info(
+            `[rebroadcast] restarting native stream for ${this.connectedClients.size} active client(s)`
+          );
+          setImmediate(() => void this.startNativeStream());
+        }
       }
     });
     this.nativeFanout.start();
@@ -6950,7 +7052,9 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     if (!this.nativeStreamActive) {
       return;
     }
-    this.rtspDebugLog(`Stopping native stream`);
+    this.logger.info(
+      `[rebroadcast] native stream stopping  profile=${this.profile} channel=${this.channel} clients=${this.connectedClients.size}`
+    );
     this.flow.stopKeepAlive();
     this.clearNoClientAutoStopTimer();
     this.nativeStreamActive = false;
@@ -6984,9 +7088,6 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     if (this.connectedClients.has(clientId)) {
       this.connectedClients.delete(clientId);
       this.emit("clientDisconnected", clientId);
-      this.logger.info(
-        `[BaichuanRtspServer] RTSP client disconnected: ${clientId}`
-      );
       if (this.connectedClients.size === 0) {
         void this.stopNativeStream();
       }
@@ -7219,10 +7320,12 @@ function parseSupportXml(xml) {
 }
 function getSupportItemForChannel(support, channel) {
   if (!support?.items?.length) return void 0;
-  const scoreSupportItem = (item) => {
+  const candidates = support.items.filter((i) => i.chnID === channel);
+  if (!candidates.length) return void 0;
+  const score = (item) => {
     const anyItem = item;
-    let score = 0;
-    if (anyItem.name == null) score += 2;
+    let result = 0;
+    if (anyItem.name == null) result += 100;
     const capabilityKeys = [
       "ptzType",
       "ptzControl",
@@ -7234,20 +7337,17 @@ function getSupportItemForChannel(support, channel) {
       "motion",
       "encCtrl",
       "newIspCfg",
-      "remoteAbility"
+      "remoteAbility",
+      "aitype",
+      "videoClip",
+      "snap"
     ];
     for (const k of capabilityKeys) {
-      if (anyItem[k] !== void 0) score += 3;
+      if (anyItem[k] !== void 0) result += 3;
     }
-    score += Math.min(10, Math.max(0, Object.keys(anyItem).length - 1));
-    return score;
-  };
-  const pickBest = (chnId) => {
-    const candidates = support.items.filter((i) => i.chnID === chnId);
-    if (!candidates.length) return void 0;
-    return candidates.slice().sort((a, b) => scoreSupportItem(b) - scoreSupportItem(a))[0];
+    return result;
   };
-  return pickBest(channel);
+  return candidates.sort((a, b) => score(b) - score(a))[0];
 }
 function computeDeviceCapabilities(params) {
   const { channel } = params;
@@ -7279,6 +7379,7 @@ function computeDeviceCapabilities(params) {
     flat,
     /white\s*led|whiteLed|flood\s*light|floodlight/i
   );
+  const hasSirenFromSupport = supportItem ? isTruthyNumberLike(supportItem.audioVersion) : false;
   const hasSirenFromAbilities = abilitiesHasAny(
     flat,
     /audio\s*alarm|audioAlarm|siren|pushAlarn|audioPlay/i
@@ -7291,6 +7392,9 @@ function computeDeviceCapabilities(params) {
   const hasPirFromSupport = supportItem ? isTruthyNumberLike(supportItem.rfCfg) || isTruthyNumberLike(supportItem.newRfCfg) || isTruthyNumberLike(supportItem.rfVersion) || isTruthyNumberLike(supportItem.battery) : false;
   const hasAutotrackingFromSupport = supportItem ? isTruthyNumberLike(supportItem.autoPt) || isTruthyNumberLike(supportItem.smartAI) : false;
   const hasAutotrackingFromAbilities = abilitiesHasAny(flat, /smartTrack/i);
+  const hasBattery = hasBatteryFromSupport || hasBatteryFromAbilities;
+  const isDoorbell = isDoorbellFromSupport || isDoorbellFromModel;
+  const hasWirelessChimeFromAbilities = abilitiesHasAny(flat, /dingDong|dingdong/i);
   const hasPan = hasPanTiltFromSupport || hasPanTiltFromAbilities;
   const hasTilt = hasPanTiltFromSupport || hasPanTiltFromAbilities;
   const hasZoom = hasZoomFromSupport || hasZoomFromAbilities;
@@ -7306,14 +7410,15 @@ function computeDeviceCapabilities(params) {
     hasZoom: finalHasZoom,
     hasPresets: finalHasPresets,
     hasPtz: ptzDisabledBySupport ? false : hasPtzFromSupport || finalHasPan || finalHasTilt || finalHasZoom || finalHasPresets,
-    hasBattery: hasBatteryFromSupport || hasBatteryFromAbilities,
+    hasBattery,
     hasIntercom: hasIntercomFromSupport,
-    hasSiren: hasSirenFromAbilities,
+    hasSiren: hasSirenFromSupport || hasSirenFromAbilities,
     // lightType >= 2 indicates controllable white LED / floodlight (1 = IR only)
     hasFloodlight: Number.isFinite(lightType) ? lightType >= 2 : hasFloodlightFromAbilities,
     hasPir: hasPirFromAbilities || hasPirFromSupport,
-    isDoorbell: isDoorbellFromSupport || isDoorbellFromModel,
-    hasAutotracking: hasAutotrackingFromSupport || hasAutotrackingFromAbilities
+    isDoorbell,
+    hasAutotracking: ptzDisabledBySupport ? false : hasAutotrackingFromSupport || hasAutotrackingFromAbilities,
+    hasWirelessChime: isDoorbell || hasWirelessChimeFromAbilities
   };
   if (ptzMode !== void 0) result.ptzMode = ptzMode;
   return result;
@@ -9188,6 +9293,161 @@ var discoverDeviceUidViaBaichuanGetP2p = async (params) => {
   return extractReolinkUidLike(p2pXml);
 };
 
+// src/reolink/baichuan/utils/chime.ts
+var buildDingDongGetParamsXml = (chimeId) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongDeviceOpt version="1.1">
+<id>${chimeId}</id>
+<opt>getParam</opt>
+</dingdongDeviceOpt>
+</body>`;
+var buildDingDongSetParamsXml = (chimeId, params) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongDeviceOpt version="1.1">
+<opt>setParam</opt>
+<id>${chimeId}</id>
+${params.volLevel !== void 0 ? `<volLevel>${params.volLevel}</volLevel>` : ""}
+${params.ledState !== void 0 ? `<ledState>${params.ledState}</ledState>` : ""}
+${params.name !== void 0 ? `<name>${params.name}</name>` : ""}
+</dingdongDeviceOpt>
+</body>`;
+var buildDingDongRingXml = (chimeId, musicId) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongDeviceOpt version="1.1">
+<id>${chimeId}</id>
+<opt>ringWithMusic</opt>
+<musicId>${musicId}</musicId>
+</dingdongDeviceOpt>
+</body>`;
+var buildSetDingDongCfgXml = (chimeId, eventType, state, musicId) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongCfg version="1.1">
+<deviceCfg>
+<id>${chimeId}</id>
+<alarminCfg>
+<valid>${state}</valid>
+<musicId>${musicId}</musicId>
+<type>${eventType}</type>
+</alarminCfg>
+</deviceCfg>
+</dingdongCfg>
+</body>`;
+var buildGetDingDongCtrlXml = () => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongCtrl version="1.1">
+<opt>machineStateGet</opt>
+</dingdongCtrl>
+</body>`;
+var buildSetDingDongCtrlXml = (chimeType, enabled, time) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongCtrl version="1.1">
+<opt>machineStateSet</opt>
+<type>${chimeType}</type>
+<bopen>${enabled}</bopen>
+<bsave>1</bsave>
+<time>${time}</time>
+</dingdongCtrl>
+</body>`;
+var buildQuickReplyPlayXml = (channel, fileId) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<audioFileInfo version="1.1">
+<channelId>${channel}</channelId>
+<id>${fileId}</id>
+<timeout>0</timeout>
+</audioFileInfo>
+</body>`;
+var parseDingDongListFromXml = (xml) => {
+  const devices = [];
+  const blocks = getXmlBlocks(xml, "dingdongDeviceInfo");
+  for (const block of blocks) {
+    const idText = getXmlText(block, "deviceId") ?? getXmlText(block, "id");
+    const name = getXmlText(block, "deviceName") ?? getXmlText(block, "name") ?? "";
+    const netStateText = getXmlText(block, "netState") ?? getXmlText(block, "netstate");
+    if (idText === void 0) continue;
+    const id = Number(idText);
+    if (!Number.isFinite(id)) continue;
+    devices.push({
+      id,
+      name,
+      netState: netStateText !== void 0 ? Number(netStateText) : 0
+    });
+  }
+  return devices;
+};
+var parseDingDongParamsFromXml = (xml) => {
+  const name = getXmlText(xml, "name");
+  const volLevelText = getXmlText(xml, "volLevel");
+  const ledStateText = getXmlText(xml, "ledState");
+  const result = {};
+  if (name !== void 0) result.name = name;
+  if (volLevelText !== void 0) {
+    const n = Number(volLevelText);
+    if (Number.isFinite(n)) result.volLevel = n;
+  }
+  if (ledStateText !== void 0) {
+    const n = Number(ledStateText);
+    if (Number.isFinite(n)) result.ledState = n;
+  }
+  return result;
+};
+var parseDingDongCfgFromXml = (xml) => {
+  const configs = [];
+  const deviceBlocks = getXmlBlocks(xml, "deviceCfg");
+  for (const deviceBlock of deviceBlocks) {
+    const idText = getXmlText(deviceBlock, "ringId") ?? getXmlText(deviceBlock, "id");
+    if (idText === void 0) continue;
+    const id = Number(idText);
+    if (!Number.isFinite(id)) continue;
+    const typeMap = {};
+    const alarmBlocks = getXmlBlocks(deviceBlock, "alarminCfg");
+    for (const alarmBlock of alarmBlocks) {
+      const type = getXmlText(alarmBlock, "type");
+      if (!type) continue;
+      const validText = getXmlText(alarmBlock, "switch") ?? getXmlText(alarmBlock, "valid");
+      const musicIdText = getXmlText(alarmBlock, "musicId");
+      typeMap[type] = {
+        valid: validText !== void 0 ? Number(validText) : 0,
+        musicId: musicIdText !== void 0 ? Number(musicIdText) : 0
+      };
+    }
+    configs.push({ id, type: typeMap });
+  }
+  return configs;
+};
+var parseHardwiredChimeFromXml = (xml) => {
+  const type = getXmlText(xml, "type") ?? "";
+  const bopenText = getXmlText(xml, "bopen") ?? getXmlText(xml, "enable");
+  const timeText = getXmlText(xml, "time");
+  return {
+    type,
+    enabled: bopenText === "1",
+    time: timeText !== void 0 ? Number(timeText) : 0
+  };
+};
+var buildGetDingDongSilentXml = (chimeId) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongSilentMode version="1.1">
+<id>${chimeId}</id>
+</dingdongSilentMode>
+</body>`;
+var buildSetDingDongSilentXml = (chimeId, time) => `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<dingdongSilentMode version="1.1">
+<id>${chimeId}</id>
+<time>${time}</time>
+<type>63</type>
+</dingdongSilentMode>
+</body>`;
+var parseWirelessChimeSilentFromXml = (xml, chimeId) => {
+  const timeText = getXmlText(xml, "time");
+  const time = timeText !== void 0 ? Number(timeText) : 0;
+  return {
+    id: chimeId,
+    time,
+    active: time === 0
+  };
+};
+
 // src/reolink/baichuan/utils/eventsGetEvents.ts
 var parseAiTypeToken = (aiTypeRaw) => {
   const raw = (aiTypeRaw ?? "").trim();
@@ -9497,6 +9757,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   host;
   username;
   password;
+  /**
+   * Set to `true` after `close()` is called.
+   * Once closed, the API instance should not be reused.
+   */
+  _closed = false;
   // ─────────────────────────────────────────────────────────────────────────────
   // SOCKET POOL - Tag-based socket management
   // ─────────────────────────────────────────────────────────────────────────────
@@ -9526,10 +9791,194 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   get client() {
     const entry = this.socketPool.get("general");
     if (!entry) {
+      if (this._closed) {
+        throw new Error(
+          "[ReolinkBaichuanApi] API has been closed \u2014 create a new instance to reconnect"
+        );
+      }
       throw new Error("[ReolinkBaichuanApi] General socket not initialized");
     }
     return entry.client;
   }
+  /**
+   * `true` after `close()` has been called. A closed API should not be reused;
+   * the consumer should create a new instance.
+   */
+  get isClosed() {
+    return this._closed;
+  }
+  /**
+   * `true` when the API is usable: not closed, general socket exists, socket
+   * is connected and the client is logged in.
+   *
+   * This is the recommended way for consumers to check whether the API is
+   * still valid before issuing commands, instead of directly accessing
+   * `api.client.isSocketConnected()` / `api.client.loggedIn` (which throws
+   * if the socket pool was already destroyed).
+   */
+  get isReady() {
+    if (this._closed) return false;
+    const entry = this.socketPool.get("general");
+    if (!entry) return false;
+    try {
+      return entry.client.isSocketConnected() && entry.client.loggedIn;
+    } catch {
+      return false;
+    }
+  }
+  /** Promise tracking an in-flight reconnection from `ensureConnected()`. */
+  _ensureConnectedPromise;
+  /**
+   * Ensure the "general" socket is connected and logged in.
+   * If the socket is disconnected or the pool entry was destroyed, a new
+   * general socket is created, logged in, and all event/push/guard listeners
+   * are re-attached automatically.
+   *
+   * This is a **no-op** when the API is already {@link isReady}.
+   *
+   * @throws If `close()` was called — the API is permanently closed and a new
+   *         instance must be created.
+   */
+  async ensureConnected() {
+    if (this._closed) {
+      throw new Error(
+        "[ReolinkBaichuanApi] API has been closed \u2014 create a new instance to reconnect"
+      );
+    }
+    if (this.isReady) return;
+    if (this._ensureConnectedPromise) {
+      return this._ensureConnectedPromise;
+    }
+    this._ensureConnectedPromise = this.reconnectGeneralSocket();
+    try {
+      await this._ensureConnectedPromise;
+    } finally {
+      this._ensureConnectedPromise = void 0;
+    }
+  }
+  /**
+   * Internal: destroy the current general socket (if any), create a new one,
+   * login, and re-attach all listeners.
+   */
+  async reconnectGeneralSocket() {
+    const oldEntry = this.socketPool.get("general");
+    if (oldEntry) {
+      oldEntry.client.removeAllListeners();
+      if (oldEntry.idleCloseTimer) clearTimeout(oldEntry.idleCloseTimer);
+      if (oldEntry.generalPermitRelease) {
+        try {
+          oldEntry.generalPermitRelease();
+        } catch {
+        }
+      }
+      this.socketPool.delete("general");
+      try {
+        await oldEntry.client.close({ reason: "reconnect", skipLogout: true });
+      } catch {
+      }
+    }
+    const newClient = new BaichuanClient(this.clientOptions);
+    this.socketPool.set("general", {
+      client: newClient,
+      refCount: 1,
+      // general socket is always "in use"
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      idleCloseTimer: void 0,
+      generalPermitRelease: void 0
+    });
+    this.setupGeneralClientListeners();
+    await this.client.login();
+    this.logger.log?.(
+      "[ReolinkBaichuanApi] General socket reconnected successfully"
+    );
+    if (this.simpleEventListeners.size > 0) {
+      this.simpleEventSubscribed = false;
+      this.simpleEventWatchdogRecoveryAttempts = 0;
+      this.simpleEventWatchdogLastRecoveryAt = 0;
+      try {
+        await this.ensureSimpleEventSubscribed();
+        this.simpleEventLastReceivedAt = Date.now();
+        this.logger.log?.(
+          `[ReolinkBaichuanApi] Events re-subscribed after reconnection (listeners=${this.simpleEventListeners.size})`
+        );
+      } catch (e) {
+        (this.logger.debug ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] Event re-subscribe after reconnection failed, watchdog will retry`,
+          formatErrorForLog(e)
+        );
+      }
+    }
+  }
+  /**
+   * Attach event, push, channelInfo, and guard listeners to the current
+   * "general" client.  Called from the constructor and from
+   * {@link reconnectGeneralSocket}.
+   */
+  setupGeneralClientListeners() {
+    const client = this.client;
+    client.on("event", (event) => {
+      const mapped = mapToSimpleEvent(event);
+      if (!mapped) return;
+      this.dispatchSimpleEvent(mapped);
+    });
+    client.on("channelInfo", (xml) => {
+      try {
+        this.parseAndStoreChannelInfo(xml);
+      } catch (e) {
+        this.logger.warn?.(
+          "[ReolinkBaichuanApi] Error parsing channel info from push",
+          formatErrorForLog(e)
+        );
+      }
+    });
+    client.on("push", (frame) => {
+      const cmdId = frame.header.cmdId;
+      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST) {
+        return;
+      }
+      try {
+        if (frame.body.length === 0) return;
+        const xml = client.tryDecryptXml(
+          frame.body,
+          frame.header.channelId,
+          client.enc
+        );
+        if (!xml || !xml.startsWith("<?xml")) return;
+        this.parseAndStoreSettingsPush(cmdId, xml, frame.header.channelId);
+      } catch (e) {
+        this.logger.debug?.(
+          "[ReolinkBaichuanApi] Error parsing settings push",
+          formatErrorForLog(e)
+        );
+      }
+    });
+    if (this.rebootAfterDisconnectionsPerMinute > 0) {
+      client.on("close", () => {
+        try {
+          void this.maybeRebootOnDisconnectStorm();
+        } catch {
+        }
+      });
+    }
+    if (this.rebootAfterConsecutiveEconnreset > 0) {
+      client.on("close", () => {
+        try {
+          void this.maybeRebootOnEconnresetStorm();
+        } catch {
+        }
+      });
+    }
+    if (!this.sessionGuardIntervalTimer) {
+      client.once("push", () => {
+        void this.logActiveSessionsOnStartup();
+        this.sessionGuardIntervalTimer = setInterval(() => {
+          void this.maybeRebootOnTooManySessions();
+        }, 6e4);
+      });
+    }
+  }
   /**
    * Cached camera UID. May be initially undefined if not provided in the constructor.
    * Will be lazily populated on demand when needed (e.g. for recordings).
@@ -10104,6 +10553,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         `[SocketPool] Closing existing socket for tag=${tag} (recreating)`
       );
       this.socketPool.delete(tag);
+      if (existing.generalPermitRelease) {
+        try {
+          existing.generalPermitRelease();
+        } catch {
+        }
+        existing.generalPermitRelease = void 0;
+      }
       try {
         await existing.client.close({
           reason: "socket pool recreation",
@@ -10122,7 +10578,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       refCount: 0,
       createdAt: now,
       lastUsedAt: now,
-      idleCloseTimer: void 0
+      idleCloseTimer: void 0,
+      generalPermitRelease: void 0
     };
     entry.pendingPromise = (async () => {
       try {
@@ -10140,6 +10597,19 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         entry.lastUsedAt = Date.now();
         delete entry.pendingPromise;
         log?.log?.(`[SocketPool] Socket connected for tag=${tag}`);
+        if (tag !== "general") {
+          try {
+            const generalEntry = this.socketPool.get("general");
+            if (generalEntry?.client) {
+              entry.generalPermitRelease = generalEntry.client.acquirePermit(
+                0,
+                // indefinite — released when the streaming socket closes
+                `streaming-peer:${tag}`
+              );
+            }
+          } catch {
+          }
+        }
         void this.maybeRebootOnTooManySessions();
         return newClient;
       } catch (loginError) {
@@ -10208,6 +10678,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         if (!current) return;
         if (current.refCount > 0) return;
         this.socketPool.delete(tag);
+        if (current.generalPermitRelease) {
+          try {
+            current.generalPermitRelease();
+          } catch {
+          }
+          current.generalPermitRelease = void 0;
+        }
         log?.log?.(`[SocketPool] Closing idle streaming socket for tag=${tag}`);
         try {
           await current.client.close({
@@ -10262,6 +10739,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       clearTimeout(entry.idleCloseTimer);
       entry.idleCloseTimer = void 0;
     }
+    if (entry.generalPermitRelease) {
+      try {
+        entry.generalPermitRelease();
+      } catch {
+      }
+      entry.generalPermitRelease = void 0;
+    }
     log?.debug?.(`[SocketPool] Force-closing socket for tag=${tag}`);
     this.socketPool.delete(tag);
     try {
@@ -10287,6 +10771,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
           if (entry.idleCloseTimer) {
             clearTimeout(entry.idleCloseTimer);
           }
+          if (entry.generalPermitRelease) {
+            try {
+              entry.generalPermitRelease();
+            } catch {
+            }
+            entry.generalPermitRelease = void 0;
+          }
           this.logger?.debug?.(`[SocketPool] Cleanup: closing tag=${tag}`);
           await entry.client.close({ reason: "API cleanup", skipLogout: true });
         } catch {
@@ -10392,7 +10883,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       password: opts.password,
       ...opts.logger ? { logger: opts.logger } : {},
       ...opts.debugOptions ? { debugOptions: opts.debugOptions } : {},
-      ...opts.uid ? { uid: opts.uid } : {}
+      ...opts.uid ? { uid: opts.uid } : {},
+      ...opts.transport ? { transport: opts.transport } : {},
+      ...opts.port !== void 0 ? { port: opts.port } : {},
+      ...opts.udpDiscoveryMethod ? { udpDiscoveryMethod: opts.udpDiscoveryMethod } : {},
+      ...opts.idleDisconnect !== void 0 ? { idleDisconnect: opts.idleDisconnect } : {},
+      ...opts.idleDisconnectTimeoutMs !== void 0 ? { idleDisconnectTimeoutMs: opts.idleDisconnectTimeoutMs } : {},
+      ...opts.channel !== void 0 ? { channel: opts.channel } : {}
     };
     const generalClient = new BaichuanClient(opts);
     this.socketPool.set("general", {
@@ -10401,7 +10898,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       // Always keep general socket "in use"
       createdAt: Date.now(),
       lastUsedAt: Date.now(),
-      idleCloseTimer: void 0
+      idleCloseTimer: void 0,
+      generalPermitRelease: void 0
     });
     this.host = opts.host;
     this.username = opts.username;
@@ -10421,42 +10919,6 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       logger: this.logger,
       debugConfig: generalClient.getDebugConfig?.()
     });
-    this.client.on("event", (event) => {
-      const mapped = mapToSimpleEvent(event);
-      if (!mapped) return;
-      this.dispatchSimpleEvent(mapped);
-    });
-    this.client.on("channelInfo", (xml) => {
-      try {
-        this.parseAndStoreChannelInfo(xml);
-      } catch (e) {
-        this.logger.warn?.(
-          "[ReolinkBaichuanApi] Error parsing channel info from push",
-          formatErrorForLog(e)
-        );
-      }
-    });
-    this.client.on("push", (frame) => {
-      const cmdId = frame.header.cmdId;
-      if (cmdId !== BC_CMD_ID_PUSH_VIDEO_INPUT && cmdId !== BC_CMD_ID_PUSH_SERIAL && cmdId !== BC_CMD_ID_PUSH_NET_INFO && cmdId !== BC_CMD_ID_PUSH_DINGDONG_LIST && cmdId !== BC_CMD_ID_PUSH_SLEEP_STATUS && cmdId !== BC_CMD_ID_PUSH_COORDINATE_POINT_LIST) {
-        return;
-      }
-      try {
-        if (frame.body.length === 0) return;
-        const xml = this.client.tryDecryptXml(
-          frame.body,
-          frame.header.channelId,
-          this.client.enc
-        );
-        if (!xml || !xml.startsWith("<?xml")) return;
-        this.parseAndStoreSettingsPush(cmdId, xml, frame.header.channelId);
-      } catch (e) {
-        this.logger.debug?.(
-          "[ReolinkBaichuanApi] Error parsing settings push",
-          formatErrorForLog(e)
-        );
-      }
-    });
     const maxSessions = opts.maxDedicatedSessionsBeforeReboot;
     if (typeof maxSessions === "number" && Number.isFinite(maxSessions) && maxSessions > 0) {
       this.maxDedicatedSessionsBeforeReboot = Math.floor(maxSessions);
@@ -10465,32 +10927,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     if (typeof disconnectThreshold === "number" && Number.isFinite(disconnectThreshold)) {
       this.rebootAfterDisconnectionsPerMinute = Math.floor(disconnectThreshold);
     }
-    if (this.rebootAfterDisconnectionsPerMinute > 0) {
-      this.client.on("close", () => {
-        try {
-          void this.maybeRebootOnDisconnectStorm();
-        } catch {
-        }
-      });
-    }
     const econnresetThreshold = opts.rebootAfterConsecutiveEconnreset;
     if (typeof econnresetThreshold === "number" && Number.isFinite(econnresetThreshold)) {
       this.rebootAfterConsecutiveEconnreset = Math.floor(econnresetThreshold);
     }
-    if (this.rebootAfterConsecutiveEconnreset > 0) {
-      this.client.on("close", () => {
-        try {
-          void this.maybeRebootOnEconnresetStorm();
-        } catch {
-        }
-      });
-    }
-    this.client.once("push", () => {
-      void this.logActiveSessionsOnStartup();
-      this.sessionGuardIntervalTimer = setInterval(() => {
-        void this.maybeRebootOnTooManySessions();
-      }, 6e4);
-    });
+    this.setupGeneralClientListeners();
   }
   /**
    * CGI forward: fetch RTSP URL for a channel via `GetRtspUrl`.
@@ -10904,7 +11345,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    */
   async onSimpleEvent(callback) {
     this.simpleEventListeners.add(callback);
-    await this.ensureSimpleEventSubscribed();
+    this.logger.debug?.(
+      `[ReolinkBaichuanApi] onSimpleEvent: registering listener (total=${this.simpleEventListeners.size})`
+    );
+    try {
+      await this.ensureSimpleEventSubscribed();
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] onSimpleEvent: initial subscribe succeeded, simpleEventSubscribed=${this.simpleEventSubscribed}`
+      );
+    } catch (e) {
+      (this.logger.debug ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] onSimpleEvent: initial subscribe failed, simpleEventSubscribed=${this.simpleEventSubscribed}, watchdog will retry`,
+        formatErrorForLog(e)
+      );
+    }
     this.simpleEventLastReceivedAt = Date.now();
     this.startSimpleEventResubscribeTimer();
     this.startSimpleEventWatchdog();
@@ -10925,11 +11380,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       this.stopUdpSleepInference();
       await this.ensureSimpleEventUnsubscribed();
     } else {
-      const isUdp = this.client.getTransport?.() === "udp";
-      if (isUdp) {
-        this.startUdpSleepInference();
-      } else if (this.client.isStatePollingEnabled?.()) {
-        this.startStatePolling();
+      const generalEntry = this.socketPool.get("general");
+      if (generalEntry) {
+        const isUdp = generalEntry.client.getTransport?.() === "udp";
+        if (isUdp) {
+          this.startUdpSleepInference();
+        } else if (generalEntry.client.isStatePollingEnabled?.()) {
+          this.startStatePolling();
+        }
       }
     }
   }
@@ -10971,8 +11429,19 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   }
   async simpleEventWatchdogTick() {
     if (this.simpleEventListeners.size === 0) return;
-    if (!this.client.isSocketConnected?.() || !this.client.loggedIn) return;
+    const generalEntry = this.socketPool.get("general");
+    if (!generalEntry) return;
+    if (!generalEntry.client.isSocketConnected?.() || !generalEntry.client.loggedIn) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] event watchdog tick: skipping (connection not alive: connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+      );
+      return;
+    }
     const now = Date.now();
+    const sinceLastEvent = this.simpleEventLastReceivedAt > 0 ? now - this.simpleEventLastReceivedAt : -1;
+    this.logger.debug?.(
+      `[ReolinkBaichuanApi] event watchdog tick: subscribed=${this.simpleEventSubscribed} clientSubscribed=${generalEntry.client.subscribed} lastEventAgoMs=${sinceLastEvent} recoveryAttempts=${this.simpleEventWatchdogRecoveryAttempts} listeners=${this.simpleEventListeners.size}`
+    );
     if (this.simpleEventSubscribed && this.simpleEventLastReceivedAt > 0) {
       const silence = now - this.simpleEventLastReceivedAt;
       if (silence < this.simpleEventWatchdogSilenceThresholdMs) return;
@@ -10983,7 +11452,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       );
       try {
         this.simpleEventSubscribed = false;
-        this.client.subscribed = false;
+        generalEntry.client.subscribed = false;
         await this.ensureSimpleEventSubscribed();
         this.simpleEventLastReceivedAt = Date.now();
         this.simpleEventWatchdogRecoveryAttempts = 0;
@@ -11001,6 +11470,31 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       return;
     }
     if (!this.simpleEventSubscribed) {
+      if (this.simpleEventLastReceivedAt > 0) {
+        const sinceLastEvent2 = now - this.simpleEventLastReceivedAt;
+        if (sinceLastEvent2 < this.simpleEventWatchdogSilenceThresholdMs) {
+          this.simpleEventSubscribed = true;
+          this.logger.debug?.(
+            `[ReolinkBaichuanApi] event watchdog: events flowing (lastEventAgo=${Math.round(sinceLastEvent2 / 1e3)}s) despite simpleEventSubscribed=false, marking subscription as active (recoveryAttempts=${this.simpleEventWatchdogRecoveryAttempts})`
+          );
+          if (this.simpleEventWatchdogRecoveryAttempts > 0) {
+            (this.logger.info ?? this.logger.log).call(
+              this.logger,
+              `[ReolinkBaichuanApi] event watchdog: events flowing despite failed subscribe, marking subscription active`
+            );
+            this.simpleEventWatchdogRecoveryAttempts = 0;
+          }
+          return;
+        } else {
+          this.logger.debug?.(
+            `[ReolinkBaichuanApi] event watchdog: events stale (lastEventAgo=${Math.round(sinceLastEvent2 / 1e3)}s, threshold=${Math.round(this.simpleEventWatchdogSilenceThresholdMs / 1e3)}s), proceeding with recovery`
+          );
+        }
+      } else {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] event watchdog: no events ever received (simpleEventLastReceivedAt=0), proceeding with recovery`
+        );
+      }
       const backoffMs = Math.min(
         3e4 * Math.pow(2, this.simpleEventWatchdogRecoveryAttempts),
         this.simpleEventWatchdogSilenceThresholdMs
@@ -11064,20 +11558,51 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     return await this.simpleEventResubscribeInFlight;
   }
   async ensureSimpleEventSubscribed() {
-    if (this.simpleEventListeners.size === 0) return;
-    if (this.simpleEventSubscribed) return;
-    if (this.simpleEventSubscribeInFlight)
+    if (this.simpleEventListeners.size === 0) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: no listeners, skipping`
+      );
+      return;
+    }
+    if (this.simpleEventSubscribed) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: already subscribed, skipping`
+      );
+      return;
+    }
+    if (this.simpleEventSubscribeInFlight) {
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: subscribe already in-flight, awaiting`
+      );
       return await this.simpleEventSubscribeInFlight;
+    }
+    this.logger.debug?.(
+      `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: starting subscribe (clientSubscribed=${this.socketPool.get("general")?.client.subscribed})`
+    );
     this.simpleEventSubscribeInFlight = (async () => {
-      if (!this.client.subscribed) {
+      const entry = this.socketPool.get("general");
+      if (!entry) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: no general socket, bailing out`
+        );
+        return;
+      }
+      if (!entry.client.subscribed) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: client.subscribed=false, calling subscribeEvents()`
+        );
         await this.subscribeEvents();
+      } else {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] ensureSimpleEventSubscribed: client already subscribed, skipping subscribeEvents()`
+        );
       }
       this.simpleEventSubscribed = true;
-      const isUdp = this.client.getTransport?.() === "udp";
+      const isUdp = entry.client.getTransport?.() === "udp";
       if (isUdp) {
         this.startUdpSleepInference();
-      } else if (this.client.isStatePollingEnabled?.()) {
-        const channel = this.client.getConfiguredChannel?.() ?? 0;
+      } else if (entry.client.isStatePollingEnabled?.()) {
+        const channel = entry.client.getConfiguredChannel?.() ?? 0;
         await this.checkAndDispatchCurrentState(channel);
         this.startStatePolling();
       }
@@ -11087,7 +11612,15 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     return await this.simpleEventSubscribeInFlight;
   }
   async ensureSimpleEventUnsubscribed() {
-    if (!this.simpleEventSubscribed && !this.client.subscribed) return;
+    const generalEntry = this.socketPool.get("general");
+    if (!generalEntry) {
+      this.simpleEventSubscribed = false;
+      this.stopSimpleEventResubscribeTimer();
+      this.stopStatePolling();
+      this.stopUdpSleepInference();
+      return;
+    }
+    if (!this.simpleEventSubscribed && !generalEntry.client.subscribed) return;
     if (this.simpleEventUnsubscribeInFlight)
       return await this.simpleEventUnsubscribeInFlight;
     if (this.simpleEventSubscribeInFlight) {
@@ -11229,6 +11762,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     );
   }
   async close(options) {
+    if (this._closed) return;
+    this._closed = true;
     if (this.sessionGuardIntervalTimer) {
       clearInterval(this.sessionGuardIntervalTimer);
       this.sessionGuardIntervalTimer = void 0;
@@ -11291,7 +11826,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   }
   async handleSendXml400(params, frame, retry) {
     const emptyBody = frame.body.length === 0;
-    const emptyBody400Msg = "Baichuan request failed (responseCode 400, empty body). Possible causes: camera sleeping/waking (battery), expired session, invalid username/password, or unsupported command on NVR/Hub.";
+    const emptyBody400Msg = "Baichuan request failed (responseCode 400, empty body). Possible causes: expired session, invalid username/password, or unsupported command on NVR/Hub.";
     if (this.isSendXmlFailFast400(params, frame.body.length)) {
       throw new Error(emptyBody400Msg);
     }
@@ -11807,11 +12342,50 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Minimal per-channel inventory for NVR-connected devices.
    *
    * Intended to be fast: avoids AI/abilities and returns only the common identity + battery hints.
+   *
+   * @param options.source - Data source for the channel list (default: `"cgi"`):
+   *   - `"cgi"`: Uses HTTP `GetChannelstatus` — returns the channel list immediately,
+   *     no dependency on async push messages. Recommended for first-call discovery.
+   *   - `"baichuan"`: Uses the cmd_id 145 push cache populated when the NVR sends channel
+   *     info after login + event subscription. This push is *asynchronous*: if it has not
+   *     arrived yet, the result will have zero channels. Callers must retry (nvr.ts does this
+   *     with a 1-second loop). Note: explicitly requesting cmd_id 145 is not supported.
    */
   async getNvrChannelsSummary(options) {
-    const source = options?.source ?? "baichuan";
-    const pushInfo = this.getChannelInfoFromPushCache();
-    const channels = (options?.channels?.length ? options.channels : Array.from(pushInfo.keys())).map((c) => Number(c)).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+    const source = options?.source ?? "cgi";
+    let channels;
+    const cgiStatusByChannel = /* @__PURE__ */ new Map();
+    if (options?.channels?.length) {
+      channels = options.channels.map((c) => Number(c)).filter((n) => Number.isFinite(n));
+    } else if (source === "cgi") {
+      try {
+        const { channels: cgiChannels, channelsResponse } = await this.cgiApi.getChannels();
+        const status = channelsResponse?.[0]?.value?.status ?? [];
+        for (const s of status) {
+          const ch = Number(s?.channel);
+          if (!Number.isFinite(ch)) continue;
+          cgiStatusByChannel.set(ch, {
+            ...s.name != null ? { name: s.name } : {},
+            ...s.uid != null ? { uid: s.uid } : {},
+            sleeping: s.sleep === 1
+          });
+        }
+        channels = cgiChannels;
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] getNvrChannelsSummary: CGI found ${channels.length} channel(s): [${channels.join(", ")}]`
+        );
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        this.logger.warn?.(
+          `[ReolinkBaichuanApi] getNvrChannelsSummary: CGI GetChannelstatus failed (${msg}), returning empty`
+        );
+        channels = [];
+      }
+    } else {
+      const pushInfo2 = this.getChannelInfoFromPushCache();
+      channels = Array.from(pushInfo2.keys()).map((c) => Number(c)).filter((n) => Number.isFinite(n));
+    }
+    channels = channels.sort((a, b) => a - b);
     const support = await this.getSupportInfo().catch(() => {
       this.logger.error?.(
         "[ReolinkBaichuanApi] getNvrChannelsSummary: failed to get support info"
@@ -11841,7 +12415,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         );
       }
     }
-    const cacheKey = `baichuan:${channels.join(",")}`;
+    const cacheKey = `${source}:${channels.join(",")}`;
     const cached = this.nvrChannelsSummaryCache.get(cacheKey);
     if (cached) {
       return {
@@ -11862,8 +12436,10 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       } catch {
       }
     }
+    const pushInfo = this.getChannelInfoFromPushCache();
     const devices = channels.map((channel) => {
-      const cached2 = pushInfo.get(channel);
+      const pushCached = pushInfo.get(channel);
+      const cgiStatus = cgiStatusByChannel.get(channel);
       const info = infoPerChannel.get(channel);
       const networkInfo = networkInfoPerChannel.get(channel);
       const isBattery = isBatteryByChannel.get(channel) ?? false;
@@ -11871,6 +12447,9 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       const isDoorbell = (isDoorbellByChannel.get(channel) ?? false) || /doorbell/i.test(model);
       const normalizedModel = model ? model.trim() : void 0;
       const isMultifocal = normalizedModel ? isDualLenseModel(normalizedModel) : false;
+      const name = pushCached?.name || cgiStatus?.name || "";
+      const uid = pushCached?.uid || cgiStatus?.uid || "";
+      const sleeping = pushCached?.sleeping ?? cgiStatus?.sleeping;
       return {
         channel,
         isBattery,
@@ -11880,19 +12459,19 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         ...networkInfo?.ip ? { ip: networkInfo.ip } : {},
         ...networkInfo?.mac ? { mac: networkInfo.mac } : {},
         ...networkInfo?.activeLink ? { activeLink: networkInfo.activeLink } : {},
-        ...cached2?.name ? { name: cached2.name } : {},
-        ...cached2?.uid ? { uid: cached2.uid } : {},
-        ...cached2?.state ? { state: cached2.state } : {},
-        ...typeof cached2?.index === "number" ? { index: cached2.index } : {},
-        ...cached2?.streamSupport?.length ? { streamSupport: cached2.streamSupport } : {},
-        ...cached2?.wifiState ? { wifiState: cached2.wifiState } : {},
-        ...cached2?.networkSegment ? { networkSegment: cached2.networkSegment } : {},
-        ...typeof cached2?.changed === "boolean" ? { changed: cached2.changed } : {},
-        ...typeof cached2?.abilityChanged === "boolean" ? { abilityChanged: cached2.abilityChanged } : {},
-        ...typeof cached2?.online === "boolean" ? { online: cached2.online } : {},
-        ...typeof cached2?.sleeping === "boolean" ? { sleeping: cached2.sleeping } : {},
-        ...cached2?.loginState ? { loginState: cached2.loginState } : {},
-        ...typeof cached2?.updatedAtMs === "number" ? { updatedAtMs: cached2.updatedAtMs } : {}
+        ...name ? { name } : {},
+        ...uid ? { uid } : {},
+        ...pushCached?.state ? { state: pushCached.state } : {},
+        ...typeof pushCached?.index === "number" ? { index: pushCached.index } : {},
+        ...pushCached?.streamSupport?.length ? { streamSupport: pushCached.streamSupport } : {},
+        ...pushCached?.wifiState ? { wifiState: pushCached.wifiState } : {},
+        ...pushCached?.networkSegment ? { networkSegment: pushCached.networkSegment } : {},
+        ...typeof pushCached?.changed === "boolean" ? { changed: pushCached.changed } : {},
+        ...typeof pushCached?.abilityChanged === "boolean" ? { abilityChanged: pushCached.abilityChanged } : {},
+        ...typeof pushCached?.online === "boolean" ? { online: pushCached.online } : {},
+        ...typeof sleeping === "boolean" ? { sleeping } : {},
+        ...pushCached?.loginState ? { loginState: pushCached.loginState } : {},
+        ...typeof pushCached?.updatedAtMs === "number" ? { updatedAtMs: pushCached.updatedAtMs } : {}
       };
     });
     const result = { channels, devices };
@@ -13072,6 +13651,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         this._processVideoclipThumbnailQueue();
       }
     }
+    if (this.videoclipThumbnailQueue.length >= 50) {
+      throw new Error(
+        `Thumbnail queue full (${this.videoclipThumbnailQueue.length}/50) \u2013 request rejected to protect camera stability`
+      );
+    }
     return new Promise((resolve, reject) => {
       this.videoclipThumbnailQueue.push({ params, resolve, reject });
     });
@@ -13172,10 +13756,7 @@ ${xml}`);
         messageClass: BC_CLASS_MODERN_24,
         streamType: 0,
         payloadXml: xml,
-        timeoutMs,
-        // Retry parameters - camera often rejects first few requests
-        maxRetries: 8,
-        retryDelayMs: 1500
+        timeoutMs
       });
       trace(`CoverPreview succeeded`);
     } catch (e) {
@@ -14568,8 +15149,10 @@ ${stderr}`)
    * Unsubscribe from events.
    */
   async unsubscribeEvents() {
-    this.client.subscribed = false;
-    this.client.refreshKeepAlive?.();
+    const generalEntry = this.socketPool.get("general");
+    if (!generalEntry) return;
+    generalEntry.client.subscribed = false;
+    generalEntry.client.refreshKeepAlive?.();
   }
   /**
    * Check current motion and AI state and dispatch events if state changed.
@@ -16156,13 +16739,12 @@ ${xml}`
     ]);
     const support = supportResult.status === "fulfilled" ? supportResult.value : void 0;
     const abilities = abilitiesResult.status === "fulfilled" ? abilitiesResult.value : void 0;
-    const supportItem = this.pickBestSupportItem(support, ch);
-    const capabilities = this.parseCapabilitiesFromSupport(
-      ch,
-      supportItem,
-      support,
-      abilities
-    );
+    const supportItem = getSupportItemForChannel(support, ch);
+    const capabilities = computeDeviceCapabilities({
+      channel: ch,
+      ...support != null && { support },
+      ...abilities != null && { abilities }
+    });
     const item = supportItem;
     const lightType = item?.lightType;
     const ledCtrl = item?.ledCtrl;
@@ -16178,6 +16760,25 @@ ${xml}`
       });
       capabilities.hasFloodlight = probed;
     }
+    let dingDongListIds;
+    let dingDongCfgIds;
+    let wirelessChimeError;
+    if (capabilities.hasWirelessChime) {
+      try {
+        const list = await this.getDingDongList(ch);
+        dingDongListIds = list.map((d) => d.id);
+        const first = list[0];
+        const fromList = first !== void 0 && first.id >= 0;
+        if (!fromList) {
+          const configs = await this.getDingDongCfg(ch);
+          dingDongCfgIds = configs.map((c) => c.id);
+          capabilities.hasWirelessChime = configs.some((c) => c.id >= 0);
+        }
+      } catch (e) {
+        capabilities.hasWirelessChime = false;
+        wirelessChimeError = e instanceof Error ? e.message : String(e);
+      }
+    }
     const features = this.parseFeaturesFromSupport(support);
     const objects = await this.getAiDetectTypes(ch, { timeoutMs: 1500 });
     const autotrackingProbed = await this.probeAutotrackingSupport(ch, {
@@ -16214,7 +16815,10 @@ ${xml}`
       ...abilities && {
         abilityMergedKeyCount: Object.keys(abilities).length
       },
-      ...support?.items && { supportItemCount: support.items.length }
+      ...support?.items && { supportItemCount: support.items.length },
+      ...dingDongListIds !== void 0 && { dingDongListIds },
+      ...dingDongCfgIds !== void 0 && { dingDongCfgIds },
+      ...wirelessChimeError !== void 0 && { wirelessChimeError }
     };
     const result = {
       capabilities,
@@ -16241,90 +16845,6 @@ ${xml}`
       this.deviceCapabilitiesCache.clear();
     }
   }
-  /**
-   * Pick the best SupportItem for a channel.
-   * Prefers items without a name (capability items) over named items (googleHome, amazonAlexa).
-   */
-  pickBestSupportItem(support, channel) {
-    if (!support?.items?.length) return void 0;
-    const candidates = support.items.filter((i) => i.chnID === channel);
-    if (!candidates.length) return void 0;
-    const score = (item) => {
-      const anyItem = item;
-      let result = 0;
-      if (anyItem.name == null) result += 100;
-      const capabilityKeys = [
-        "ptzType",
-        "ptzControl",
-        "ptzPreset",
-        "ledCtrl",
-        "lightType",
-        "battery",
-        "audioVersion",
-        "motion",
-        "encCtrl",
-        "newIspCfg",
-        "remoteAbility",
-        "aitype",
-        "videoClip",
-        "snap"
-      ];
-      for (const k of capabilityKeys) {
-        if (anyItem[k] !== void 0) result += 3;
-      }
-      return result;
-    };
-    return candidates.sort((a, b) => score(b) - score(a))[0];
-  }
-  /**
-   * Parse device capabilities from SupportInfo.
-   * Uses SupportInfo as the single source of truth with AbilityInfo as fallback.
-   */
-  parseCapabilitiesFromSupport(channel, supportItem, support, abilities) {
-    const truthy = (v) => {
-      if (typeof v === "number") return v > 0;
-      if (typeof v === "string") {
-        const n = Number(v);
-        return Number.isFinite(n) ? n > 0 : v.length > 0 && v !== "0";
-      }
-      return Boolean(v);
-    };
-    const item = supportItem;
-    const ptzMode = support?.ptzMode?.toLowerCase();
-    const ptzType = item ? truthy(item.ptzType) : false;
-    const ptzControl = item ? truthy(item.ptzControl) : false;
-    const hasPtzFromItem = ptzType || ptzControl;
-    const hasPtzFromMode = ptzMode ? ptzMode !== "none" && ptzMode !== "0" : false;
-    const hasPanTilt = ptzMode ? ptzMode.includes("pt") || ptzMode === "ptz" : hasPtzFromItem;
-    const hasZoom = ptzMode ? ptzMode.includes("z") : hasPtzFromItem;
-    const hasPresets = item ? truthy(item.ptzPreset) : false;
-    const hasBattery = item ? truthy(item.battery) : false;
-    const hasSiren = item ? truthy(item.audioVersion) : false;
-    const lightType = item?.lightType;
-    const hasFloodlight = typeof lightType === "number" ? lightType >= 2 : false;
-    const hasPir = item ? truthy(item.rfCfg) || truthy(item.newRfCfg) || truthy(item.rfVersion) : false;
-    const isDoorbell = item ? truthy(item.doorbellVersion) : false;
-    const hasIntercom = truthy(support?.audioTalk) || (item ? truthy(item.ipcAudioTalk) : false);
-    return {
-      channel,
-      ...ptzMode && { ptzMode },
-      hasPan: hasPanTilt,
-      hasTilt: hasPanTilt,
-      hasZoom,
-      hasPresets,
-      hasPtz: hasPtzFromItem || hasPtzFromMode || hasPanTilt || hasZoom,
-      hasBattery,
-      hasIntercom,
-      hasSiren,
-      hasFloodlight,
-      hasPir,
-      isDoorbell,
-      // Autotracking: explicit flags only (autoPt or smartAI)
-      // Note: the heuristic (ptzControl && aitype) was too aggressive and caused false positives
-      // on cameras that have PTZ and AI detection but NOT autotracking capability.
-      hasAutotracking: item ? truthy(item.autoPt) || truthy(item.smartAI) : false
-    };
-  }
   /**
    * Parse support features from SupportInfo.
    */
@@ -17093,7 +17613,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-NUMCYEKQ.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-FNLGCOVA.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -17109,7 +17629,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-NUMCYEKQ.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-FNLGCOVA.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -19197,6 +19717,216 @@ ${scheduleItems}
     const channel = 0;
     return await this.getSnapshot(channel);
   }
+  // --------------------
+  // Chime / DingDong APIs
+  // --------------------
+  /**
+   * Get the list of paired wireless chime devices.
+   * cmd_id: 484 (GetDingDongList)
+   *
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Array of paired chime devices
+   */
+  async getDingDongList(channel) {
+    const ch = this.normalizeChannel(channel);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_DING_DONG_LIST,
+      channel: ch
+    });
+    return parseDingDongListFromXml(xml);
+  }
+  /**
+   * Get parameters (name, volume, LED state) for a specific wireless chime.
+   * cmd_id: 485 (DingDongOpt, option getParam)
+   *
+   * @param chimeId - The chime device ID
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Chime parameters
+   */
+  async getDingDongParams(chimeId, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildDingDongGetParamsXml(chimeId);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_DING_DONG_OPT,
+      channel: ch,
+      payloadXml
+    });
+    return parseDingDongParamsFromXml(xml);
+  }
+  /**
+   * Set parameters (name, volume, LED state) for a specific wireless chime.
+   * cmd_id: 485 (DingDongOpt, option setParam)
+   *
+   * @param chimeId - The chime device ID
+   * @param params - Parameters to set (volLevel, ledState, name)
+   * @param channel - Channel number (0-based, default 0)
+   */
+  async setDingDongParams(chimeId, params, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildDingDongSetParamsXml(chimeId, params);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_DING_DONG_OPT,
+      channel: ch,
+      payloadXml
+    });
+  }
+  /**
+   * Trigger a wireless chime to ring with a specific ringtone.
+   * cmd_id: 485 (DingDongOpt, option ringWithMusic)
+   *
+   * @param chimeId - The chime device ID
+   * @param musicId - The ringtone/music ID to play
+   * @param channel - Channel number (0-based, default 0)
+   */
+  async ringDingDong(chimeId, musicId, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildDingDongRingXml(chimeId, musicId);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_DING_DONG_OPT,
+      channel: ch,
+      payloadXml
+    });
+  }
+  /**
+   * Get the per-event alarm configuration for paired wireless chimes.
+   * cmd_id: 486 (GetDingDongCfg)
+   *
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Array of chime configurations (one per paired chime)
+   */
+  async getDingDongCfg(channel) {
+    const ch = this.normalizeChannel(channel);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_DING_DONG_CFG,
+      channel: ch
+    });
+    return parseDingDongCfgFromXml(xml);
+  }
+  /**
+   * Set the per-event alarm configuration for a specific wireless chime.
+   * cmd_id: 487 (SetDingDongCfg)
+   *
+   * @param chimeId - The chime ring/device ID
+   * @param eventType - Event type string (e.g. "doorbell", "package", "people")
+   * @param state - 0 = disabled, 1 = enabled
+   * @param musicId - Ringtone ID to use for this event type
+   * @param channel - Channel number (0-based, default 0)
+   */
+  async setDingDongCfg(chimeId, eventType, state, musicId, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildSetDingDongCfgXml(chimeId, eventType, state, musicId);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_DING_DONG_CFG,
+      channel: ch,
+      payloadXml
+    });
+  }
+  /** Cache of last known hardwired chime state per channel, used to avoid re-fetching on every set. */
+  _hardwiredChimeCache = /* @__PURE__ */ new Map();
+  /**
+   * Get the hardwired (wired-in) chime state.
+   * cmd_id: 483 (GetDingDongCtrl)
+   *
+   * Note: calling this may briefly trigger the physical chime to rattle.
+   *
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Hardwired chime state (type, enabled, time)
+   */
+  async getHardwiredChime(channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildGetDingDongCtrlXml();
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_DING_DONG_CTRL,
+      channel: ch,
+      payloadXml
+    });
+    const state = parseHardwiredChimeFromXml(xml);
+    this._hardwiredChimeCache.set(ch, state);
+    return state;
+  }
+  /**
+   * Set the hardwired (wired-in) chime state.
+   * cmd_id: 483 (SetDingDongCtrl)
+   *
+   * Uses the cached state from a previous getHardwiredChime call to fill in
+   * missing type/time fields, avoiding a double round-trip on every set.
+   * Falls back to fetching if no cache is available.
+   *
+   * @param params - Chime configuration (type, enabled, time)
+   * @param channel - Channel number (0-based, default 0)
+   */
+  async setHardwiredChime(params, channel) {
+    const ch = this.normalizeChannel(channel);
+    let current = this._hardwiredChimeCache.get(ch);
+    if (!current) {
+      current = await this.getHardwiredChime(ch);
+    }
+    const chimeType = params.type ?? current.type;
+    const enabled = params.enabled ? 1 : 0;
+    const time = params.time ?? current.time;
+    const payloadXml = buildSetDingDongCtrlXml(chimeType, enabled, time);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_DING_DONG_CTRL,
+      channel: ch,
+      payloadXml
+    });
+    const newState = parseHardwiredChimeFromXml(xml);
+    this._hardwiredChimeCache.set(ch, newState);
+    return newState;
+  }
+  /**
+   * Play an audio file on the doorbell / chime device.
+   * cmd_id: 349 (QuickReplyPlay)
+   *
+   * @param fileId - The audio file ID to play
+   * @param channel - Channel number (0-based, default 0)
+   */
+  async quickReplyPlay(fileId, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildQuickReplyPlayXml(ch, fileId);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_QUICK_REPLY_PLAY,
+      channel: ch,
+      payloadXml
+    });
+  }
+  /**
+   * Get the silent mode state of a paired wireless chime.
+   * cmd_id: 609 (GetDingDongSilent)
+   *
+   * @param chimeId - The wireless chime device ID (from getDingDongList)
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Wireless chime silent state (time=0 means active/not silenced)
+   */
+  async getDingDongSilent(chimeId, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildGetDingDongSilentXml(chimeId);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_DING_DONG_SILENT,
+      channel: ch,
+      payloadXml
+    });
+    return parseWirelessChimeSilentFromXml(xml, chimeId);
+  }
+  /**
+   * Set the silent mode of a paired wireless chime.
+   * cmd_id: 610 (SetDingDongSilent)
+   *
+   * @param chimeId - The wireless chime device ID (from getDingDongList)
+   * @param time - Silence duration in seconds. 0 = not silenced (chime active), >0 = silenced for this many seconds.
+   * @param channel - Channel number (0-based, default 0)
+   * @returns Updated wireless chime silent state
+   */
+  async setDingDongSilent(chimeId, time, channel) {
+    const ch = this.normalizeChannel(channel);
+    const payloadXml = buildSetDingDongSilentXml(chimeId, time);
+    const xml = await this.sendXml({
+      cmdId: BC_CMD_ID_SET_DING_DONG_SILENT,
+      channel: ch,
+      payloadXml
+    });
+    return parseWirelessChimeSilentFromXml(xml, chimeId);
+  }
 };
 
 // src/reolink/discovery.ts
@@ -20194,6 +20924,7 @@ export {
   flattenAbilitiesForChannel,
   abilitiesHasAny,
   parseSupportXml,
+  getSupportItemForChannel,
   computeDeviceCapabilities,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
@@ -20212,4 +20943,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-EHWVA3SG.js.map
+//# sourceMappingURL=chunk-MN7GUZT7.js.map