@apocaliss92/nodelink-js 0.2.1 → 0.2.3

package/dist/{chunk-PCPEXOWB.js → chunk-RWYEGEWG.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) {
@@ -5392,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?.();
       }
     })();
   }
@@ -5491,6 +5501,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   // Shared native stream fan-out (single camera stream, multiple RTSP clients)
   nativeFanout = null;
   noClientAutoStopTimer;
+  // Prebuffer: rolling ring of recent video frames for IDR-aligned fast startup.
+  // When a new client connects while the stream is already running it does not need
+  // to wait up to one full GOP interval for the next keyframe — we replay frames
+  // from the last IDR in the prebuffer immediately.
+  PREBUFFER_MAX_MS = 3e3;
+  prebuffer = [];
   static isAdtsAacFrame(b) {
     return b.length >= 2 && b[0] === 255 && (b[1] & 240) === 240;
   }
@@ -5525,6 +5541,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     );
     return { sampleRate, channels, configHex };
   }
+  /** Returns true if the raw (packed/Annex B) frame is an IDR (H.264) or IRAP (H.265). */
+  isRawFrameKeyframe(frame) {
+    try {
+      if (frame.videoType === "H264") {
+        const nals = _BaichuanRtspServer.splitAnnexBNals(
+          convertToAnnexB(frame.data)
+        );
+        return nals.some((n) => n.length >= 1 && (n[0] & 31) === 5);
+      }
+      if (frame.videoType === "H265") {
+        const nals = splitAnnexBToNalPayloads2(convertToAnnexB2(frame.data));
+        return nals.some(
+          (n) => n.length >= 2 && isH265Irap(n[0] >> 1 & 63)
+        );
+      }
+    } catch {
+    }
+    return false;
+  }
   static parseInterleavedChannels(transportHeader) {
     const m = transportHeader.match(/interleaved\s*=\s*(\d+)\s*-\s*(\d+)/i);
     if (!m) return null;
@@ -5717,7 +5752,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) => {
@@ -5749,7 +5784,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;
@@ -5757,6 +5795,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);
@@ -5898,7 +5942,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();
@@ -5910,7 +5954,11 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             }
             const { hasParamSets } = this.flow.getFmtp();
             if (!hasParamSets) {
-              const primingMs = this.api.client.getTransport() === "udp" ? 4e3 : 1500;
+              const primingMs = this.api.client.getTransport() === "udp" ? 4e3 : 3e3;
+              const primingStart = Date.now();
+              this.logger.info(
+                `[rebroadcast] DESCRIBE priming: waiting up to ${primingMs}ms for SPS/PPS  client=${clientId} path=${this.path}`
+              );
               try {
                 await Promise.race([
                   this.firstFramePromise || Promise.resolve(),
@@ -5918,6 +5966,17 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
                 ]);
               } catch {
               }
+              const primingElapsed = Date.now() - primingStart;
+              const { hasParamSets: hasParamSetsAfter } = this.flow.getFmtp();
+              if (hasParamSetsAfter) {
+                this.logger.info(
+                  `[rebroadcast] DESCRIBE priming: SPS/PPS received after ${primingElapsed}ms  client=${clientId} path=${this.path}`
+                );
+              } else {
+                this.logger.warn(
+                  `[rebroadcast] DESCRIBE priming: timed out after ${primingElapsed}ms without SPS/PPS \u2014 SDP will lack sprop-parameter-sets, downstream decoder may hang  client=${clientId} path=${this.path}`
+                );
+              }
             }
           }
           {
@@ -5926,11 +5985,6 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             this.logger.info(
               `[BaichuanRtspServer] DESCRIBE SDP for ${clientId} path=${this.path} codec=${this.flow.sdpCodec} hasParamSets=${hasParamSets} fmtp=${fmtpPreview}`
             );
-            if (!hasParamSets) {
-              this.rtspDebugLog(
-                `DESCRIBE responding without parameter sets yet (client=${clientId}, path=${this.path}, flow=${this.flow.key})`
-              );
-            }
           }
           const sdp = this.generateSdp();
           sendResponse(
@@ -5980,7 +6034,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
               seenFirstVideoKeyframe: false,
               setupTrack0: false,
               setupTrack1: false,
-              isPlaying: false
+              isPlaying: false,
+              connectTime
             });
           } else {
             existing.rtspSocket = socket;
@@ -6027,8 +6082,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}`
               );
             }
           }
@@ -6053,8 +6110,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}`
               );
             }
           }
@@ -6063,6 +6121,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
@@ -6128,10 +6189,6 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       sdp += `a=control:track1\r
 `;
     }
-    sdp += `a=setup:passive\r
-`;
-    sdp += `a=connection:new\r
-`;
     return sdp;
   }
   /**
@@ -6157,7 +6214,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;
@@ -6202,6 +6259,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
           return false;
         if (channel === audioRtpChannel && !resources2?.setupTrack1)
           return false;
+        const buffered = rtspSocket.writableLength;
+        if (buffered > 10 * 1024 * 1024) {
+          this.logger.warn(
+            `[rebroadcast] backpressure: ${Math.round(buffered / 1024)}KB buffered for client=${clientId} \u2014 disconnecting`
+          );
+          rtspSocket.destroy();
+          return false;
+        }
         try {
           return rtspSocket.write(frameRtpOverTcp(channel, msg));
         } catch (error) {
@@ -6631,6 +6696,24 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     let frameCount = 0;
     let lastFrameTime = Date.now();
     const targetFrameInterval = streamMetadata && streamMetadata.frameRate > 0 ? 1e3 / streamMetadata.frameRate : 40;
+    const prebufferSnap = this.prebuffer.slice();
+    let lastIdrIdx = -1;
+    for (let i = prebufferSnap.length - 1; i >= 0; i--) {
+      if (prebufferSnap[i].isKeyframe) {
+        lastIdrIdx = i;
+        break;
+      }
+    }
+    const prebufferFrames = lastIdrIdx >= 0 ? prebufferSnap.slice(lastIdrIdx) : [];
+    if (prebufferFrames.length > 0) {
+      this.logger.info(
+        `[rebroadcast] prebuffer replay  client=${clientId} frames=${prebufferFrames.length} starting from IDR`
+      );
+    }
+    const combined = async function* () {
+      for (const entry of prebufferFrames) yield entry.frame;
+      for await (const f of clientGenerator) yield f;
+    };
     const feedFrames = async () => {
       try {
         this.rtspDebugLog(
@@ -6642,7 +6725,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         let firstVideoFrameSeenLogged = false;
         let h265WaitParamSetsLogged = false;
         let h265WaitIrapLogged = false;
-        for await (const frame of clientGenerator) {
+        for await (const frame of combined()) {
           if (!this.connectedClients.has(clientId)) {
             this.rtspDebugLog(
               `Client ${clientId} disconnected, stopping frame feed`
@@ -6745,15 +6828,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);
@@ -6826,6 +6911,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(
@@ -6833,6 +6923,9 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
                 );
               }
             }
+            if (resources) {
+              resources.framesSent = (resources.framesSent ?? 0) + 1;
+            }
             sendVideoAccessUnit(videoType, normalizedVideoData, true);
           } else {
             try {
@@ -6917,8 +7010,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({
@@ -6956,11 +7049,41 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         if (hasParamSets) {
           this.markFirstFrameReceived();
         }
+        const isKeyframe = this.isRawFrameKeyframe(frame);
+        this.prebuffer.push({
+          frame: { ...frame, data: Buffer.from(frame.data) },
+          time: Date.now(),
+          isKeyframe
+        });
+        const cutoff = Date.now() - this.PREBUFFER_MAX_MS;
+        let trimIdx = 0;
+        while (trimIdx < this.prebuffer.length && this.prebuffer[trimIdx].time < cutoff) {
+          trimIdx++;
+        }
+        if (trimIdx > 0) this.prebuffer.splice(0, trimIdx);
       },
       onError: (error) => {
         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.prebuffer = [];
+        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();
@@ -6999,7 +7122,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;
@@ -7018,6 +7143,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       this.nativeFanout = null;
       await fanout.stop();
     }
+    this.prebuffer = [];
     if (this.tempStreamGenerator) {
       try {
         await this.tempStreamGenerator.return(void 0);
@@ -7033,9 +7159,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();
       }
@@ -7268,10 +7391,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",
@@ -7283,20 +7408,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;
@@ -7328,6 +7450,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
@@ -7340,6 +7463,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;
@@ -7355,14 +7481,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;
@@ -9237,6 +9364,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();
@@ -9546,6 +9828,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
   // ─────────────────────────────────────────────────────────────────────────────
@@ -9575,10 +9862,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).
@@ -10519,42 +10990,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);
@@ -10563,32 +10998,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`.
@@ -11419,6 +11833,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;
@@ -11481,7 +11897,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);
     }
@@ -11997,11 +12413,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"
@@ -12031,7 +12486,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         );
       }
     }
-    const cacheKey = `baichuan:${channels.join(",")}`;
+    const cacheKey = `${source}:${channels.join(",")}`;
     const cached = this.nvrChannelsSummaryCache.get(cacheKey);
     if (cached) {
       return {
@@ -12052,8 +12507,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;
@@ -12061,6 +12518,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,
@@ -12070,19 +12530,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 };
@@ -16350,13 +16810,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;
@@ -16372,6 +16831,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, {
@@ -16408,7 +16886,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,
@@ -16435,90 +16916,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.
    */
@@ -17287,7 +17684,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),
@@ -17303,7 +17700,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
@@ -19391,6 +19788,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
@@ -20388,6 +20995,7 @@ export {
   flattenAbilitiesForChannel,
   abilitiesHasAny,
   parseSupportXml,
+  getSupportItemForChannel,
   computeDeviceCapabilities,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
@@ -20406,4 +21014,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-PCPEXOWB.js.map
+//# sourceMappingURL=chunk-RWYEGEWG.js.map