@apocaliss92/nodelink-js 0.1.9 → 0.1.17

package/dist/{chunk-YUBYINJF.js → chunk-ULSFEQSE.js}

@@ -58,6 +58,7 @@ import {
   BC_CMD_ID_GET_WIFI,
   BC_CMD_ID_GET_WIFI_SIGNAL,
   BC_CMD_ID_GET_ZOOM_FOCUS,
+  BC_CMD_ID_LOGOUT,
   BC_CMD_ID_PING,
   BC_CMD_ID_PTZ_CONTROL,
   BC_CMD_ID_PTZ_CONTROL_PRESET,
@@ -101,6 +102,7 @@ import {
   buildChannelExtensionXml,
   buildFloodlightManualXml,
   buildLoginXml,
+  buildLogoutXml,
   buildPreviewStopXml,
   buildPreviewStopXmlV11,
   buildPreviewXml,
@@ -134,7 +136,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-TZFZ5WJX.js";
+} from "./chunk-ZE7D7LI4.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -692,7 +694,9 @@ var BcUdpStream = class extends EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    await new Promise((resolve) => sock.bind(0, "0.0.0.0", () => resolve()));
+    await new Promise(
+      (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
+    );
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -703,7 +707,8 @@ var BcUdpStream = class extends EventEmitter {
     this.startTimers();
   }
   async discoveryUid(sock) {
-    if (this.opts.mode !== "uid") throw new Error("Internal: discoveryUid called for non-uid mode");
+    if (this.opts.mode !== "uid")
+      throw new Error("Internal: discoveryUid called for non-uid mode");
     const method = this.opts.discoveryMethod ?? "local-direct";
     if (method === "local-broadcast" || method === "local-direct") {
       await this.discoveryUidLocal(sock, { localMode: method });
@@ -725,10 +730,13 @@ var BcUdpStream = class extends EventEmitter {
         }
       }
     }
-    throw new Error("No non-loopback IPv4 address found (required for P2P discovery)");
+    throw new Error(
+      "No non-loopback IPv4 address found (required for P2P discovery)"
+    );
   }
   async discoveryUidP2p(sock, method) {
-    if (this.opts.mode !== "uid") throw new Error("Internal: discoveryUidP2p called for non-uid mode");
+    if (this.opts.mode !== "uid")
+      throw new Error("Internal: discoveryUidP2p called for non-uid mode");
     const addr = sock.address();
     const localPort = typeof addr === "string" ? 0 : addr.port;
     const cid = Math.floor(Math.random() * 2147483647) | 0 || 82e3;
@@ -741,7 +749,11 @@ var BcUdpStream = class extends EventEmitter {
       reg: lookup.reg
     });
     const conn = method === "remote" ? "local" : method;
-    const connected = await this.p2pConnect(sock, { ...reg, uid: this.opts.uid, cid }, method);
+    const connected = await this.p2pConnect(
+      sock,
+      { ...reg, uid: this.opts.uid, cid },
+      method
+    );
     await this.p2pConfirm(sock, reg.reg, {
       sid: reg.sid,
       conn,
@@ -760,13 +772,16 @@ var BcUdpStream = class extends EventEmitter {
       try {
         const answers = await dns.lookup(host, { family: 4, all: true });
         for (const a of answers) {
-          if (a.address && !resolved.includes(a.address)) resolved.push(a.address);
+          if (a.address && !resolved.includes(a.address))
+            resolved.push(a.address);
         }
       } catch {
       }
     }
     if (resolved.length === 0) {
-      throw new Error("P2P UID lookup failed: no p2p.reolink.com addresses resolved");
+      throw new Error(
+        "P2P UID lookup failed: no p2p.reolink.com addresses resolved"
+      );
     }
     const start = Date.now();
     let lastErr;
@@ -774,7 +789,12 @@ var BcUdpStream = class extends EventEmitter {
       const remaining = P2P_MAX_WAIT_MS - (Date.now() - start);
       if (remaining <= 0) break;
       try {
-        const res = await this.p2pUidLookupOne(sock, uid, { host: ip, port: P2P_LOOKUP_PORT }, Math.min(remaining, 3e3));
+        const res = await this.p2pUidLookupOne(
+          sock,
+          uid,
+          { host: ip, port: P2P_LOOKUP_PORT },
+          Math.min(remaining, 3e3)
+        );
         return res;
       } catch (e) {
         lastErr = e instanceof Error ? e : new Error(String(e));
@@ -896,26 +916,64 @@ var BcUdpStream = class extends EventEmitter {
   async p2pConnect(sock, reg, method) {
     if (method === "remote") {
       const tasks = [];
-      if (reg.dev) tasks.push(this.p2pClientInitiated(sock, { sid: reg.sid, cid: reg.cid, conn: "local", dest: reg.dev }));
-      if (reg.dmap) tasks.push(this.p2pDeviceInitiated(sock, { sid: reg.sid, cid: reg.cid, conn: "local", expectFrom: reg.dmap }));
-      if (tasks.length === 0) throw new Error("P2P remote discovery: missing dev/dmap addresses");
+      if (reg.dev)
+        tasks.push(
+          this.p2pClientInitiated(sock, {
+            sid: reg.sid,
+            cid: reg.cid,
+            conn: "local",
+            dest: reg.dev
+          })
+        );
+      if (reg.dmap)
+        tasks.push(
+          this.p2pDeviceInitiated(sock, {
+            sid: reg.sid,
+            cid: reg.cid,
+            conn: "local",
+            expectFrom: reg.dmap
+          })
+        );
+      if (tasks.length === 0)
+        throw new Error("P2P remote discovery: missing dev/dmap addresses");
       return await Promise.race(tasks);
     }
     if (method === "map") {
       if (!reg.dmap) throw new Error("P2P map discovery: missing dmap address");
-      return await this.p2pDeviceInitiated(sock, { sid: reg.sid, cid: reg.cid, conn: "map", expectFrom: reg.dmap });
+      return await this.p2pDeviceInitiated(sock, {
+        sid: reg.sid,
+        cid: reg.cid,
+        conn: "map",
+        expectFrom: reg.dmap
+      });
     }
-    if (!reg.relay) throw new Error("P2P relay discovery: missing relay address");
-    return await this.p2pClientInitiated(sock, { sid: reg.sid, cid: reg.cid, conn: "relay", dest: reg.relay, requireConnMatch: true });
+    if (!reg.relay)
+      throw new Error("P2P relay discovery: missing relay address");
+    return await this.p2pClientInitiated(sock, {
+      sid: reg.sid,
+      cid: reg.cid,
+      conn: "relay",
+      dest: reg.relay,
+      requireConnMatch: true
+    });
   }
   async p2pClientInitiated(sock, params) {
     const tid = (Math.floor(Math.random() * 2147483647) | 0) >>> 0;
-    const xml = buildC2dT({ sid: params.sid, conn: params.conn, cid: params.cid, mtu: this.mtu });
+    const xml = buildC2dT({
+      sid: params.sid,
+      conn: params.conn,
+      cid: params.cid,
+      mtu: this.mtu
+    });
     const pkt = encodeDiscoveryPacket(tid, xml);
     return await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
-        reject(new Error(`P2P client-initiated (${params.conn}) timeout after ${P2P_MAX_WAIT_MS}ms`));
+        reject(
+          new Error(
+            `P2P client-initiated (${params.conn}) timeout after ${P2P_MAX_WAIT_MS}ms`
+          )
+        );
       }, P2P_MAX_WAIT_MS);
       const onMsg = (msg, rinfo) => {
         try {
@@ -925,10 +983,16 @@ var BcUdpStream = class extends EventEmitter {
           if (!cfm) return;
           if (cfm.cid !== params.cid) return;
           if (cfm.sid !== params.sid) return;
-          if (params.requireConnMatch && (cfm.conn ?? "") !== params.conn) return;
+          if (params.requireConnMatch && (cfm.conn ?? "") !== params.conn)
+            return;
           if (cfm.did == null) return;
           cleanup();
-          resolve({ did: cfm.did, rhost: rinfo.address, rport: rinfo.port, tid });
+          resolve({
+            did: cfm.did,
+            rhost: rinfo.address,
+            rport: rinfo.port,
+            tid
+          });
         } catch {
         }
       };
@@ -952,7 +1016,11 @@ var BcUdpStream = class extends EventEmitter {
     return await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
-        reject(new Error(`P2P device-initiated (${params.conn}) timeout after ${P2P_MAX_WAIT_MS}ms`));
+        reject(
+          new Error(
+            `P2P device-initiated (${params.conn}) timeout after ${P2P_MAX_WAIT_MS}ms`
+          )
+        );
       }, P2P_MAX_WAIT_MS);
       let state = "wait_t";
       let did;
@@ -961,9 +1029,16 @@ var BcUdpStream = class extends EventEmitter {
       let rport;
       let resendA;
       const sendA = () => {
-        if (state !== "wait_cfm" || did == null || tid == null || rhost == null || rport == null) return;
+        if (state !== "wait_cfm" || did == null || tid == null || rhost == null || rport == null)
+          return;
         try {
-          const aXml = buildC2dA({ sid: params.sid, conn: params.conn, cid: params.cid, did, mtu: this.mtu });
+          const aXml = buildC2dA({
+            sid: params.sid,
+            conn: params.conn,
+            cid: params.cid,
+            did,
+            mtu: this.mtu
+          });
           const aPkt = encodeDiscoveryPacket(tid, aXml);
           sock.send(aPkt, rport, rhost);
         } catch {
@@ -999,7 +1074,12 @@ var BcUdpStream = class extends EventEmitter {
           if (cfm.did !== did) return;
           if ((cfm.conn ?? "") !== params.conn) return;
           cleanup();
-          resolve({ did, rhost: info.address, rport: info.port, tid: tid ?? 0 });
+          resolve({
+            did,
+            rhost: info.address,
+            rport: info.port,
+            tid: tid ?? 0
+          });
         } catch {
         }
       };
@@ -1012,7 +1092,13 @@ var BcUdpStream = class extends EventEmitter {
     });
   }
   async p2pConfirm(sock, reg, params) {
-    const xml = buildC2rCfm({ sid: params.sid, conn: params.conn, rsp: 0, cid: params.cid, did: params.did });
+    const xml = buildC2rCfm({
+      sid: params.sid,
+      conn: params.conn,
+      rsp: 0,
+      cid: params.cid,
+      did: params.did
+    });
     for (let i = 0; i < 5; i++) {
       const tid = (Math.floor(Math.random() * 2147483647) | 0) >>> 0;
       const pkt = encodeDiscoveryPacket(tid, xml);
@@ -1024,8 +1110,12 @@ var BcUdpStream = class extends EventEmitter {
     }
   }
   async discoveryUidLocal(sock, opts) {
-    if (this.opts.mode !== "uid") throw new Error("Internal: discoveryUidLocal called for non-uid mode");
-    const ports = [BCUDP_DISCOVERY_PORT_LOCAL_ANY, BCUDP_DISCOVERY_PORT_LOCAL_UID];
+    if (this.opts.mode !== "uid")
+      throw new Error("Internal: discoveryUidLocal called for non-uid mode");
+    const ports = [
+      BCUDP_DISCOVERY_PORT_LOCAL_ANY,
+      BCUDP_DISCOVERY_PORT_LOCAL_UID
+    ];
     const broadcastHost = "255.255.255.255";
     const directHost = (this.opts.directHost ?? "").trim();
     const localMode = opts?.localMode ?? "local-broadcast";
@@ -1037,12 +1127,21 @@ var BcUdpStream = class extends EventEmitter {
     const addr = sock.address();
     const localPort = typeof addr === "string" ? 0 : addr.port;
     const cid = Math.floor(Math.random() * 2147483647) | 0 || 82e3;
-    const xml = buildC2dC({ uid: this.opts.uid, clientPort: localPort, cid, mtu: this.mtu });
+    const xml = buildC2dC({
+      uid: this.opts.uid,
+      clientPort: localPort,
+      cid,
+      mtu: this.mtu
+    });
     const reply = await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         if (retryTimer) clearInterval(retryTimer);
         sock.off("message", onMsg);
-        reject(new Error(`BCUDP discovery timeout after ${discoveryTimeout}ms (camera may be sleeping or unreachable)`));
+        reject(
+          new Error(
+            `BCUDP discovery timeout after ${discoveryTimeout}ms (camera may be sleeping or unreachable)`
+          )
+        );
       }, discoveryTimeout);
       let retryTimer;
       let retryCount = 0;
@@ -1064,8 +1163,16 @@ var BcUdpStream = class extends EventEmitter {
           sock.off("message", onMsg);
           clearTimeout(timeout);
           if (retryTimer) clearInterval(retryTimer);
-          this.emit("debug", "discovery_finalize", { reason, ...sid != null ? { sid } : {}, ...d });
-          resolve({ ...d, ...sid != null ? { sid } : {}, ...tid != null ? { tid } : {} });
+          this.emit("debug", "discovery_finalize", {
+            reason,
+            ...sid != null ? { sid } : {},
+            ...d
+          });
+          resolve({
+            ...d,
+            ...sid != null ? { sid } : {},
+            ...tid != null ? { tid } : {}
+          });
         }, 250);
       };
       const sendT = (rhost, rport) => {
@@ -1074,11 +1181,22 @@ var BcUdpStream = class extends EventEmitter {
         if (discoveredSid == null) return;
         try {
           const tid = (Math.floor(Math.random() * 2147483647) | 0) >>> 0;
-          const tXml = buildC2dT({ ...discoveredSid != null ? { sid: discoveredSid } : {}, cid: discovered.cid, mtu: this.mtu, conn: "local" });
+          const tXml = buildC2dT({
+            ...discoveredSid != null ? { sid: discoveredSid } : {},
+            cid: discovered.cid,
+            mtu: this.mtu,
+            conn: "local"
+          });
           const tPkt = encodeDiscoveryPacket(tid, tXml);
           sock.send(tPkt, rport, rhost);
           sentT = true;
-          this.emit("debug", "discovery_t_send", { sid: discoveredSid, cid: discovered.cid, did: discovered.did, rhost, rport });
+          this.emit("debug", "discovery_t_send", {
+            sid: discoveredSid,
+            cid: discovered.cid,
+            did: discovered.did,
+            rhost,
+            rport
+          });
         } catch (e) {
           this.emit("debug", "discovery_t_send_error", e);
         }
@@ -1086,11 +1204,23 @@ var BcUdpStream = class extends EventEmitter {
       const sendA = (tid, rhost, rport, dt) => {
         if (sentA) return;
         try {
-          const aXml = buildC2dA({ sid: dt.sid, conn: dt.conn ?? "local", cid: dt.cid, did: dt.did, mtu: this.mtu });
+          const aXml = buildC2dA({
+            sid: dt.sid,
+            conn: dt.conn ?? "local",
+            cid: dt.cid,
+            did: dt.did,
+            mtu: this.mtu
+          });
           const aPkt = encodeDiscoveryPacket(tid, aXml);
           sock.send(aPkt, rport, rhost);
           sentA = true;
-          this.emit("debug", "discovery_a_send", { sid: dt.sid, cid: dt.cid, did: dt.did, rhost, rport });
+          this.emit("debug", "discovery_a_send", {
+            sid: dt.sid,
+            cid: dt.cid,
+            did: dt.did,
+            rhost,
+            rport
+          });
         } catch (e) {
           this.emit("debug", "discovery_a_send_error", e);
         }
@@ -1099,12 +1229,22 @@ var BcUdpStream = class extends EventEmitter {
         try {
           const p = decodeBcUdpPacket(msg);
           if (p.kind !== "discovery") return;
-          this.emit("debug", "discovery_rx", { tid: p.tid, rhost: rinfo.address, rport: rinfo.port, xmlPreview: p.xml.slice(0, 120) });
+          this.emit("debug", "discovery_rx", {
+            tid: p.tid,
+            rhost: rinfo.address,
+            rport: rinfo.port,
+            xmlPreview: p.xml.slice(0, 120)
+          });
           const cfm = parseD2cCfm(p.xml);
           if (cfm) {
             discoveredSid = cfm.sid;
             if (!discovered && cfm.cid != null && cfm.did != null) {
-              discovered = { cid: cfm.cid, did: cfm.did, rhost: rinfo.address, rport: rinfo.port };
+              discovered = {
+                cid: cfm.cid,
+                did: cfm.did,
+                rhost: rinfo.address,
+                rport: rinfo.port
+              };
             }
             if (discovered) {
               sendT(rinfo.address, rinfo.port);
@@ -1116,9 +1256,20 @@ var BcUdpStream = class extends EventEmitter {
             gotT = true;
             discoveredSid = dt.sid;
             if (!discovered) {
-              discovered = { cid: dt.cid, did: dt.did, rhost: rinfo.address, rport: rinfo.port };
+              discovered = {
+                cid: dt.cid,
+                did: dt.did,
+                rhost: rinfo.address,
+                rport: rinfo.port
+              };
             }
-            this.emit("debug", "discovery_t_rx", { sid: dt.sid, cid: dt.cid, did: dt.did, rhost: rinfo.address, rport: rinfo.port });
+            this.emit("debug", "discovery_t_rx", {
+              sid: dt.sid,
+              cid: dt.cid,
+              did: dt.did,
+              rhost: rinfo.address,
+              rport: rinfo.port
+            });
             sendA(p.tid, rinfo.address, rinfo.port, dt);
             maybeFinalize("t_a");
             return;
@@ -1126,9 +1277,20 @@ var BcUdpStream = class extends EventEmitter {
           const parsed = parseD2cCr(p.xml);
           if (!parsed) return;
           if (parsed.rsp !== 0) return;
-          this.emit("debug", "discovery_success", { retryCount, rhost: rinfo.address, rport: rinfo.port, sid: parsed.sid ?? discoveredSid, timer: parsed.timer });
+          this.emit("debug", "discovery_success", {
+            retryCount,
+            rhost: rinfo.address,
+            rport: rinfo.port,
+            sid: parsed.sid ?? discoveredSid,
+            timer: parsed.timer
+          });
           discoveredTid = p.tid;
-          discovered = { cid: parsed.cid, did: parsed.did, rhost: rinfo.address, rport: rinfo.port };
+          discovered = {
+            cid: parsed.cid,
+            did: parsed.did,
+            rhost: rinfo.address,
+            rport: rinfo.port
+          };
           if (parsed.sid != null) discoveredSid = parsed.sid;
           sendT(rinfo.address, rinfo.port);
           if (gotT || sentA) {
@@ -1155,7 +1317,8 @@ var BcUdpStream = class extends EventEmitter {
         const hosts = (() => {
           if (localMode === "local-direct") {
             if (directHost) {
-              if (directFirstWindowMs > 0 && elapsedMs < directFirstWindowMs) return [directHost];
+              if (directFirstWindowMs > 0 && elapsedMs < directFirstWindowMs)
+                return [directHost];
               return [directHost, broadcastHost];
             }
             return [broadcastHost];
@@ -1214,12 +1377,18 @@ var BcUdpStream = class extends EventEmitter {
     }, 1e3);
   }
   sendHeartbeat() {
-    if (!this.sock || !this.remote || this.clientId == null || this.cameraId == null) return;
+    if (!this.sock || !this.remote || this.clientId == null || this.cameraId == null)
+      return;
     const tid = this.getKeepAliveTid();
     let xml;
     xml = buildC2dHb({ cid: this.clientId, did: this.cameraId });
     const pkt = encodeDiscoveryPacket(tid, xml);
-    this.emit("debug", "udp_hb_send", { tid, xml, host: this.remote.host, port: this.remote.port });
+    this.emit("debug", "udp_hb_send", {
+      tid,
+      xml,
+      host: this.remote.host,
+      port: this.remote.port
+    });
     this.sock.send(pkt, this.remote.port, this.remote.host);
   }
   buildAckPayload() {
@@ -1263,7 +1432,9 @@ var BcUdpStream = class extends EventEmitter {
     this.sock.send(this.lastAckPacket, this.remote.port, this.remote.host);
     this.ackSentCount++;
     if (this.ackSentCount % 100 === 0) {
-      this.emit("debug", "ack_sent_100", { latency: this.ackLatency.getValue() });
+      this.emit("debug", "ack_sent_100", {
+        latency: this.ackLatency.getValue()
+      });
     }
   }
   scheduleAck(reason = "data") {
@@ -1338,7 +1509,11 @@ var BcUdpStream = class extends EventEmitter {
     const updateRemote = (reason) => {
       if (!this.remote || this.remote.host !== rhost || this.remote.port !== rport) {
         this.remote = { host: rhost, port: rport };
-        this.emit("debug", "remote_update", { reason, host: rhost, port: rport });
+        this.emit("debug", "remote_update", {
+          reason,
+          host: rhost,
+          port: rport
+        });
       }
     };
     if (!this.remote) updateRemote("first_packet");
@@ -1357,7 +1532,9 @@ var BcUdpStream = class extends EventEmitter {
           this.flushReceived();
           this.updateAckPacket();
           if (this.packetsWant % 100 === 0) {
-            this.emit("debug", "udp_progress", { packetsWant: this.packetsWant });
+            this.emit("debug", "udp_progress", {
+              packetsWant: this.packetsWant
+            });
           }
         }
       }
@@ -1367,7 +1544,11 @@ var BcUdpStream = class extends EventEmitter {
       this.emit("debug", "discovery_rx_connected", { tid: p.tid, xml: p.xml });
       const hb = parseD2cHb(p.xml);
       if (hb && this.clientId != null && this.cameraId != null && hb.cid === this.clientId && hb.did === this.cameraId) {
-        this.emit("debug", "discovery_hb_rx_connected", { ...hb, rhost, rport });
+        this.emit("debug", "discovery_hb_rx_connected", {
+          ...hb,
+          rhost,
+          rport
+        });
         try {
           updateRemote("d2c_hb");
           this.sendHeartbeat();
@@ -1381,18 +1562,44 @@ var BcUdpStream = class extends EventEmitter {
         try {
           updateRemote("d2c_t");
           this.sid = dt.sid;
-          this.emit("debug", "discovery_t_rx_connected", { sid: dt.sid, cid: dt.cid, did: dt.did, rhost, rport });
+          this.emit("debug", "discovery_t_rx_connected", {
+            sid: dt.sid,
+            cid: dt.cid,
+            did: dt.did,
+            rhost,
+            rport
+          });
           const now = Date.now();
           const throttleMs = 750;
           if (this.lastAcceptAtMs == null || now - this.lastAcceptAtMs >= throttleMs) {
-            const aXml = buildC2dA({ sid: dt.sid, conn: dt.conn ?? "local", cid: dt.cid, did: dt.did, mtu: this.mtu });
+            const aXml = buildC2dA({
+              sid: dt.sid,
+              conn: dt.conn ?? "local",
+              cid: dt.cid,
+              did: dt.did,
+              mtu: this.mtu
+            });
             const aPkt = encodeDiscoveryPacket(p.tid, aXml);
             this.sock?.send(aPkt, rport, rhost);
             this.acceptSent = true;
             this.lastAcceptAtMs = now;
-            this.emit("debug", "discovery_a_send_connected", { sid: dt.sid, cid: dt.cid, did: dt.did, rhost, rport });
+            this.emit("debug", "discovery_a_send_connected", {
+              sid: dt.sid,
+              cid: dt.cid,
+              did: dt.did,
+              rhost,
+              rport
+            });
           } else {
-            this.emit("debug", "discovery_a_skip_throttle", { sinceMs: now - this.lastAcceptAtMs, throttleMs, sid: dt.sid, cid: dt.cid, did: dt.did, rhost, rport });
+            this.emit("debug", "discovery_a_skip_throttle", {
+              sinceMs: now - this.lastAcceptAtMs,
+              throttleMs,
+              sid: dt.sid,
+              cid: dt.cid,
+              did: dt.did,
+              rhost,
+              rport
+            });
           }
         } catch (e) {
           this.emit("debug", "discovery_a_send_connected_error", e);
@@ -1409,10 +1616,16 @@ var BcUdpStream = class extends EventEmitter {
       }
       const disc = parseD2cDisc(p.xml);
       if (disc && this.clientId != null && this.cameraId != null && disc.cid === this.clientId && disc.did === this.cameraId) {
-        this.emit("debug", "discovery_disc_rx_connected", { ...disc, rhost, rport });
+        this.emit("debug", "discovery_disc_rx_connected", {
+          ...disc,
+          rhost,
+          rport
+        });
         this.emit(
           "error",
-          new Error(`BCUDP disconnected by camera (D2C_DISC${this.sid != null ? ` sid=${this.sid}` : ""})`)
+          new Error(
+            `BCUDP disconnected by camera (D2C_DISC${this.sid != null ? ` sid=${this.sid}` : ""})`
+          )
         );
         void this.close();
         return;
@@ -1421,13 +1634,18 @@ var BcUdpStream = class extends EventEmitter {
     return;
   }
   write(buf) {
-    if (!this.sock || !this.remote || this.cameraId == null) throw new Error("BCUDP stream is not connected");
+    if (!this.sock || !this.remote || this.cameraId == null)
+      throw new Error("BCUDP stream is not connected");
     const maxPayload = this.mtu - BCUDP_DATA_HEADER_SIZE;
     for (let off = 0; off < buf.length; off += maxPayload) {
       const payload = buf.subarray(off, Math.min(buf.length, off + maxPayload));
       const packetId = this.sendPacketId >>> 0;
       this.sendPacketId = this.sendPacketId + 1 >>> 0;
-      const pkt = encodeDataPacket({ connectionId: this.cameraId, packetId, payload: Buffer.from(payload) });
+      const pkt = encodeDataPacket({
+        connectionId: this.cameraId,
+        packetId,
+        payload: Buffer.from(payload)
+      });
       this.sent.set(packetId, { packetId, buf: pkt, ts: Date.now() });
       this.sock.send(pkt, this.remote.port, this.remote.host);
     }
@@ -1580,6 +1798,15 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    *   even if the current client instance is idle/disconnected.
    */
   static streamingRegistry = /* @__PURE__ */ new Map();
+  /**
+   * Global (process-wide) CoverPreview serialization.
+   *
+   * Why:
+   * - CoverPreview uses fixed msgNum=0 and some firmwares correlate requests loosely.
+   * - Concurrent CoverPreview attempts can cause cross-talk (400 rejects / timeouts)
+   *   and may leave device-side sessions in a bad state.
+   */
+  static coverPreviewQueueTail = /* @__PURE__ */ new Map();
   opts;
   debugCfg;
   logger;
@@ -1598,6 +1825,14 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   socketClosed = false;
   pendingCloseInfo;
   lastDisconnectInfo;
+  /** Tracks the most recent socket error code for inclusion in lastDisconnectInfo. */
+  lastSocketErrorCode;
+  /**
+   * Promise lock to prevent parallel TCP connections.
+   * When multiple callers race to connect, only the first one creates a socket;
+   * others wait on the same promise.
+   */
+  tcpConnectPromise;
   msgNum = 0;
   loggedIn = false;
   // Public to allow ReolinkBaichuanApi to check login status
@@ -1689,6 +1924,23 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   isIdleDisconnectEnabled() {
     return this.opts.idleDisconnect === true;
   }
+  /**
+   * Enable or disable idle disconnect dynamically.
+   *
+   * This is useful when the battery status is discovered after connection
+   * (e.g., during autodetect). Call with `true` for battery cameras to
+   * preserve battery life by disconnecting when idle.
+   *
+   * @param enabled - true to enable idle disconnect, false to disable
+   */
+  setIdleDisconnect(enabled) {
+    this.opts.idleDisconnect = enabled;
+    if (enabled) {
+      this.kickIdleDisconnectTimer();
+    } else {
+      this.clearIdleDisconnectTimer();
+    }
+  }
   clearIdleDisconnectTimer() {
     if (!this.idleDisconnectTimer) return;
     clearTimeout(this.idleDisconnectTimer);
@@ -1822,6 +2074,28 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     const channel = this.opts.channel ?? 0;
     return `${host}|${uid}|${channel}`;
   }
+  getCoverPreviewQueueKey() {
+    const host = (this.opts.host ?? "").trim();
+    const uid = (this.opts.uid ?? "").trim().toUpperCase();
+    return `coverpreview|${host}|${uid}`;
+  }
+  async withSerializedCoverPreview(fn) {
+    const key = this.getCoverPreviewQueueKey();
+    const prevTail = _BaichuanClient.coverPreviewQueueTail.get(key) ?? Promise.resolve();
+    const run = prevTail.catch(() => void 0).then(fn);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    _BaichuanClient.coverPreviewQueueTail.set(key, tail);
+    try {
+      return await run;
+    } finally {
+      if (_BaichuanClient.coverPreviewQueueTail.get(key) === tail) {
+        _BaichuanClient.coverPreviewQueueTail.delete(key);
+      }
+    }
+  }
   recomputeGlobalStreamingContribution() {
     const shouldContribute = this.hasActiveVideoSubscriptionsInternal();
     if (shouldContribute === this.contributesToGlobalStreamingRegistry) return;
@@ -1856,6 +2130,62 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       this.emit("debug", event, data);
     }
   }
+  getTcpSocketDebugSnapshot(sock) {
+    if (!sock) return void 0;
+    const s = sock;
+    const snap = {
+      destroyed: sock.destroyed,
+      bytesRead: sock.bytesRead,
+      bytesWritten: sock.bytesWritten
+    };
+    if (typeof s.readyState === "string") snap.readyState = s.readyState;
+    if (typeof s.connecting === "boolean") snap.connecting = s.connecting;
+    if (typeof s.pending === "boolean") snap.pending = s.pending;
+    if (sock.localAddress != null) snap.localAddress = sock.localAddress;
+    if (sock.localFamily != null) snap.localFamily = sock.localFamily;
+    if (sock.localPort != null) snap.localPort = sock.localPort;
+    if (sock.remoteAddress != null) snap.remoteAddress = sock.remoteAddress;
+    if (sock.remoteFamily != null) snap.remoteFamily = sock.remoteFamily;
+    if (sock.remotePort != null) snap.remotePort = sock.remotePort;
+    if (typeof s.readableLength === "number")
+      snap.readableLength = s.readableLength;
+    if (typeof s.writableLength === "number")
+      snap.writableLength = s.writableLength;
+    if (typeof s.timeout === "number") snap.timeoutMs = s.timeout;
+    return snap;
+  }
+  logSocketState(reason, extra) {
+    try {
+      const transport = this.transport;
+      const sid = this.socketSessionId;
+      const host = this.opts.host;
+      const port = this.opts.port ?? BC_TCP_DEFAULT_PORT;
+      const shortUid = this.opts.uid ? this.opts.uid.substring(0, 5) : void 0;
+      this.logDebug("socket_state", {
+        reason,
+        transport,
+        host,
+        ...transport === "tcp" ? { port } : {},
+        ...sid ? { sid } : {},
+        ...shortUid ? { uid: shortUid } : {},
+        socketClosed: this.socketClosed,
+        socketConnected: this.isSocketConnected(),
+        loggedIn: this.loggedIn,
+        subscribed: this.subscribed,
+        pending: this.pending.size,
+        permits: this.permits.size,
+        videoSubscriptions: this.videoSubscriptions.size,
+        lastRxAtMs: this.lastRxAtMs,
+        lastTxAtMs: this.lastTxAtMs,
+        lastRxCmdId: this.lastRxInfo?.cmdId,
+        lastTxCmdId: this.lastTxInfo?.cmdId,
+        tcp: this.getTcpSocketDebugSnapshot(this.tcpSocket),
+        udpConnected: this.udpSocket?.isConnected?.(),
+        ...extra
+      });
+    } catch {
+    }
+  }
   getTransport() {
     return this.transport;
   }
@@ -1935,6 +2265,19 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   getSocketSessionId() {
     return this.socketSessionId;
   }
+  /**
+   * Get the local IP address of the socket connection.
+   * This is the IP address that the camera sees as the client IP.
+   */
+  getLocalAddress() {
+    if (this.transport === "tcp" && this.tcpSocket) {
+      return this.tcpSocket.localAddress;
+    }
+    if (this.transport === "udp" && this.udpSocket) {
+      return this.udpSocket.localAddress?.();
+    }
+    return void 0;
+  }
   /**
    * Check if the socket is connected and ready for operations.
    * For TCP: checks if socket exists and is not destroyed.
@@ -2093,7 +2436,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     if (waitMs <= 0) return;
     const sid = this.socketSessionId;
     const shortUid = this.opts.uid ? this.opts.uid.substring(0, 5) : void 0;
-    this.logFixed("udp_reconnect_cooldown", {
+    this.logDebug("udp_reconnect_cooldown", {
       transport: "udp",
       host: this.opts.host,
       sid,
@@ -2103,6 +2446,33 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     await new Promise((resolve) => setTimeout(resolve, waitMs));
   }
   async connectTcp() {
+    if (this.tcpConnectPromise) {
+      this.logDebug(
+        "tcp_connect_waiting",
+        "Waiting for existing connection promise"
+      );
+      await this.tcpConnectPromise;
+      return;
+    }
+    if (this.tcpSocket && !this.tcpSocket.destroyed) {
+      this.transport = "tcp";
+      return;
+    }
+    this.logDebug("tcp_connect_new", {
+      hasSocket: !!this.tcpSocket,
+      destroyed: this.tcpSocket?.destroyed
+    });
+    this.tcpConnectPromise = this.doConnectTcp();
+    try {
+      await this.tcpConnectPromise;
+    } finally {
+      this.tcpConnectPromise = void 0;
+    }
+  }
+  /**
+   * Internal TCP connection logic. Only called from connectTcp() with promise lock.
+   */
+  async doConnectTcp() {
     if (this.tcpSocket && !this.tcpSocket.destroyed) {
       this.transport = "tcp";
       return;
@@ -2122,7 +2492,8 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       const frames = this.parser.push(chunk);
       for (const f of frames) this.handleFrame(f);
     });
-    sock.on("close", () => {
+    sock.on("close", (hadError) => {
+      this.logSocketState("tcp_close_event", { hadError: Boolean(hadError) });
       const sid2 = this.socketSessionId;
       if (sock === this.tcpSocket) {
         this.tcpSocket = void 0;
@@ -2135,11 +2506,14 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       this.socketClosed = true;
       const pending = this.pendingCloseInfo;
       this.pendingCloseInfo = void 0;
+      const errorCode = this.lastSocketErrorCode;
+      this.lastSocketErrorCode = void 0;
       this.lastDisconnectInfo = {
         atMs: Date.now(),
         transport: "tcp",
         voluntary: pending != null,
-        reason: pending?.reason ?? "socket_closed"
+        reason: pending?.reason ?? "socket_closed",
+        ...errorCode != null && { errorCode }
       };
       const tcpDisconnectParts = [
         `transport=tcp`,
@@ -2168,7 +2542,17 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         });
       }
     });
-    sock.on("error", (err) => this.emit("error", err));
+    sock.on("error", (err) => {
+      const code = err?.code;
+      this.lastSocketErrorCode = code;
+      this.logSocketState("tcp_error", {
+        error: {
+          message: err?.message ?? String(err),
+          code
+        }
+      });
+      this.emit("error", err);
+    });
     await new Promise((resolve, reject) => {
       sock.once("connect", () => resolve());
       sock.once("error", (e) => reject(e));
@@ -2186,6 +2570,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       "connected",
       `transport=tcp host=${this.opts.host} port=${port}${sid ? ` sid=${sid}` : ""}${remote ? ` remote=${remote}` : ""}${peer ? ` peer=${peer}` : ""}`
     );
+    this.logSocketState("tcp_connected");
     this.startKeepAlive();
     this.kickIdleDisconnectTimer();
   }
@@ -2202,13 +2587,18 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       this.udpSocket = void 0;
     }
     if (!this.opts.uid) {
-      throw new Error(
-        "Baichuan UDP requested but `options.uid` is not set (required for BCUDP discovery)."
-      );
+      const isLocalDirect = this.opts.udpDiscoveryMethod === "local-direct";
+      const hasDirectHost = !!this.opts.host?.trim();
+      if (!isLocalDirect || !hasDirectHost) {
+        throw new Error(
+          "Baichuan UDP requested but `options.uid` is not set (required for BCUDP discovery unless using local-direct with a direct host)."
+        );
+      }
     }
     const sock = new BcUdpStream({
       mode: "uid",
-      uid: this.opts.uid,
+      // UID may be empty for local-direct with directHost
+      uid: this.opts.uid ?? "",
       // If the camera IP/hostname is known, allow local-direct to try unicast before broadcast.
       ...this.opts.host?.trim() ? { directHost: this.opts.host.trim() } : {},
       ...this.opts.udpDiscoveryMethod ? { discoveryMethod: this.opts.udpDiscoveryMethod } : {}
@@ -2222,6 +2612,9 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       for (const f of frames) this.handleFrame(f);
     });
     sock.on("close", () => {
+      this.logSocketState("udp_close_event", {
+        udpConnected: sock.isConnected?.()
+      });
       const sid2 = this.socketSessionId;
       if (sock === this.udpSocket) {
         this.udpSocket = void 0;
@@ -2233,11 +2626,14 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       this.socketClosed = true;
       const pending = this.pendingCloseInfo;
       this.pendingCloseInfo = void 0;
+      const errorCode = this.lastSocketErrorCode;
+      this.lastSocketErrorCode = void 0;
       this.lastDisconnectInfo = {
         atMs: Date.now(),
         transport: "udp",
         voluntary: pending != null,
-        reason: pending?.reason ?? "socket_closed"
+        reason: pending?.reason ?? "socket_closed",
+        ...errorCode != null && { errorCode }
       };
       const udpDisconnectParts = [
         `transport=udp`,
@@ -2274,6 +2670,10 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     });
     sock.on("error", (err) => {
       if (err?.message?.includes("D2C_DISC")) {
+        this.logSocketState("udp_error_d2c_disc", {
+          message: err.message,
+          udpConnected: sock.isConnected?.()
+        });
         const now = Date.now();
         const sid2 = this.socketSessionId;
         const shortUid2 = this.opts.uid ? this.opts.uid.substring(0, 5) : void 0;
@@ -2300,7 +2700,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
           this.udpReconnectCooldownUntilMs,
           now + nextBackoffMs
         );
-        this.logFixed("d2c_disc_backoff", {
+        this.logDebug("d2c_disc_backoff", {
           transport: "udp",
           host: this.opts.host,
           sid: sid2,
@@ -2330,9 +2730,64 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       "connected",
       `transport=udp host=${this.opts.host}${sid ? ` sid=${sid}` : ""}${udpRemoteHost ? ` remote=${udpRemoteHost}` : ""} uid=${shortUid} udpDiscoveryMethod=${udpDiscoveryMethod}`
     );
+    this.logSocketState("udp_connected", {
+      udpConnected: sock.isConnected?.(),
+      udpRemoteHost,
+      udpDiscoveryMethod
+    });
     this.startKeepAlive();
     this.kickIdleDisconnectTimer();
   }
+  /**
+   * Send a logout command to the camera to gracefully end the session.
+   *
+   * This notifies the camera that we're done, preventing "hung" sessions
+   * that would otherwise wait for a timeout on the camera side.
+   *
+   * PCAP-confirmed: cmdId=2 with encrypted XML body.
+   * Call this before close() for clean session termination.
+   *
+   * @returns true if logout was sent and acknowledged, false if failed or not logged in
+   */
+  async logout() {
+    if (!this.loggedIn || !this.isSocketConnected()) {
+      this.logDebug("logout_skip", {
+        loggedIn: this.loggedIn,
+        socketConnected: this.isSocketConnected()
+      });
+      return false;
+    }
+    try {
+      this.logDebug("logout_start", { host: this.opts.host });
+      const logoutXml = buildLogoutXml();
+      const effectiveHostChannelId = this.hostChannelId;
+      const response = await this.sendFrame({
+        cmdId: BC_CMD_ID_LOGOUT,
+        payloadXml: logoutXml,
+        extensionXml: "",
+        messageClass: BC_CLASS_MODERN_24,
+        channelIdOverride: effectiveHostChannelId,
+        timeoutMs: 5e3
+        // Short timeout - camera should respond quickly
+      });
+      const responseCode = response.header.responseCode;
+      const success = responseCode === 200;
+      this.logDebug("logout_response", {
+        responseCode,
+        success
+      });
+      this.loggedIn = false;
+      this.nonce = void 0;
+      return success;
+    } catch (e) {
+      this.logDebug("logout_error", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      this.loggedIn = false;
+      this.nonce = void 0;
+      return false;
+    }
+  }
   async close(options) {
     const hasSocket = Boolean(
       this.tcpSocket && !this.tcpSocket.destroyed || this.udpSocket
@@ -2350,7 +2805,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       const host = this.opts.host;
       const port = this.opts.port ?? BC_TCP_DEFAULT_PORT;
       const shortUid = this.opts.uid ? this.opts.uid.substring(0, 5) : void 0;
-      this.logFixed("closing", {
+      this.logDebug("closing", {
         transport,
         host,
         ...transport === "tcp" ? { port } : {},
@@ -2365,15 +2820,26 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         permits: this.permits.size,
         videoSubscriptions: this.videoSubscriptions.size
       });
+      this.logSocketState("close_called", { reason });
       if ((process.env.BAICHUAN_LOG_CLOSE_STACK ?? "").trim() === "1") {
         const stack = new Error("BaichuanClient.close() stack").stack;
         if (stack) {
           const lines = stack.split("\n").slice(0, 10).join("\n");
-          this.logFixed("closing_stack", lines);
+          this.logDebug("closing_stack", lines);
         }
       }
     } catch {
     }
+    const skipLogout = options?.skipLogout ?? false;
+    if (!skipLogout && this.loggedIn && this.isSocketConnected()) {
+      try {
+        await this.logout();
+      } catch (e) {
+        this.logDebug("close_logout_error", {
+          error: e instanceof Error ? e.message : String(e)
+        });
+      }
+    }
     this.stopKeepAlive();
     this.clearIdleDisconnectTimer();
     for (const id of Array.from(this.permits.keys())) {
@@ -3940,27 +4406,31 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    * instead of JPEG.
    */
   async sendBinaryCoverPreview(params) {
-    const maxRetries = params.maxRetries ?? 5;
-    const retryDelayMs = params.retryDelayMs ?? 1e3;
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; 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) {
-          console.log(
-            `[CoverPreview] Attempt ${attempt + 1} got 400, retrying in ${retryDelayMs}ms...`
-          );
-          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-          continue;
+    return await this.withSerializedCoverPreview(async () => {
+      const maxRetries = params.maxRetries ?? 5;
+      const retryDelayMs = params.retryDelayMs ?? 1e3;
+      let lastError;
+      for (let attempt = 0; attempt < maxRetries; 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) {
+            this.logDebug("coverpreview_retry_400", {
+              attempt: attempt + 1,
+              maxRetries,
+              retryDelayMs
+            });
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            continue;
+          }
+          throw lastError;
         }
-        throw lastError;
       }
-    }
-    throw lastError ?? new Error("CoverPreview failed after all retries");
+      throw lastError ?? new Error("CoverPreview failed after all retries");
+    });
   }
   /**
    * Internal: single attempt for sendBinaryCoverPreview
@@ -4063,8 +4533,16 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     return await new Promise((resolve, reject) => {
       let timeout;
       let done = false;
+      const onClose = () => {
+        fail(
+          new Error(
+            `Baichuan socket closed while waiting CoverPreview cmdId=${cmdId} msgNum=${msgNum}`
+          )
+        );
+      };
       const cleanup = () => {
         this.off("frame", onFrame);
+        this.off("close", onClose);
         if (timeout) clearTimeout(timeout);
       };
       const finish = (buf) => {
@@ -4183,6 +4661,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         }
       }, timeoutMs);
       this.on("frame", onFrame);
+      this.on("close", onClose);
       try {
         this.logDebug("tx", {
           cmdId,
@@ -8261,7 +8740,10 @@ var logDebugStreamBlock = (params) => {
   const { logger, traceNativeStream, channel, tag, blockXml } = params;
   if (!traceNativeStream) return;
   if (!blockXml) {
-    (logger.warn ?? logger.log).call(logger, `[ReolinkBaichuanApi] getStreamMetadata(traceNativeStream): channel=${channel} tag=<${tag}> missing`);
+    (logger.warn ?? logger.log).call(
+      logger,
+      `[ReolinkBaichuanApi] getStreamMetadata(traceNativeStream): channel=${channel} tag=<${tag}> missing`
+    );
     return;
   }
   const raw = blockXml;
@@ -8297,7 +8779,8 @@ var buildStream = (params) => {
   const audio = Number(getXmlText(streamXml, "audio") ?? "0");
   const enabled = getXmlText(streamXml, "enable");
   const isEnabled = isEnabledFromText(enabled);
-  if (!isEnabled || !isPlausibleStream({ width, height, frameRate, bitRate })) return void 0;
+  if (!isEnabled || !isPlausibleStream({ width, height, frameRate, bitRate }))
+    return void 0;
   return {
     profile,
     audio,
@@ -8335,7 +8818,13 @@ var parseChannelStreamMetadataFromGetEncXml = (params) => {
   const mainMatch = xml.match(/<mainStream[^>]*>([\s\S]*?)<\/mainStream>/);
   if (mainMatch) {
     const mainXml = mainMatch[1] ?? "";
-    logDebugStreamBlock({ logger, traceNativeStream, channel, tag: "mainStream", blockXml: mainXml });
+    logDebugStreamBlock({
+      logger,
+      traceNativeStream,
+      channel,
+      tag: "mainStream",
+      blockXml: mainXml
+    });
     const s = buildStream({ profile: "main", streamXml: mainXml });
     if (s) {
       streams.push(s);
@@ -8345,19 +8834,40 @@ var parseChannelStreamMetadataFromGetEncXml = (params) => {
   const subMatch = xml.match(/<subStream[^>]*>([\s\S]*?)<\/subStream>/);
   if (subMatch) {
     const subXml = subMatch[1] ?? "";
-    logDebugStreamBlock({ logger, traceNativeStream, channel, tag: "subStream", blockXml: subXml });
+    logDebugStreamBlock({
+      logger,
+      traceNativeStream,
+      channel,
+      tag: "subStream",
+      blockXml: subXml
+    });
     const s = buildStream({ profile: "sub", streamXml: subXml });
     if (s) {
       streams.push(s);
       audioEnabled = audioEnabled && s.audio === 1;
     }
   }
-  const extLikeTags = ["extStream", "thirdStream", "externStream", "extraStream"];
+  const extLikeTags = [
+    "extStream",
+    "thirdStream",
+    "externStream",
+    "extraStream"
+  ];
+  let extTagFound;
   for (const tag of extLikeTags) {
-    const extMatch = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    const extMatch = xml.match(
+      new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`)
+    );
     if (!extMatch) continue;
+    extTagFound = tag;
     const extXml = extMatch[1] ?? "";
-    logDebugStreamBlock({ logger, traceNativeStream, channel, tag, blockXml: extXml });
+    logDebugStreamBlock({
+      logger,
+      traceNativeStream,
+      channel,
+      tag,
+      blockXml: extXml
+    });
     const s = buildStream({ profile: "ext", streamXml: extXml });
     if (s) {
       streams.push(s);
@@ -8368,7 +8878,8 @@ var parseChannelStreamMetadataFromGetEncXml = (params) => {
   return {
     channel,
     streams,
-    audioEnabled
+    audioEnabled,
+    rawXml: xml
   };
 };
 
@@ -8975,7 +9486,6 @@ var isNvrHubModel = (model) => {
   return NVR_HUB_MODEL_PATTERNS.some((pattern) => pattern.test(normalized));
 };
 var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
-  client;
   logger;
   httpClient;
   cgiApi;
@@ -8983,6 +9493,39 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   host;
   username;
   password;
+  // ─────────────────────────────────────────────────────────────────────────────
+  // SOCKET POOL - Tag-based socket management
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Socket pool with tag-based allocation strategy.
+   * Tags determine which sockets are shared vs dedicated:
+   *
+   * For standalone camera (channelCount=1):
+   * - "general" - commands, events, ext stream (all share one socket)
+   * - "streaming" - main + sub streams (share one socket)
+   * - "replay:XXX" - dedicated per replay session
+   *
+   * For NVR (channelCount>1):
+   * - "general" - commands, events (shared socket)
+   * - "streaming:chN" - main + sub for channel N (one socket per channel)
+   * - "replay:XXX" - dedicated per replay session
+   */
+  socketPool = /* @__PURE__ */ new Map();
+  /** BaichuanClientOptions to use when creating new sockets */
+  clientOptions;
+  /**
+   * Get the primary "general" socket. This is the default socket for commands and events.
+   * Lazily created on first access if not already initialized.
+   *
+   * This getter maintains backward compatibility with existing code that uses `this.client`.
+   */
+  get client() {
+    const entry = this.socketPool.get("general");
+    if (!entry) {
+      throw new Error("[ReolinkBaichuanApi] General socket not initialized");
+    }
+    return entry.client;
+  }
   /**
    * 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).
@@ -8995,10 +9538,36 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Set during login or when capabilities are queried.
    */
   _channelCount;
-  rebootAfterDisconnectionsPerMinute;
+  /**
+   * Cached NVR/Hub detection result.
+   * - true = NVR/Hub with multiple channels
+   * - false = standalone camera
+   * Set via setIsNvr() from the plugin or auto-detected via isNvrDevice().
+   */
+  _isNvr;
+  /** Maximum dedicated sessions allowed before triggering a reboot (default: 7). */
+  maxDedicatedSessionsBeforeReboot;
+  sessionGuardRebootInFlight;
+  sessionGuardLastRebootAtMs;
+  /** Track last known session count and IDs for change detection. */
+  lastKnownSessionCount;
+  lastKnownSessionIds = /* @__PURE__ */ new Set();
+  /** Reboot if too many voluntary disconnections per minute (default: 15). */
+  rebootAfterDisconnectionsPerMinute = 15;
   disconnectStormVoluntaryAtMs = [];
   disconnectStormRebootInFlight;
   disconnectStormLastRebootAtMs;
+  /**
+   * ECONNRESET storm guard: reboot if too many consecutive ECONNRESET errors.
+   * Default threshold: 10 consecutive ECONNRESET within 60 seconds.
+   */
+  rebootAfterConsecutiveEconnreset = 10;
+  consecutiveEconnresetCount = 0;
+  consecutiveEconnresetFirstAtMs;
+  econnresetStormRebootInFlight;
+  econnresetStormLastRebootAtMs;
+  /** Periodic session check interval (every 60 seconds). */
+  sessionGuardIntervalTimer;
   simpleEventListeners = /* @__PURE__ */ new Set();
   simpleEventSubscribed = false;
   simpleEventSubscribeInFlight;
@@ -9027,29 +9596,68 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   deviceCapabilitiesCache = /* @__PURE__ */ new Map();
   static CAPABILITIES_CACHE_TTL_MS = 5 * 60 * 1e3;
   // 5 minutes
+  // ─────────────────────────────────────────────────────────────────────────────
+  // SOCKET POOL CONSTANTS
+  // ─────────────────────────────────────────────────────────────────────────────
+  /** Keep replay/streaming sockets warm briefly to reduce clip switch latency. */
+  static SOCKET_POOL_KEEPALIVE_MS = 1e4;
   /**
-   * Pool of dedicated BaichuanClient instances for streaming/replay operations.
-   * Each replay/stream operation gets its own dedicated socket to avoid interference
-   * when switching between clips or concurrent operations.
-   *
-   * Key: unique session ID (e.g., "replay:channel:fileName")
-   * Value: client, refCount, createdAt
+   * Cooldown tracking to prevent session spam when login repeatedly fails.
+   * Key: host address (since camera session limits are per-device, not per-sessionKey)
+   * Value: object with failureCount, lastFailureAt, cooldownUntil
    */
-  dedicatedClients = /* @__PURE__ */ new Map();
-  /** Keep replay dedicated sockets warm briefly to reduce clip switch latency. */
-  // Keep replay sockets warm briefly for fast clip switches, but tear down quickly
-  // when clients stop requesting HLS segments (avoids looking like a stuck session).
-  static REPLAY_DEDICATED_KEEPALIVE_MS = 1e4;
+  socketPoolCooldowns = /* @__PURE__ */ new Map();
+  /** Base cooldown duration (ms) for socket failures. */
+  static SOCKET_POOL_BASE_COOLDOWN_MS = 5e3;
+  /** Max cooldown duration (ms) - caps exponential backoff. */
+  static SOCKET_POOL_MAX_COOLDOWN_MS = 12e4;
+  /** Failure count threshold before entering cooldown. */
+  static SOCKET_POOL_FAILURE_THRESHOLD = 2;
+  /** Time window (ms) to reset failure count if no failures occur. */
+  static SOCKET_POOL_FAILURE_WINDOW_MS = 6e4;
   /**
-   * Get a summary of currently active dedicated sessions.
+   * Get a summary of currently active sockets in the pool.
    * Useful for debugging/logging to see how many sockets are open.
    */
+  getSocketPoolSummary() {
+    return {
+      count: this.socketPool.size,
+      tags: Array.from(this.socketPool.keys())
+    };
+  }
+  /**
+   * @deprecated Use getSocketPoolSummary() instead.
+   */
   getDedicatedSessionsSummary() {
+    const summary = this.getSocketPoolSummary();
     return {
-      count: this.dedicatedClients.size,
-      keys: Array.from(this.dedicatedClients.keys())
+      count: summary.count,
+      keys: summary.tags
     };
   }
+  /**
+   * Get cooldown status for socket pool connections.
+   * Useful for debugging when connections are being rate-limited.
+   */
+  getSocketPoolCooldownStatus() {
+    const entry = this.socketPoolCooldowns.get(this.host);
+    if (!entry) return null;
+    const now = Date.now();
+    const inCooldown = now < entry.cooldownUntil;
+    return {
+      host: this.host,
+      inCooldown,
+      failureCount: entry.failureCount,
+      cooldownRemainingMs: inCooldown ? entry.cooldownUntil - now : 0,
+      cooldownUntil: inCooldown ? new Date(entry.cooldownUntil) : null
+    };
+  }
+  /**
+   * @deprecated Use getSocketPoolCooldownStatus() instead.
+   */
+  getDedicatedClientCooldownStatus() {
+    return this.getSocketPoolCooldownStatus();
+  }
   /**
    * Cached per-channel data from cmd_id 145 push (NVR sends this automatically on connection).
    *
@@ -9135,6 +9743,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    */
   replayQueue = [];
   replayQueueProcessing = false;
+  /**
+   * Abort controller for the currently active replay stream.
+   * When a new clip is requested, we signal the current one to stop.
+   */
+  activeReplayAbortController = null;
   /** Minimum delay between replay operations to give camera time to reset */
   REPLAY_COOLDOWN_MS = 500;
   lastReplayEndTime = 0;
@@ -9226,17 +9839,23 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * continues producing data after the initial setup.
    *
    * @param setup - Function that sets up the stream. Called when it's this operation's turn.
-   * @returns Promise that resolves when setup is complete, with the result and a release function.
+   *                 Receives an AbortSignal that will be triggered if a new clip is requested.
+   * @returns Promise that resolves when setup is complete, with the result, release function, and abort signal.
    */
   enqueueStreamingReplayOperation(setup) {
+    if (this.activeReplayAbortController) {
+      this.logger?.debug?.(
+        "[ReplayQueue] Signaling current replay stream to abort for new clip"
+      );
+      this.activeReplayAbortController.abort();
+      this.activeReplayAbortController = null;
+    }
     let resolvePromise;
     let rejectPromise;
-    const promise = new Promise(
-      (resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-      }
-    );
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
     this.replayQueue.push({
       execute: () => {
         return new Promise((releaseSlot) => {
@@ -9244,26 +9863,33 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
           const safeRelease = () => {
             if (released) return;
             released = true;
+            if (this.activeReplayAbortController && this.activeReplayAbortController === abortController) {
+              this.activeReplayAbortController = null;
+            }
             releaseSlot();
           };
+          const abortController = new AbortController();
+          this.activeReplayAbortController = abortController;
           const safetyTimeout = setTimeout(
             () => {
               if (!released) {
                 this.logger?.warn?.(
                   "[ReplayQueue] Safety timeout: releasing queue slot after 10 minutes"
                 );
+                abortController.abort();
                 safeRelease();
               }
             },
             10 * 60 * 1e3
           );
-          setup().then((result) => {
+          setup(abortController.signal).then((result) => {
             resolvePromise({
               result,
               release: () => {
                 clearTimeout(safetyTimeout);
                 safeRelease();
-              }
+              },
+              abortSignal: abortController.signal
             });
           }).catch((e) => {
             clearTimeout(safetyTimeout);
@@ -9326,32 +9952,95 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     });
   }
   recordingsCacheTtlMs = 20 * 60 * 1e3;
+  // ─────────────────────────────────────────────────────────────────────────────
+  // SOCKET POOL MANAGEMENT
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Create or reuse a dedicated BaichuanClient for streaming/replay operations.
-   * Each streaming session gets its own socket to avoid interference when switching clips.
+   * Determine the socket tag for a given sessionKey.
+   * This implements the tag-based allocation strategy:
+   *
+   * - "general" - commands, events
+   * - "streaming:ch{N}" - main + sub for channel N (closed when no streams)
+   * - "streaming:ch{N}:ext" - ext for channel N (closed when no streams)
+   * - "replay:deviceId:ch{N}" - dedicated per device+channel for replay
    *
-   * @param sessionKey - Unique key for this session (e.g., `replay:\$\{deviceId\}`)
-   * @returns The dedicated client and a release function to call when done
+   * Always uses per-channel tagging for streams (works for both standalone and NVR).
+   * Replay uses per-device+channel sockets to allow multiple users to watch
+   * different clips simultaneously without interfering with each other.
    *
-   * IMPORTANT: A socket cannot do concurrent streaming. If a client already exists
-   * for this sessionKey (same device switching clips), we close the old socket
-   * immediately and create a new one. This ensures clean state for each clip.
+   * @param sessionKey - The session key (e.g., "live:device:ch0:main", "replay:device:ch1:file")
+   * @returns The socket pool tag to use
    */
-  async acquireDedicatedClient(sessionKey, logger) {
+  resolveSocketTag(sessionKey) {
+    const replayMatch = sessionKey.match(/^replay:([^:]+)(?::ch(\d+))?/);
+    if (replayMatch) {
+      const deviceId = replayMatch[1];
+      const channel = replayMatch[2] ?? "0";
+      return `replay:${deviceId}:ch${channel}`;
+    }
+    const liveMatch = sessionKey.match(/^live:[^:]+:ch(\d+):(\w+)$/);
+    if (liveMatch && liveMatch[1] && liveMatch[2]) {
+      const channel = parseInt(liveMatch[1], 10);
+      const profile = liveMatch[2].toLowerCase();
+      if (profile === "ext") {
+        if (channel === 0) {
+          return "general";
+        }
+        return `streaming:ch${channel}:ext`;
+      }
+      return `streaming:ch${channel}`;
+    }
+    return "general";
+  }
+  /**
+   * Acquire a socket from the pool by tag.
+   * Creates a new socket if needed, or reuses an existing one.
+   *
+   * @param tag - The socket pool tag (from resolveSocketTag)
+   * @param logger - Optional logger for debug output
+   * @returns The socket and a release function
+   */
+  async acquirePooledSocket(tag, logger) {
     const log = logger ?? this.logger;
-    const isReplayKey = sessionKey.startsWith("replay:");
-    const existing = this.dedicatedClients.get(sessionKey);
+    const now = Date.now();
+    const cooldownEntry = this.socketPoolCooldowns.get(this.host);
+    if (cooldownEntry) {
+      if (now - cooldownEntry.lastFailureAt > _ReolinkBaichuanApi.SOCKET_POOL_FAILURE_WINDOW_MS) {
+        this.socketPoolCooldowns.delete(this.host);
+        log?.debug?.(
+          `[SocketPool] Cooldown reset for host=${this.host} (no failures for ${_ReolinkBaichuanApi.SOCKET_POOL_FAILURE_WINDOW_MS}ms)`
+        );
+      } else if (now < cooldownEntry.cooldownUntil) {
+        const remainingMs = cooldownEntry.cooldownUntil - now;
+        const error = new Error(
+          `[SocketPool] Host ${this.host} is in cooldown for ${Math.ceil(remainingMs / 1e3)}s due to repeated login failures. tag=${tag}`
+        );
+        log?.warn?.(error.message);
+        throw error;
+      }
+    }
+    const existing = this.socketPool.get(tag);
     if (existing) {
       if (existing.idleCloseTimer) {
         clearTimeout(existing.idleCloseTimer);
         existing.idleCloseTimer = void 0;
       }
-      if (existing.refCount === 0) {
-        existing.refCount = 1;
+      if (existing.pendingPromise) {
+        const client2 = await existing.pendingPromise;
+        existing.refCount++;
         existing.lastUsedAt = Date.now();
         log?.debug?.(
-          `[DedicatedClient] Reusing existing dedicated socket for sessionKey=${sessionKey}`
+          `[SocketPool] Waited for pending socket creation for tag=${tag} (refCount=${existing.refCount})`
         );
+        return {
+          client: client2,
+          release: () => this.releasePooledSocket(tag, logger)
+        };
+      }
+      if (existing.refCount === 0) {
+        existing.refCount = 1;
+        existing.lastUsedAt = Date.now();
+        log?.debug?.(`[SocketPool] Reusing idle socket for tag=${tag}`);
         try {
           if (!existing.client.loggedIn) {
             await existing.client.login();
@@ -9361,132 +10050,223 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         if (existing.client.loggedIn) {
           return {
             client: existing.client,
-            release: () => this.releaseDedicatedClient(sessionKey, logger)
+            release: () => this.releasePooledSocket(tag, logger)
+          };
+        }
+      } else {
+        if (tag.startsWith("replay:")) {
+          log?.debug?.(
+            `[SocketPool] Preempting active replay socket for tag=${tag}`
+          );
+        } else {
+          existing.refCount++;
+          existing.lastUsedAt = Date.now();
+          log?.debug?.(
+            `[SocketPool] Reusing active socket for tag=${tag} (refCount=${existing.refCount})`
+          );
+          return {
+            client: existing.client,
+            release: () => this.releasePooledSocket(tag, logger)
           };
         }
       }
-      log?.log?.(
-        `[DedicatedClient] Closing existing socket for sessionKey=${sessionKey} (preempting active session)`
+      log?.debug?.(
+        `[SocketPool] Closing existing socket for tag=${tag} (recreating)`
       );
-      this.dedicatedClients.delete(sessionKey);
+      this.socketPool.delete(tag);
       try {
-        await existing.client.close({ reason: "preempted by new session" });
-        log?.log?.(
-          `[DedicatedClient] Old socket closed successfully for sessionKey=${sessionKey}`
-        );
+        await existing.client.close({
+          reason: "socket pool recreation",
+          skipLogout: true
+        });
       } catch (e) {
         log?.warn?.(
-          `[DedicatedClient] Error closing old socket for sessionKey=${sessionKey}: ${e}`
+          `[SocketPool] Error closing old socket for tag=${tag}: ${e}`
         );
       }
     }
-    log?.log?.(
-      `[DedicatedClient] Opening new dedicated socket for sessionKey=${sessionKey}`
-    );
-    const dedicatedClient = new BaichuanClient({
-      host: this.host,
-      username: this.username,
-      password: this.password,
-      logger: log,
-      debugOptions: this.client.getDebugConfig?.()
-    });
-    await dedicatedClient.login();
-    log?.log?.(
-      `[DedicatedClient] Dedicated socket logged in for sessionKey=${sessionKey}`
-    );
-    this.dedicatedClients.set(sessionKey, {
-      client: dedicatedClient,
-      refCount: 1,
-      createdAt: Date.now(),
-      lastUsedAt: Date.now(),
+    log?.log?.(`[SocketPool] Creating new socket for tag=${tag}`);
+    const entry = {
+      client: void 0,
+      // Will be set after login
+      refCount: 0,
+      createdAt: now,
+      lastUsedAt: now,
       idleCloseTimer: void 0
-    });
+    };
+    entry.pendingPromise = (async () => {
+      try {
+        const clientOpts = log ? { ...this.clientOptions, logger: log } : this.clientOptions;
+        const newClient = new BaichuanClient(clientOpts);
+        await newClient.login();
+        if (this.socketPoolCooldowns.has(this.host)) {
+          log?.debug?.(
+            `[SocketPool] Clearing cooldown for host=${this.host} after successful login`
+          );
+          this.socketPoolCooldowns.delete(this.host);
+        }
+        entry.client = newClient;
+        entry.refCount = 1;
+        entry.lastUsedAt = Date.now();
+        delete entry.pendingPromise;
+        log?.log?.(`[SocketPool] Socket connected for tag=${tag}`);
+        void this.maybeRebootOnTooManySessions();
+        return newClient;
+      } catch (loginError) {
+        const prevCooldown = this.socketPoolCooldowns.get(this.host);
+        const failureCount = (prevCooldown?.failureCount ?? 0) + 1;
+        const now2 = Date.now();
+        let cooldownUntil = now2;
+        if (failureCount >= _ReolinkBaichuanApi.SOCKET_POOL_FAILURE_THRESHOLD) {
+          const backoffMs = Math.min(
+            _ReolinkBaichuanApi.SOCKET_POOL_BASE_COOLDOWN_MS * Math.pow(
+              2,
+              failureCount - _ReolinkBaichuanApi.SOCKET_POOL_FAILURE_THRESHOLD
+            ),
+            _ReolinkBaichuanApi.SOCKET_POOL_MAX_COOLDOWN_MS
+          );
+          cooldownUntil = now2 + backoffMs;
+          log?.warn?.(
+            `[SocketPool] Login failed for host=${this.host} (failure #${failureCount}). Entering cooldown for ${Math.ceil(backoffMs / 1e3)}s. tag=${tag}`
+          );
+        } else {
+          log?.warn?.(
+            `[SocketPool] Login failed for host=${this.host} (failure #${failureCount}/${_ReolinkBaichuanApi.SOCKET_POOL_FAILURE_THRESHOLD} before cooldown). tag=${tag}`
+          );
+        }
+        this.socketPoolCooldowns.set(this.host, {
+          failureCount,
+          lastFailureAt: now2,
+          cooldownUntil
+        });
+        this.socketPool.delete(tag);
+        throw loginError;
+      }
+    })();
+    this.socketPool.set(tag, entry);
+    const client = await entry.pendingPromise;
     return {
-      client: dedicatedClient,
-      release: () => this.releaseDedicatedClient(sessionKey, logger)
+      client,
+      release: () => this.releasePooledSocket(tag, logger)
     };
   }
   /**
-   * Release a dedicated client. Always closes the socket immediately.
-   * This ensures clean teardown at the end of each clip.
+   * Release a socket back to the pool.
+   * For shared sockets (general, streaming), just decrements refCount.
+   * For replay sockets, schedules idle close.
    */
-  async releaseDedicatedClient(sessionKey, logger) {
+  async releasePooledSocket(tag, logger) {
     const log = logger ?? this.logger;
-    const entry = this.dedicatedClients.get(sessionKey);
+    const entry = this.socketPool.get(tag);
     if (!entry) return;
     entry.refCount = Math.max(0, entry.refCount - 1);
     entry.lastUsedAt = Date.now();
+    log?.debug?.(
+      `[SocketPool] Released socket for tag=${tag} (refCount=${entry.refCount})`
+    );
     if (entry.refCount > 0) return;
-    const isReplayKey = sessionKey.startsWith("replay:");
-    const allowReplayKeepAlive = /^replay:[^:]+$/.test(sessionKey);
-    if (isReplayKey && allowReplayKeepAlive) {
+    const isReplayTag = tag.startsWith("replay:");
+    const isStreamingTag = tag.startsWith("streaming:");
+    const isGeneralTag = tag === "general";
+    if (isGeneralTag) {
+      return;
+    }
+    if (isStreamingTag) {
+      if (entry.idleCloseTimer) return;
+      entry.idleCloseTimer = setTimeout(async () => {
+        const current = this.socketPool.get(tag);
+        if (!current) return;
+        if (current.refCount > 0) return;
+        this.socketPool.delete(tag);
+        log?.log?.(`[SocketPool] Closing idle streaming socket for tag=${tag}`);
+        try {
+          await current.client.close({
+            reason: "streaming idle close",
+            skipLogout: true
+          });
+        } catch {
+        }
+      }, 5e3);
+      return;
+    }
+    if (isReplayTag) {
       if (entry.idleCloseTimer) return;
       entry.idleCloseTimer = setTimeout(async () => {
-        const current = this.dedicatedClients.get(sessionKey);
+        const current = this.socketPool.get(tag);
         if (!current) return;
         if (current.refCount > 0) return;
-        this.dedicatedClients.delete(sessionKey);
+        this.socketPool.delete(tag);
         log?.debug?.(
-          `[DedicatedClient] Closing idle replay socket for sessionKey=${sessionKey} (keepalive expired)`
+          `[SocketPool] Closing idle replay socket for tag=${tag} (keepalive expired)`
         );
         try {
           await current.client.close({
-            reason: "replay idle keepalive expired"
+            reason: "replay idle keepalive expired",
+            skipLogout: true
           });
         } catch {
         }
-      }, _ReolinkBaichuanApi.REPLAY_DEDICATED_KEEPALIVE_MS);
+      }, _ReolinkBaichuanApi.SOCKET_POOL_KEEPALIVE_MS);
       return;
     }
-    this.dedicatedClients.delete(sessionKey);
-    log?.log?.(
-      `[DedicatedClient] Closing socket for sessionKey=${sessionKey} (session ended)`
-    );
+    this.socketPool.delete(tag);
     try {
-      await entry.client.close({ reason: "dedicated session ended" });
-      log?.log?.(
-        `[DedicatedClient] Socket closed successfully for sessionKey=${sessionKey}`
-      );
+      await entry.client.close({
+        reason: "socket pool release",
+        skipLogout: true
+      });
+      log?.log?.(`[SocketPool] Closed socket for tag=${tag}`);
     } catch (e) {
-      log?.warn?.(
-        `[DedicatedClient] Error closing socket for sessionKey=${sessionKey}: ${e}`
-      );
+      log?.warn?.(`[SocketPool] Error closing socket for tag=${tag}: ${e}`);
     }
   }
   /**
-   * Force-close a dedicated client if it exists.
-   * This is called BEFORE entering the queue to immediately terminate any existing stream
-   * for the same sessionKey. The existing stream will receive an error, release its queue slot,
-   * and the new request can then proceed.
-   *
-   * @param sessionKey - The session key to force-close (e.g., `replay:${deviceId}`)
-   * @param logger - Optional logger
-   * @returns true if a client was closed, false if no client existed
+   * Force-close a socket by tag.
+   * Used to preempt existing connections before acquiring a new one.
    */
-  async forceCloseDedicatedClient(sessionKey, logger) {
+  async forceClosePooledSocket(tag, logger) {
     const log = logger ?? this.logger;
-    const entry = this.dedicatedClients.get(sessionKey);
+    const entry = this.socketPool.get(tag);
     if (!entry) return false;
     if (entry.idleCloseTimer) {
       clearTimeout(entry.idleCloseTimer);
       entry.idleCloseTimer = void 0;
     }
-    log?.log?.(
-      `[DedicatedClient] Force-closing existing socket for sessionKey=${sessionKey} (new request preempting)`
-    );
-    this.dedicatedClients.delete(sessionKey);
+    log?.debug?.(`[SocketPool] Force-closing socket for tag=${tag}`);
+    this.socketPool.delete(tag);
     try {
-      await entry.client.close({ reason: "preempted by new request" });
-      log?.log?.(
-        `[DedicatedClient] Force-close complete for sessionKey=${sessionKey}`
-      );
+      await entry.client.close({
+        reason: "force closed",
+        skipLogout: true
+      });
+      log?.log?.(`[SocketPool] Force-closed socket for tag=${tag}`);
     } catch (e) {
-      log?.warn?.(
-        `[DedicatedClient] Error during force-close for sessionKey=${sessionKey}: ${e}`
-      );
+      log?.warn?.(`[SocketPool] Error during force-close for tag=${tag}: ${e}`);
     }
     return true;
   }
+  /**
+   * Cleanup all sockets in the pool. Called during API close.
+   */
+  async cleanupSocketPool() {
+    const entries = Array.from(this.socketPool.entries());
+    this.socketPool.clear();
+    await Promise.allSettled(
+      entries.map(async ([tag, entry]) => {
+        try {
+          if (entry.idleCloseTimer) {
+            clearTimeout(entry.idleCloseTimer);
+          }
+          this.logger?.debug?.(`[SocketPool] Cleanup: closing tag=${tag}`);
+          await entry.client.close({ reason: "API cleanup", skipLogout: true });
+        } catch {
+        }
+      })
+    );
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // PUBLIC SESSION API (backward compatible)
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
    * Create a dedicated Baichuan client session for streaming.
    * This is useful for consumers that need isolated socket connections per stream.
@@ -9495,10 +10275,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * @param logger - Optional logger for debug output
    * @returns Object with `client` (the dedicated BaichuanClient) and `release` function to call when done
    *
-   * The dedicated client is automatically cleaned up when:
-   * 1. `release()` is called explicitly
-   * 2. A new session is created with the same sessionKey (old one is closed first)
-   * 3. The API is closed via `close()`
+   * Session keys are automatically mapped to socket pool tags:
+   * - `live:device:ch0:ext` → "general" socket (shared with commands/events)
+   * - `live:device:ch0:main` → "streaming" socket (standalone) or "streaming:ch0" (NVR)
+   * - `live:device:ch0:sub` → "streaming" socket (standalone) or "streaming:ch0" (NVR)
+   * - `replay:device:...` → dedicated per-replay socket
    *
    * @example
    * ```typescript
@@ -9511,26 +10292,25 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * ```
    */
   async createDedicatedSession(sessionKey, logger) {
-    return await this.acquireDedicatedClient(sessionKey, logger);
+    const tag = this.resolveSocketTag(sessionKey);
+    const log = logger ?? this.logger;
+    log?.debug?.(
+      `[SocketPool] createDedicatedSession sessionKey=${sessionKey} \u2192 tag=${tag}`
+    );
+    return await this.acquirePooledSocket(tag, logger);
+  }
+  /**
+   * @deprecated Use forceClosePooledSocket via createDedicatedSession instead.
+   * Force-close a dedicated client if it exists.
+   */
+  async forceCloseDedicatedClient(sessionKey, logger) {
+    const tag = this.resolveSocketTag(sessionKey);
+    return await this.forceClosePooledSocket(tag, logger);
   }
   /**
-   * Cleanup all dedicated clients. Called during API close.
+   * @deprecated Cleanup handled by cleanupSocketPool now.
    */
   async cleanupDedicatedClients() {
-    const entries = Array.from(this.dedicatedClients.entries());
-    this.dedicatedClients.clear();
-    await Promise.allSettled(
-      entries.map(async ([key, entry]) => {
-        try {
-          if (entry.idleCloseTimer) {
-            clearTimeout(entry.idleCloseTimer);
-          }
-          this.logger?.debug?.(`[DedicatedClient] Cleanup: closing ${key}`);
-          await entry.client.close({ reason: "API cleanup" });
-        } catch {
-        }
-      })
-    );
   }
   dispatchSimpleEvent(evt) {
     const debugCfg = this.client.getDebugConfig?.();
@@ -9568,7 +10348,23 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       opts.logger,
       dbg.general || dbg.traceNativeStream || dbg.traceRecordings || dbg.traceTalk || dbg.traceEvents || dbg.debugRtsp
     );
-    this.client = new BaichuanClient(opts);
+    this.clientOptions = {
+      host: opts.host,
+      username: opts.username,
+      password: opts.password,
+      ...opts.logger ? { logger: opts.logger } : {},
+      ...opts.debugOptions ? { debugOptions: opts.debugOptions } : {},
+      ...opts.uid ? { uid: opts.uid } : {}
+    };
+    const generalClient = new BaichuanClient(opts);
+    this.socketPool.set("general", {
+      client: generalClient,
+      refCount: 1,
+      // Always keep general socket "in use"
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      idleCloseTimer: void 0
+    });
     this.host = opts.host;
     this.username = opts.username;
     this.password = opts.password;
@@ -9585,7 +10381,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       username: opts.username,
       password: opts.password,
       logger: this.logger,
-      debugConfig: this.client.getDebugConfig?.()
+      debugConfig: generalClient.getDebugConfig?.()
     });
     this.client.on("event", (event) => {
       const mapped = mapToSimpleEvent(event);
@@ -9623,9 +10419,15 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         );
       }
     });
-    const v = opts.rebootAfterDisconnectionsPerMinute;
-    if (typeof v === "number" && Number.isFinite(v) && v > 0) {
-      this.rebootAfterDisconnectionsPerMinute = Math.floor(v);
+    const maxSessions = opts.maxDedicatedSessionsBeforeReboot;
+    if (typeof maxSessions === "number" && Number.isFinite(maxSessions) && maxSessions > 0) {
+      this.maxDedicatedSessionsBeforeReboot = Math.floor(maxSessions);
+    }
+    const disconnectThreshold = opts.rebootAfterDisconnectionsPerMinute;
+    if (typeof disconnectThreshold === "number" && Number.isFinite(disconnectThreshold)) {
+      this.rebootAfterDisconnectionsPerMinute = Math.floor(disconnectThreshold);
+    }
+    if (this.rebootAfterDisconnectionsPerMinute > 0) {
       this.client.on("close", () => {
         try {
           void this.maybeRebootOnDisconnectStorm();
@@ -9633,6 +10435,24 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         }
       });
     }
+    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);
+    });
   }
   /**
    * CGI forward: fetch RTSP URL for a channel via `GetRtspUrl`.
@@ -9720,24 +10540,228 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     });
   }
   /**
-   * Multifocal/NVR empirical stream diagnostics:
-   * probes RTSP/RTMP candidates + native streams, prints discovered resolutions,
-   * and saves one clip per working stream into a timestamped folder under outDir.
+   * Multifocal/NVR empirical stream diagnostics:
+   * probes RTSP/RTMP candidates + native streams, prints discovered resolutions,
+   * and saves one clip per working stream into a timestamped folder under outDir.
+   */
+  async runMultifocalDiagnosticsConsecutively(params) {
+    return await runMultifocalDiagnosticsConsecutively({
+      ...params,
+      api: this,
+      logger: params.logger ?? this.logger,
+      host: this.host,
+      username: this.username,
+      password: this.password
+    });
+  }
+  /**
+   * Log active sessions on the device at startup for debugging purposes.
+   */
+  async logActiveSessionsOnStartup() {
+    const localSessionCount = this.socketPool.size;
+    try {
+      const ourIp = this.client.getLocalAddress?.();
+      const onlineUsers = await this.getOnlineUserList({ timeoutMs: 5e3 });
+      const rawLegacy = onlineUsers.body?.OnlineUserList?.item;
+      const rawCurrent = onlineUsers.body?.OnlineUserList?.OnlineUser;
+      const legacyItems = Array.isArray(rawLegacy) ? rawLegacy : rawLegacy ? [rawLegacy] : [];
+      const currentItems = Array.isArray(rawCurrent) ? rawCurrent : rawCurrent ? [rawCurrent] : [];
+      const allItems = currentItems.length > 0 ? currentItems.map((u) => ({
+        ip: u.ipAddress,
+        userName: u.userName,
+        level: u.userLevel,
+        sessionId: u.sessionId
+      })) : legacyItems.map((u) => ({
+        ip: u.ip,
+        userName: u.userName,
+        level: u.level,
+        sessionId: void 0
+      }));
+      const ourSessions = ourIp ? allItems.filter((item) => item.ip === ourIp) : allItems;
+      const deviceReportsZero = allItems.length === 0 && localSessionCount > 0;
+      this.logger.log?.(
+        `[ReolinkBaichuanApi] Startup session check: ${ourSessions.length} device session(s) from our IP (${ourIp ?? "unknown"}), ${allItems.length} total on device, ${localSessionCount} local${deviceReportsZero ? " [device may not support OnlineUserList]" : ""}`,
+        {
+          host: this.host,
+          ourIp,
+          localSessionCount,
+          deviceReportsZero,
+          ourSessions: ourSessions.map((s) => ({
+            user: s.userName,
+            ip: s.ip,
+            sessionId: s.sessionId
+          })),
+          allSessions: allItems.map((s) => ({
+            user: s.userName,
+            ip: s.ip,
+            sessionId: s.sessionId
+          }))
+        }
+      );
+    } catch (e) {
+      this.logger.debug?.(
+        "[ReolinkBaichuanApi] Could not query sessions at startup",
+        e
+      );
+    }
+  }
+  /**
+   * Check if too many sessions are open on the device and trigger a reboot if needed.
+   * Called when acquiring a new dedicated client.
+   * Uses the native Baichuan API to get the actual session count from the device.
+   * Only counts sessions from our own IP address.
+   */
+  async maybeRebootOnTooManySessions() {
+    const threshold = this.maxDedicatedSessionsBeforeReboot ?? 10;
+    if (this.sessionGuardRebootInFlight) return;
+    const cooldownMs = 10 * 6e4;
+    const now = Date.now();
+    if (this.sessionGuardLastRebootAtMs != null && now - this.sessionGuardLastRebootAtMs < cooldownMs) {
+      return;
+    }
+    const ourIp = this.client.getLocalAddress?.();
+    const ourDedicatedSessions = this.socketPool.size;
+    let sessionCount;
+    let sessionItems = [];
+    let ourSessionCount = 0;
+    let usedLocalFallback = false;
+    try {
+      const onlineUsers = await this.getOnlineUserList({ timeoutMs: 5e3 });
+      const rawLegacy = onlineUsers.body?.OnlineUserList?.item;
+      const rawCurrent = onlineUsers.body?.OnlineUserList?.OnlineUser;
+      const legacyItems = Array.isArray(rawLegacy) ? rawLegacy : rawLegacy ? [rawLegacy] : [];
+      const currentItems = Array.isArray(rawCurrent) ? rawCurrent : rawCurrent ? [rawCurrent] : [];
+      const allItems = currentItems.length > 0 ? currentItems.map((u) => ({
+        ip: u.ipAddress,
+        name: u.userName,
+        level: u.userLevel,
+        sessionId: u.sessionId
+      })) : legacyItems.map((u) => ({
+        ip: u.ip,
+        name: u.userName,
+        level: u.level,
+        sessionId: u.sessionId
+      }));
+      sessionItems = allItems;
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] Session guard: camera reports ${allItems.length} sessions, ourIp=${ourIp ?? "unknown"}`,
+        {
+          ourIp,
+          sessions: allItems
+        }
+      );
+      if (ourIp) {
+        const ourSessions = allItems.filter((item) => item.ip === ourIp);
+        ourSessionCount = ourSessions.length;
+        sessionCount = ourSessionCount;
+        const currentSessionIds = new Set(
+          ourSessions.map((s) => s.sessionId).filter((id) => id != null)
+        );
+        if (this.lastKnownSessionCount !== void 0) {
+          const newIds = [...currentSessionIds].filter(
+            (id) => !this.lastKnownSessionIds.has(id)
+          );
+          const removedIds = [...this.lastKnownSessionIds].filter(
+            (id) => !currentSessionIds.has(id)
+          );
+          if (newIds.length > 0 || removedIds.length > 0) {
+            this.logger.log?.(
+              `[ReolinkBaichuanApi] Session change detected: ${this.lastKnownSessionCount} -> ${ourSessionCount} sessions`,
+              {
+                newSessionIds: newIds,
+                removedSessionIds: removedIds,
+                currentSessions: ourSessions.map((s) => ({
+                  id: s.sessionId,
+                  ip: s.ip
+                })),
+                localDedicatedSessions: Array.from(this.socketPool.keys())
+              }
+            );
+          }
+        }
+        this.lastKnownSessionCount = ourSessionCount;
+        this.lastKnownSessionIds = currentSessionIds;
+        if (allItems.length > 0) {
+          this.logger.debug?.(
+            `[ReolinkBaichuanApi] Session guard: ${ourSessionCount}/${allItems.length} sessions match ourIp=${ourIp}`
+          );
+        }
+      } else {
+        sessionCount = onlineUsers.body?.OnlineUserList?.itemNum ?? 0;
+        ourSessionCount = sessionCount;
+      }
+      if (sessionCount === 0 && ourDedicatedSessions > 0) {
+        sessionCount = ourDedicatedSessions;
+        ourSessionCount = ourDedicatedSessions;
+        usedLocalFallback = true;
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] Session guard: camera reports 0 sessions but we have ${ourDedicatedSessions} local dedicated sessions, using local fallback`
+        );
+      }
+    } catch (e) {
+      this.logger.debug?.(
+        "[ReolinkBaichuanApi] Session guard: failed to query online users, using local count",
+        e
+      );
+      sessionCount = this.socketPool.size;
+      ourSessionCount = sessionCount;
+      usedLocalFallback = true;
+    }
+    if (sessionCount < threshold) return;
+    this.sessionGuardLastRebootAtMs = now;
+    const localSessions = Array.from(this.socketPool.keys());
+    const thresholdIsDefault = this.maxDedicatedSessionsBeforeReboot == null;
+    (this.logger.warn ?? this.logger.log).call(
+      this.logger,
+      `[ReolinkBaichuanApi] Too many sessions from our IP (${ourIp ?? "unknown"}) on device host=${this.host} (${sessionCount} >= ${threshold}${thresholdIsDefault ? " [default]" : ""}${usedLocalFallback ? " [local fallback]" : ""}); rebooting device`,
+      {
+        host: this.host,
+        ourIp,
+        ourSessionCount,
+        threshold,
+        usedLocalFallback,
+        thresholdFormula: thresholdIsDefault ? "default (10)" : "explicit",
+        localDedicatedSessions: localSessions,
+        allDeviceSessions: sessionItems
+      }
+    );
+    this.sessionGuardRebootInFlight = this.rebootFromSessionGuard().catch((e) => {
+      (this.logger.warn ?? this.logger.error).call(
+        this.logger,
+        "[ReolinkBaichuanApi] Session guard reboot failed",
+        e
+      );
+    }).finally(() => {
+      this.sessionGuardRebootInFlight = void 0;
+    });
+  }
+  async rebootFromSessionGuard() {
+    try {
+      await this.reboot();
+      return;
+    } catch (e) {
+      this.logger.debug?.(
+        "[ReolinkBaichuanApi] Baichuan reboot failed, trying CGI",
+        e
+      );
+    }
+    try {
+      await this.cgiApi.login();
+      await this.cgiApi.Reboot();
+    } catch (e) {
+      throw e instanceof Error ? e : new Error(String(e ?? "session guard reboot failed"));
+    }
+  }
+  /**
+   * Check if there are too many voluntary disconnections and trigger a reboot if needed.
+   * Called on every socket close event.
    */
-  async runMultifocalDiagnosticsConsecutively(params) {
-    return await runMultifocalDiagnosticsConsecutively({
-      ...params,
-      api: this,
-      logger: params.logger ?? this.logger,
-      host: this.host,
-      username: this.username,
-      password: this.password
-    });
-  }
   async maybeRebootOnDisconnectStorm() {
     const threshold = this.rebootAfterDisconnectionsPerMinute;
-    if (threshold == null) return;
-    const info = this.client.getLastDisconnectInfo?.();
+    if (threshold <= 0) return;
+    const entry = this.socketPool.get("general");
+    if (!entry) return;
+    const info = entry.client.getLastDisconnectInfo?.();
     if (!info?.voluntary) return;
     const now = Date.now();
     const windowMs = 6e4;
@@ -9749,54 +10773,90 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     if (this.disconnectStormVoluntaryAtMs.length < threshold) return;
     if (this.disconnectStormRebootInFlight) return;
     const cooldownMs = 10 * 6e4;
-    if (this.disconnectStormLastRebootAtMs != null && now - this.disconnectStormLastRebootAtMs < cooldownMs)
+    if (this.disconnectStormLastRebootAtMs != null && now - this.disconnectStormLastRebootAtMs < cooldownMs) {
       return;
+    }
     this.disconnectStormLastRebootAtMs = now;
-    (this.logger.warn ?? this.logger.error).call(
+    (this.logger.warn ?? this.logger.log).call(
       this.logger,
-      "[ReolinkBaichuanApi] disconnect storm detected; rebooting device",
+      `[ReolinkBaichuanApi] Disconnect storm detected for host=${this.host} (${this.disconnectStormVoluntaryAtMs.length} voluntary disconnects in 60s >= ${threshold}); rebooting device`,
       {
+        host: this.host,
         transport: info.transport,
         reason: info.reason,
         voluntaryDisconnectsInWindow: this.disconnectStormVoluntaryAtMs.length,
-        windowMs,
         threshold,
-        cooldownMs,
-        method: "auto"
+        windowMs,
+        cooldownMs
       }
     );
-    this.disconnectStormRebootInFlight = this.rebootFromDisconnectStorm("auto").catch((e) => {
+    this.disconnectStormRebootInFlight = this.rebootFromSessionGuard().catch((e) => {
       (this.logger.warn ?? this.logger.error).call(
         this.logger,
-        "[ReolinkBaichuanApi] disconnect-storm reboot failed",
+        "[ReolinkBaichuanApi] Disconnect storm reboot failed",
         e
       );
     }).finally(() => {
       this.disconnectStormRebootInFlight = void 0;
     });
   }
-  async rebootFromDisconnectStorm(method) {
-    let lastErr;
-    if (method === "auto" || method === "baichuan") {
-      try {
-        await this.reboot();
-        return;
-      } catch (e) {
-        lastErr = e;
-        if (method === "baichuan") throw e;
-      }
+  /**
+   * Check if there are too many consecutive ECONNRESET errors and trigger a reboot if needed.
+   * This guards against camera saturation where the device refuses all new connections.
+   * Called on every socket close event.
+   */
+  async maybeRebootOnEconnresetStorm() {
+    const threshold = this.rebootAfterConsecutiveEconnreset;
+    if (threshold <= 0) return;
+    const entry = this.socketPool.get("general");
+    if (!entry) return;
+    const info = entry.client.getLastDisconnectInfo?.();
+    const isEconnreset = info?.errorCode === "ECONNRESET";
+    if (!isEconnreset) {
+      this.consecutiveEconnresetCount = 0;
+      this.consecutiveEconnresetFirstAtMs = void 0;
+      return;
     }
-    if (method === "auto" || method === "cgi") {
-      try {
-        await this.cgiApi.login();
-        await this.cgiApi.Reboot();
-        return;
-      } catch (e) {
-        lastErr = e;
-        if (method === "cgi") throw e;
-      }
+    const now = Date.now();
+    const windowMs = 6e4;
+    if (this.consecutiveEconnresetFirstAtMs == null) {
+      this.consecutiveEconnresetFirstAtMs = now;
     }
-    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr ?? "disconnect-storm reboot failed"));
+    if (now - this.consecutiveEconnresetFirstAtMs > windowMs) {
+      this.consecutiveEconnresetCount = 1;
+      this.consecutiveEconnresetFirstAtMs = now;
+    } else {
+      this.consecutiveEconnresetCount++;
+    }
+    if (this.consecutiveEconnresetCount < threshold) return;
+    if (this.econnresetStormRebootInFlight) return;
+    const cooldownMs = 10 * 6e4;
+    if (this.econnresetStormLastRebootAtMs != null && now - this.econnresetStormLastRebootAtMs < cooldownMs) {
+      return;
+    }
+    this.econnresetStormLastRebootAtMs = now;
+    (this.logger.warn ?? this.logger.log).call(
+      this.logger,
+      `[ReolinkBaichuanApi] ECONNRESET storm detected for host=${this.host} (${this.consecutiveEconnresetCount} consecutive ECONNRESET in 60s >= ${threshold}); rebooting device`,
+      {
+        host: this.host,
+        consecutiveEconnreset: this.consecutiveEconnresetCount,
+        threshold,
+        windowMs,
+        cooldownMs
+      }
+    );
+    this.consecutiveEconnresetCount = 0;
+    this.consecutiveEconnresetFirstAtMs = void 0;
+    this.econnresetStormRebootInFlight = this.rebootFromSessionGuard().catch((e) => {
+      (this.logger.warn ?? this.logger.error).call(
+        this.logger,
+        "[ReolinkBaichuanApi] ECONNRESET storm reboot failed",
+        e
+      );
+    }).finally(() => {
+      this.econnresetStormRebootInFlight = void 0;
+    });
   }
   /**
    * Subscribe to minimal high-level events.
@@ -9941,12 +11001,19 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   /**
    * Determines if this device is an NVR/Hub (multiple channels) vs a standalone camera.
    * Checks:
-   * 1. Channel count > 1 (typical NVR detection)
-   * 2. Device model matches NVR/Hub patterns (for devices like Home Hub that report channelNum=1)
+   * 1. Cached value from setIsNvr()
+   * 2. Channel count > 3 (typical NVR detection)
+   * 3. Device model matches NVR/Hub patterns (for devices like Home Hub that report channelNum=1)
    */
   async isNvrDevice() {
+    if (this._isNvr !== void 0) {
+      return this._isNvr;
+    }
     const channelCount = await this.getChannelCount();
-    if (channelCount > 3) return true;
+    if (channelCount > 3) {
+      this._isNvr = true;
+      return true;
+    }
     try {
       const info = await this.getInfo(void 0, {
         tags: ["type"],
@@ -9956,23 +11023,76 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         this.logger.debug?.(
           `[ReolinkBaichuanApi] isNvrDevice: type="${info.type}" matches NVR/Hub pattern`
         );
+        this._isNvr = true;
         return true;
       }
     } catch {
     }
+    this._isNvr = false;
     return false;
   }
+  /**
+   * Set the NVR/Hub flag explicitly.
+   * Call this early (before streaming) to ensure correct socket pooling.
+   * @param isNvr - true if this is an NVR/Hub, false for standalone camera
+   */
+  setIsNvr(isNvr) {
+    this._isNvr = isNvr;
+    this.logger.debug?.(`[ReolinkBaichuanApi] setIsNvr: ${isNvr}`);
+  }
+  /**
+   * Enable or disable idle disconnect dynamically.
+   *
+   * This is useful when the battery status is discovered after connection
+   * (e.g., during autodetect). Call with `true` for battery cameras to
+   * preserve battery life by disconnecting when idle.
+   *
+   * @param enabled - true to enable idle disconnect, false to disable
+   */
+  setIdleDisconnect(enabled) {
+    this.client.setIdleDisconnect(enabled);
+    this.logger.debug?.(`[ReolinkBaichuanApi] setIdleDisconnect: ${enabled}`);
+  }
   async login(maxEncryption) {
     await this.client.login(maxEncryption);
   }
+  /**
+   * Stop all active video streams on the main API client.
+   * Called automatically during close() to ensure clean session termination.
+   */
+  async stopAllActiveStreams() {
+    const activeStreams = Array.from(this.activeVideoMsgNums.keys());
+    if (activeStreams.length === 0) {
+      return;
+    }
+    this.logger?.debug?.(
+      `[ReolinkBaichuanApi] Stopping ${activeStreams.length} active stream(s) before close`
+    );
+    await Promise.allSettled(
+      activeStreams.map(async (key) => {
+        const [ch, profile, variant] = key.split(":");
+        try {
+          await this.stopVideoStream(Number(ch), profile, {
+            variant
+          });
+        } catch (e) {
+          this.logger?.debug?.(
+            `[ReolinkBaichuanApi] Error stopping stream ${key}: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+      })
+    );
+  }
   async close(options) {
+    if (this.sessionGuardIntervalTimer) {
+      clearInterval(this.sessionGuardIntervalTimer);
+      this.sessionGuardIntervalTimer = void 0;
+    }
     this.stopStatePolling();
     this.stopUdpSleepInference();
     await this.cleanup();
-    await this.cleanupDedicatedClients();
-    await this.client.close(
-      options?.reason ? { reason: options.reason } : void 0
-    );
+    await this.stopAllActiveStreams();
+    await this.cleanupSocketPool();
   }
   /**
    * Cleanup all RTSP servers and release resources.
@@ -10175,10 +11295,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     logger?.info?.(
       `[DedicatedTalk] Creating session: ${sessionKey} (idleTimeout=${idleTimeoutMs}ms)`
     );
-    const { client: dedicatedClient, release } = await this.acquireDedicatedClient(sessionKey, logger);
-    const summary = this.getDedicatedSessionsSummary();
+    const tag = this.resolveSocketTag(sessionKey);
+    const { client: dedicatedClient, release } = await this.acquirePooledSocket(
+      tag,
+      logger
+    );
+    const summary = this.getSocketPoolSummary();
     logger?.info?.(
-      `[DedicatedTalk] Session created [sessions: ${summary.count} active${summary.count > 0 ? ` (${summary.keys.join(", ")})` : ""}]`
+      `[DedicatedTalk] Session created [sessions: ${summary.count} active${summary.count > 0 ? ` (${summary.tags.join(", ")})` : ""}]`
     );
     try {
       const isUdp = dedicatedClient.getTransport?.() === "udp";
@@ -11301,8 +12425,12 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const channel = params.channel;
     const streamType = params.streamType;
     const logger = params.logger ?? this.logger;
-    const sessionKey = params.deviceId ? `replay:${params.deviceId}` : `replay:standalone:${channel}:${Date.now()}`;
-    const { client: dedicatedClient, release: releaseDedicatedClient } = await this.acquireDedicatedClient(sessionKey, logger);
+    const sessionKey = params.deviceId ? `replay:${params.deviceId}:ch${channel}` : `replay:standalone:ch${channel}:${Date.now()}`;
+    const tag = this.resolveSocketTag(sessionKey);
+    logger?.debug?.(
+      `[startRecordingReplayStreamStandalone] sessionKey=${sessionKey} -> tag=${tag}`
+    );
+    const { client: dedicatedClient, release: releaseDedicatedClient } = await this.acquirePooledSocket(tag, logger);
     const uid = await this.ensureUidForRecordings(channel, void 0);
     const payloadXml = buildFileInfoListReplayByNameXml({
       channel,
@@ -11430,8 +12558,9 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const channel = params.channel;
     const streamType = params.streamType;
     const logger = params.logger ?? this.logger;
-    const sessionKey = params.deviceId ? `replay:${params.deviceId}` : `replay:nvr:${channel}:${Date.now()}`;
-    const { client: dedicatedClient, release: releaseDedicatedClient } = await this.acquireDedicatedClient(sessionKey, logger);
+    const sessionKey = params.deviceId ? `replay:${params.deviceId}:ch${channel}` : `replay:nvr:ch${channel}:${Date.now()}`;
+    const tag = this.resolveSocketTag(sessionKey);
+    const { client: dedicatedClient, release: releaseDedicatedClient } = await this.acquirePooledSocket(tag, logger);
     let uid;
     try {
       uid = await this.ensureUidForRecordings(channel, void 0);
@@ -13175,6 +14304,9 @@ ${stderr}`)
    * After subscribing, events will be emitted via client.on("event", ...)
    */
   async subscribeEvents() {
+    this.logger.debug?.(
+      "[ReolinkBaichuanApi] subscribeEvents() called - checking session count before"
+    );
     await this.client.login();
     const channel = this.client.getConfiguredChannel?.() ?? 0;
     const attempts = [
@@ -15448,7 +16580,8 @@ ${xml}`
       const result2 = {
         nativeStreams,
         rtmpStreams,
-        rtspStreams
+        rtspStreams,
+        rawEncXml: void 0
       };
       return cacheOrFallback(result2);
     }
@@ -15536,7 +16669,8 @@ ${xml}`
       return {
         nativeStreams,
         rtmpStreams,
-        rtspStreams
+        rtspStreams,
+        rawEncXml: widerMetadata?.rawXml
       };
     }
     const guessRtspEncodingPrefix = (m) => {
@@ -15798,7 +16932,8 @@ ${xml}`
     const result = {
       nativeStreams,
       rtmpStreams,
-      rtspStreams
+      rtspStreams,
+      rawEncXml: streamMetadata?.rawXml
     };
     return cacheOrFallback(result);
   }
@@ -15811,7 +16946,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-EC7DADEQ.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-6WEMO4L4.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -15827,7 +16962,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-EC7DADEQ.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-6WEMO4L4.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -16506,6 +17641,134 @@ ${xml}`
     });
     return parseXmlFragmentToJson(xml);
   }
+  /**
+   * Build the UI-friendly user sessions strings directly in the library.
+   * This is intended for hosts (like Scrypted plugins) that want a stable, consistent
+   * sessions view without re-implementing parsing/formatting logic.
+   */
+  async getOnlineUserSessionsForUi(options) {
+    const sessions = await this.getOnlineUserList(options);
+    let socketSessionId;
+    try {
+      socketSessionId = this.client?.getSocketSessionId?.();
+    } catch {
+    }
+    const out = [];
+    out.push(`Last updated: ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+    if (socketSessionId) {
+      out.push(`Current socket session ID: ${socketSessionId}`);
+    }
+    try {
+      const summary = this.getDedicatedSessionsSummary();
+      out.push(`Internal dedicated sessions (active): ${summary.count}`);
+      for (const key of summary.keys) {
+        out.push(`  - ${key}`);
+      }
+    } catch {
+    }
+    out.push("");
+    const looksLikeUserSession = (value) => {
+      if (!value || typeof value !== "object") return false;
+      const hasUser = value.userName !== void 0 || value.user !== void 0 || value.username !== void 0;
+      const hasIp = value.ip !== void 0 || value.ipAddress !== void 0;
+      const hasPort = value.port !== void 0;
+      const hasSessionId = value.sessionId !== void 0;
+      const hasId = value.id !== void 0;
+      return hasUser && (hasIp || hasPort) || hasSessionId && (hasUser || hasIp || hasPort) || hasId && (hasUser || hasIp || hasPort);
+    };
+    const seen = /* @__PURE__ */ new Set();
+    const keyFor = (session, group) => {
+      const user = session?.userName ?? session?.user ?? session?.username;
+      const ip = session?.ip ?? session?.ipAddress;
+      const port = session?.port;
+      const sessionId = session?.sessionId;
+      const id = session?.id;
+      return `${group ?? ""}|u:${String(user ?? "")}@${String(ip ?? "")}:${String(
+        port ?? ""
+      )}|sid:${String(sessionId ?? "")}|id:${String(id ?? "")}`;
+    };
+    const collected = [];
+    const collect = (data, group) => {
+      if (!data) return;
+      if (Array.isArray(data)) {
+        for (const item of data) {
+          if (looksLikeUserSession(item)) {
+            const k = keyFor(item, group);
+            if (!seen.has(k)) {
+              seen.add(k);
+              collected.push(
+                group ? { session: item, group } : { session: item }
+              );
+            }
+          } else if (item && typeof item === "object") {
+            collect(item, group);
+          }
+        }
+        return;
+      }
+      if (typeof data !== "object") return;
+      let foundNested = false;
+      for (const [k, v] of Object.entries(data)) {
+        if (Array.isArray(v)) {
+          foundNested = true;
+          collect(v, k);
+        } else if (v && typeof v === "object") {
+          foundNested = true;
+          collect(v, group);
+        }
+      }
+      if (!foundNested && looksLikeUserSession(data)) {
+        const k = keyFor(data, group);
+        if (!seen.has(k)) {
+          seen.add(k);
+          collected.push(group ? { session: data, group } : { session: data });
+        }
+      }
+    };
+    const format = (session, index, group) => {
+      const parts = [];
+      if (group) parts.push(`[${group}]`);
+      parts.push(`Session ${index}:`);
+      if (session.userName !== void 0)
+        parts.push(`User: ${session.userName}`);
+      if (session.user !== void 0) parts.push(`User: ${session.user}`);
+      if (session.ip !== void 0) parts.push(`IP: ${session.ip}`);
+      if (session.ipAddress !== void 0)
+        parts.push(`IP: ${session.ipAddress}`);
+      if (session.port !== void 0) parts.push(`Port: ${session.port}`);
+      if (session.sessionId !== void 0)
+        parts.push(`Session ID: ${session.sessionId}`);
+      if (session.id !== void 0) parts.push(`ID: ${session.id}`);
+      if (session.loginTime !== void 0)
+        parts.push(`Login Time: ${session.loginTime}`);
+      if (session.time !== void 0) parts.push(`Time: ${session.time}`);
+      if (session.status !== void 0) parts.push(`Status: ${session.status}`);
+      if (parts.length === (group ? 2 : 1)) {
+        if (session && typeof session === "object") {
+          const allFields = Object.entries(session).filter(([, v]) => v === null || typeof v !== "object").map(([k, v]) => `${k}: ${v}`).join(", ");
+          if (allFields) parts.push(allFields);
+        }
+      }
+      return parts.join(" | ");
+    };
+    collect(sessions);
+    const onlineUserList = sessions.body?.OnlineUserList;
+    const rawCurrent = onlineUserList?.OnlineUser;
+    const rawLegacy = onlineUserList?.item;
+    const currentItems = Array.isArray(rawCurrent) ? rawCurrent : rawCurrent ? [rawCurrent] : [];
+    const legacyItems = Array.isArray(rawLegacy) ? rawLegacy : rawLegacy ? [rawLegacy] : [];
+    const sessionIds = currentItems.map((s) => `${s.sessionId}@${s.ipAddress}`).join(", ");
+    const legacyIds = legacyItems.map((s) => `${s.sessionId}@${s.ip}`).join(", ");
+    this.logger.log?.(
+      `[ReolinkBaichuanApi] getOnlineUserSessionsForUi: legacyItems=${legacyItems.length}, currentItems=${currentItems.length} [${sessionIds || legacyIds || "none"}]`
+    );
+    let count = 0;
+    for (const entry of collected) {
+      out.push(format(entry.session, ++count, entry.group));
+    }
+    if (count === 0) out.push("No active sessions found");
+    return out;
+  }
   // Placeholder cmdIds seen in PCAPs but without XML samples yet.
   // Expose as JSON (parsed from XML) for easy inspection.
   async getCmd123(channel, options) {
@@ -16862,18 +18125,12 @@ ${scheduleItems}
       ...params.isNvr != null ? { isNvr: params.isNvr } : {},
       ...params.deviceId != null ? { deviceId: params.deviceId } : {}
     };
-    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(async () => {
-      try {
-        return await this.startRecordingReplayStream(startParams);
-      } catch (e) {
-        if (!params.deviceId) throw e;
-        const sessionKey = `replay:${params.deviceId}`;
-        logger?.debug?.(
-          `[createRecordingReplayMp4Stream] startRecordingReplayStream failed; force-closing dedicated client and retrying once`
-        );
-        await this.forceCloseDedicatedClient(sessionKey, logger);
-        return await this.startRecordingReplayStream(startParams);
-      }
+    const {
+      result: replayResult,
+      release: releaseQueueSlot,
+      abortSignal
+    } = await this.enqueueStreamingReplayOperation(async () => {
+      return await this.startRecordingReplayStream(startParams);
     });
     const { stream, stop: stopReplay } = replayResult;
     const input = new PassThrough();
@@ -17017,6 +18274,20 @@ ${scheduleItems}
       },
       Math.max(1, seconds) * 1e3
     );
+    if (abortSignal) {
+      abortSignal.addEventListener(
+        "abort",
+        () => {
+          if (!ended) {
+            logger?.debug?.(
+              `[createRecordingReplayMp4Stream] Abort signal received, stopping for new clip`
+            );
+            void stopAll();
+          }
+        },
+        { once: true }
+      );
+    }
     output.on("close", () => {
       clearTimeout(timer);
       void stopAll();
@@ -17269,18 +18540,12 @@ ${scheduleItems}
       ...params.isNvr != null ? { isNvr: params.isNvr } : {},
       ...params.deviceId != null ? { deviceId: params.deviceId } : {}
     };
-    const { result: replayResult, release: releaseQueueSlot } = await this.enqueueStreamingReplayOperation(async () => {
-      try {
-        return await this.startRecordingReplayStream(startParams);
-      } catch (e) {
-        if (!params.deviceId) throw e;
-        const sessionKey = `replay:${params.deviceId}`;
-        logger?.debug?.(
-          `[createRecordingReplayHlsSession] startRecordingReplayStream failed; force-closing dedicated client and retrying once`
-        );
-        await this.forceCloseDedicatedClient(sessionKey, logger);
-        return await this.startRecordingReplayStream(startParams);
-      }
+    const {
+      result: replayResult,
+      release: releaseQueueSlot,
+      abortSignal
+    } = await this.enqueueStreamingReplayOperation(async () => {
+      return await this.startRecordingReplayStream(startParams);
     });
     const { stream, stop: stopReplay } = replayResult;
     const input = new PassThrough();
@@ -17465,6 +18730,20 @@ ${scheduleItems}
       },
       Math.max(1, seconds) * 1e3
     );
+    if (abortSignal) {
+      abortSignal.addEventListener(
+        "abort",
+        () => {
+          if (!ended) {
+            logger?.debug?.(
+              `[createRecordingReplayHlsSession] Abort signal received, stopping for new clip`
+            );
+            void stopAll();
+          }
+        },
+        { once: true }
+      );
+    }
     stream.on("error", (e) => {
       logger?.error?.(
         `[createRecordingReplayHlsSession] Stream error: ${e.message}`
@@ -18206,7 +19485,9 @@ async function discoverUidForHost(host, logger) {
       const directMatch = directDevices.find((d) => d.host === directTarget);
       const directUid = normalizeUid(directMatch?.uid);
       if (directUid) {
-        logger?.log?.(`[AutoDetect] UID discovered via UDP direct: ${maskUid(directUid)}`);
+        logger?.log?.(
+          `[AutoDetect] UID discovered via UDP direct: ${maskUid(directUid)}`
+        );
         return directUid;
       }
     } catch {
@@ -18220,7 +19501,9 @@ async function discoverUidForHost(host, logger) {
     const match = devices.find((d) => d.host === ip || d.host === host);
     const uid = normalizeUid(match?.uid);
     if (uid) {
-      logger?.log?.(`[AutoDetect] UID discovered via UDP broadcast: ${maskUid(uid)}`);
+      logger?.log?.(
+        `[AutoDetect] UID discovered via UDP broadcast: ${maskUid(uid)}`
+      );
       return uid;
     }
   } catch {
@@ -18236,7 +19519,13 @@ async function pingHost(host, timeoutMs = 3e3) {
   return new Promise((resolve) => {
     const { exec } = __require("child_process");
     const platform = process.platform;
-    const pingCmd = platform === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform === "darwin" ? `ping -c 1 -W ${timeoutMs} ${host}` : `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`;
+    const pingCmd = platform === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform === "darwin" ? (
+      // macOS: -W is in milliseconds (Linux: seconds)
+      `ping -c 1 -W ${timeoutMs} ${host}`
+    ) : (
+      // Linux/BSD-ish: -W is in seconds on most distros
+      `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
+    );
     exec(pingCmd, (error) => {
       resolve(!error);
     });
@@ -18259,15 +19548,20 @@ function createBaichuanApi(inputs, transport) {
     return api2;
   }
   const uid = normalizeUid(inputs.uid);
-  if (!uid) {
-    throw new Error("UID is required for battery cameras (BCUDP)");
+  const isLocalDirect = inputs.udpDiscoveryMethod === "local-direct";
+  if (!uid && !isLocalDirect) {
+    throw new Error(
+      "UID is required for UDP cameras (BCUDP) unless using local-direct discovery"
+    );
   }
   const api = new ReolinkBaichuanApi({
     ...base,
     transport: "udp",
-    uid,
-    ...inputs.udpDiscoveryMethod ? { udpDiscoveryMethod: inputs.udpDiscoveryMethod } : {},
-    idleDisconnect: true
+    // UID is optional for local-direct, required for other methods
+    ...uid ? { uid } : {},
+    ...inputs.udpDiscoveryMethod ? { udpDiscoveryMethod: inputs.udpDiscoveryMethod } : {}
+    // NOTE: idleDisconnect is NOT enabled here - it will be enabled dynamically
+    // after detecting if the device has a battery (via setIdleDisconnect)
   });
   attachErrorHandler(api, transport, inputs);
   return api;
@@ -18280,7 +19574,9 @@ function attachErrorHandler(api, transport, inputs) {
       if (typeof msg === "string" && (msg.includes("Baichuan socket closed") || msg.includes("Baichuan UDP stream closed") || msg.includes("Not running"))) {
         return;
       }
-      inputs.logger?.log?.(`[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`);
+      inputs.logger?.log?.(
+        `[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`
+      );
     });
     api.client.on("close", () => {
     });
@@ -18291,7 +19587,13 @@ async function autoDetectDeviceType(inputs) {
   const { host, uid, logger } = inputs;
   const mode = inputs.mode ?? "auto";
   const maxRetriesRaw = inputs.maxRetries;
-  const maxRetries = Math.max(1, Math.min(10, typeof maxRetriesRaw === "number" && Number.isFinite(maxRetriesRaw) ? Math.floor(maxRetriesRaw) : 1));
+  const maxRetries = Math.max(
+    1,
+    Math.min(
+      10,
+      typeof maxRetriesRaw === "number" && Number.isFinite(maxRetriesRaw) ? Math.floor(maxRetriesRaw) : 1
+    )
+  );
   const fmtErr = (e) => {
     const m = e?.message || e?.toString?.() || String(e);
     return typeof m === "string" ? m : String(m);
@@ -18317,7 +19619,9 @@ async function autoDetectDeviceType(inputs) {
         lastErr = e;
         const msg = fmtErr(e);
         const retryable = attempt < max && shouldRetry(e);
-        logger?.log?.(`[AutoDetect] ${label} attempt ${attempt}/${max} failed: ${msg}${retryable ? " (will retry)" : ""}`);
+        logger?.log?.(
+          `[AutoDetect] ${label} attempt ${attempt}/${max} failed: ${msg}${retryable ? " (will retry)" : ""}`
+        );
         if (!retryable) throw e;
         await sleepMs2(350);
       }
@@ -18328,15 +19632,21 @@ async function autoDetectDeviceType(inputs) {
   logger?.log?.(`[AutoDetect] Pinging ${host}...`);
   const isReachable = await pingHost(host);
   if (!isReachable) {
-    logger?.log?.(`[AutoDetect] Host ${host} is not reachable via ping, but continuing with connection attempt...`);
+    logger?.log?.(
+      `[AutoDetect] Host ${host} is not reachable via ping, but continuing with connection attempt...`
+    );
   } else {
     logger?.log?.(`[AutoDetect] Host ${host} is reachable`);
   }
   if (mode === "udp") {
-    logger?.log?.(`[AutoDetect] Forced mode=udp, skipping TCP and starting UDP discovery/login...`);
+    logger?.log?.(
+      `[AutoDetect] Forced mode=udp, skipping TCP and starting UDP discovery/login...`
+    );
     let normalizedUid = effectiveUid;
     if (!normalizedUid) {
-      logger?.log?.(`[AutoDetect] UID not provided; attempting UDP discovery for UID...`);
+      logger?.log?.(
+        `[AutoDetect] UID not provided; attempting UDP discovery for UID...`
+      );
       const discovered = await discoverUidForHost(host, logger);
       const normalizedDiscovered = normalizeUid(discovered);
       if (!normalizedDiscovered) {
@@ -18355,13 +19665,18 @@ async function autoDetectDeviceType(inputs) {
           `UDP(${m})`,
           maxRetries,
           async (attempt) => {
-            const api = createBaichuanApi({ ...inputs, uid: normalizedUid, udpDiscoveryMethod: m }, "udp");
+            const api = createBaichuanApi(
+              { ...inputs, uid: normalizedUid, udpDiscoveryMethod: m },
+              "udp"
+            );
             try {
               await api.login();
               return api;
             } catch (e) {
               try {
-                await api.close({ reason: `autodetect:udp_failed:${m}:attempt_${attempt}` });
+                await api.close({
+                  reason: `autodetect:udp_failed:${m}:attempt_${attempt}`
+                });
               } catch {
               }
               throw e;
@@ -18379,10 +19694,11 @@ async function autoDetectDeviceType(inputs) {
         const channelNumValue = typeof channelNum === "string" ? Number.parseInt(channelNum, 10) : channelNum;
         const hasDualLensChannelCount = (channelNumValue === 2 || channelNumValue === 3) && Number.isFinite(channelNumValue);
         const isMultifocal = isMultifocalByModel || hasDualLensChannelCount;
+        const hasBattery = capabilities?.capabilities?.hasBattery === true;
         if (isMultifocal) {
           const detectionMethod = isMultifocalByModel ? "model match" : "channelNum fallback";
           logger?.log?.(
-            `[AutoDetect] UDP (${m}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}).`
+            `[AutoDetect] UDP (${m}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}, hasBattery=${hasBattery}).`
           );
           return {
             type: "multifocal",
@@ -18395,9 +19711,12 @@ async function autoDetectDeviceType(inputs) {
             api: udpApi
           };
         }
-        logger?.log?.(`[AutoDetect] UDP (${m}) connection successful. Detected battery camera.`);
+        const deviceType = hasBattery ? "battery-cam" : "camera";
+        logger?.log?.(
+          `[AutoDetect] UDP (${m}) connection successful. Detected ${deviceType} (hasBattery=${hasBattery}, model=${normalizedModel ?? "unknown"}).`
+        );
         return {
-          type: "battery-cam",
+          type: deviceType,
           transport: "udp",
           uid: normalizedUid,
           udpDiscoveryMethod: m,
@@ -18412,7 +19731,9 @@ async function autoDetectDeviceType(inputs) {
         logger?.log?.(`[AutoDetect] UDP (${m}) failed: ${msg}`);
       }
     }
-    throw new Error(`Forced UDP autodetect failed for all methods. ${udpErrors.join(" | ")}`);
+    throw new Error(
+      `Forced UDP autodetect failed for all methods. ${udpErrors.join(" | ")}`
+    );
   }
   let tcpApi;
   try {
@@ -18427,7 +19748,9 @@ async function autoDetectDeviceType(inputs) {
           return api2;
         } catch (e) {
           try {
-            await api2.close({ reason: `autodetect:tcp_failed:attempt_${attempt}` });
+            await api2.close({
+              reason: `autodetect:tcp_failed:attempt_${attempt}`
+            });
           } catch {
           }
           throw e;
@@ -18436,7 +19759,10 @@ async function autoDetectDeviceType(inputs) {
       shouldRetryTcp
     );
     const api = tcpApi;
-    if (!api) throw new Error("AutoDetect internal error: TCP API not initialized after successful login");
+    if (!api)
+      throw new Error(
+        "AutoDetect internal error: TCP API not initialized after successful login"
+      );
     const runProbeVariants = async (label, variants) => {
       let lastMsg;
       for (const v of variants) {
@@ -18447,30 +19773,67 @@ async function autoDetectDeviceType(inputs) {
         } catch (e) {
           const msg = fmtErr(e);
           lastMsg = msg;
-          logger?.log?.(`[AutoDetect] TCP probe ${label} failed (${v.variant}): ${msg}`);
+          logger?.log?.(
+            `[AutoDetect] TCP probe ${label} failed (${v.variant}): ${msg}`
+          );
         }
       }
       if (lastMsg) {
-        logger?.log?.(`[AutoDetect] TCP probe ${label} failed (all variants): ${lastMsg}`);
+        logger?.log?.(
+          `[AutoDetect] TCP probe ${label} failed (all variants): ${lastMsg}`
+        );
       }
       return void 0;
     };
     const infoProbe = await runProbeVariants(
       "getInfo",
       [
-        { variant: "cmd80 class=0x6414", op: () => api.getInfo(void 0, { timeoutMs: 2500, messageClass: BC_CLASS_MODERN_24 }) },
-        { variant: "cmd80 class=0x6614", op: () => api.getInfo(void 0, { timeoutMs: 3e3, messageClass: BC_CLASS_MODERN_20 }) },
-        { variant: "cmd318(ch0) class=0x6414", op: () => api.getInfo(0, { timeoutMs: 3e3, messageClass: BC_CLASS_MODERN_24 }) },
-        { variant: "cmd318(ch0) class=0x6614", op: () => api.getInfo(0, { timeoutMs: 3500, messageClass: BC_CLASS_MODERN_20 }) }
-      ]
-    );
-    const supportProbe = await runProbeVariants(
-      "getSupportInfo",
-      [
-        { variant: "cmd199 class=0x6414", op: () => api.getSupportInfo({ timeoutMs: 2500, messageClass: BC_CLASS_MODERN_24 }) },
-        { variant: "cmd199 class=0x6614", op: () => api.getSupportInfo({ timeoutMs: 3500, messageClass: BC_CLASS_MODERN_20 }) }
+        {
+          variant: "cmd80 class=0x6414",
+          op: () => api.getInfo(void 0, {
+            timeoutMs: 2500,
+            messageClass: BC_CLASS_MODERN_24
+          })
+        },
+        {
+          variant: "cmd80 class=0x6614",
+          op: () => api.getInfo(void 0, {
+            timeoutMs: 3e3,
+            messageClass: BC_CLASS_MODERN_20
+          })
+        },
+        {
+          variant: "cmd318(ch0) class=0x6414",
+          op: () => api.getInfo(0, {
+            timeoutMs: 3e3,
+            messageClass: BC_CLASS_MODERN_24
+          })
+        },
+        {
+          variant: "cmd318(ch0) class=0x6614",
+          op: () => api.getInfo(0, {
+            timeoutMs: 3500,
+            messageClass: BC_CLASS_MODERN_20
+          })
+        }
       ]
     );
+    const supportProbe = await runProbeVariants("getSupportInfo", [
+      {
+        variant: "cmd199 class=0x6414",
+        op: () => api.getSupportInfo({
+          timeoutMs: 2500,
+          messageClass: BC_CLASS_MODERN_24
+        })
+      },
+      {
+        variant: "cmd199 class=0x6614",
+        op: () => api.getSupportInfo({
+          timeoutMs: 3500,
+          messageClass: BC_CLASS_MODERN_20
+        })
+      }
+    ]);
     const deviceInfo = infoProbe?.value;
     const support = supportProbe?.value;
     const channelNumRaw = support?.channelNum;
@@ -18487,7 +19850,9 @@ async function autoDetectDeviceType(inputs) {
     const isMultifocal = isMultifocalByModel || hasDualLensChannelCount;
     if (isMultifocal) {
       const detectionMethod = isMultifocalByModel ? "model match" : "channelNum fallback";
-      logger?.log?.(`[AutoDetect] Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum})`);
+      logger?.log?.(
+        `[AutoDetect] Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum})`
+      );
       return {
         type: "multifocal",
         transport: "tcp",
@@ -18499,7 +19864,9 @@ async function autoDetectDeviceType(inputs) {
       };
     }
     if (effectiveChannelNum > 1) {
-      logger?.log?.(`[AutoDetect] Detected NVR (${effectiveChannelNum} channels)`);
+      logger?.log?.(
+        `[AutoDetect] Detected NVR (${effectiveChannelNum} channels)`
+      );
       return {
         type: "nvr",
         transport: "tcp",
@@ -18533,23 +19900,27 @@ async function autoDetectDeviceType(inputs) {
     if (!isTcpFailureThatShouldFallbackToUdp(tcpError)) {
       throw tcpError;
     }
-    logger?.log?.(`[AutoDetect] TCP failed, trying UDP (battery camera)...`);
+    logger?.log?.(`[AutoDetect] TCP failed, trying UDP...`);
     let normalizedUid = effectiveUid;
     if (!normalizedUid) {
-      logger?.log?.(`[AutoDetect] UID not provided; attempting UDP broadcast discovery for UID...`);
+      logger?.log?.(
+        `[AutoDetect] UID not provided; attempting UDP broadcast discovery for UID...`
+      );
       const discovered = await discoverUidForHost(host, logger);
-      if (!discovered) {
-        throw new Error(
-          `TCP connection failed and device likely requires UDP/BCUDP. UID is required for battery cameras (ip=${host}).`
-        );
+      if (discovered) {
+        const normalizedDiscovered = normalizeUid(discovered);
+        if (normalizedDiscovered) {
+          normalizedUid = normalizedDiscovered;
+          logger?.log?.(
+            `[AutoDetect] UID discovered via broadcast: ${normalizedUid}`
+          );
+        }
       }
-      const normalizedDiscovered = normalizeUid(discovered);
-      if (!normalizedDiscovered) {
-        throw new Error(
-          `TCP connection failed and device likely requires UDP/BCUDP, but UID discovery returned an empty UID (ip=${host}).`
+      if (!normalizedUid) {
+        logger?.log?.(
+          `[AutoDetect] UID discovery failed; will try local-direct without UID first.`
         );
       }
-      normalizedUid = normalizedDiscovered;
     }
     try {
       const detectOverUdpApi = async (udpApi, udpDiscoveryMethod) => {
@@ -18563,31 +19934,38 @@ async function autoDetectDeviceType(inputs) {
         const channelNumValue = typeof channelNum === "string" ? Number.parseInt(channelNum, 10) : channelNum;
         const hasDualLensChannelCount = (channelNumValue === 2 || channelNumValue === 3) && Number.isFinite(channelNumValue);
         const isMultifocal = isMultifocalByModel || hasDualLensChannelCount;
+        const hasBattery = capabilities?.capabilities?.hasBattery === true;
+        udpApi.setIdleDisconnect(hasBattery);
         if (isMultifocal) {
           const detectionMethod = isMultifocalByModel ? "model match" : "channelNum fallback";
           logger?.log?.(
-            `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}).`
+            `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}, hasBattery=${hasBattery}).`
           );
           return {
             type: "multifocal",
             transport: "udp",
-            uid: normalizedUid,
+            uid: normalizedUid ?? "",
             udpDiscoveryMethod,
             deviceInfo,
             ...hostNetworkInfo ? { hostNetworkInfo } : {},
             channelNum,
+            hasBattery,
             api: udpApi
           };
         }
-        logger?.log?.(`[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected battery camera.`);
+        const deviceType = hasBattery ? "battery-cam" : "udp-camera";
+        logger?.log?.(
+          `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected ${deviceType} (hasBattery=${hasBattery}, model=${normalizedModel ?? "unknown"}).`
+        );
         return {
-          type: "battery-cam",
+          type: deviceType,
           transport: "udp",
-          uid: normalizedUid,
+          uid: normalizedUid ?? "",
           udpDiscoveryMethod,
           deviceInfo,
           ...hostNetworkInfo ? { hostNetworkInfo } : {},
           channelNum: 1,
+          hasBattery,
           api: udpApi
         };
       };
@@ -18600,13 +19978,22 @@ async function autoDetectDeviceType(inputs) {
             `UDP(${m})`,
             maxRetries,
             async (attempt) => {
-              const api = createBaichuanApi({ ...inputs, uid: normalizedUid, udpDiscoveryMethod: m }, "udp");
+              const apiInputs = {
+                ...inputs,
+                udpDiscoveryMethod: m
+              };
+              if (normalizedUid) {
+                apiInputs.uid = normalizedUid;
+              }
+              const api = createBaichuanApi(apiInputs, "udp");
               try {
                 await api.login();
                 return api;
               } catch (e) {
                 try {
-                  await api.close({ reason: `autodetect:udp_failed:${m}:attempt_${attempt}` });
+                  await api.close({
+                    reason: `autodetect:udp_failed:${m}:attempt_${attempt}`
+                  });
                 } catch {
                 }
                 throw e;
@@ -18624,7 +20011,9 @@ async function autoDetectDeviceType(inputs) {
           logger?.log?.(`[AutoDetect] UDP (${m}) failed: ${msg}`);
         }
       }
-      throw new Error(`UDP discovery failed for all methods. ${udpErrors.join(" | ")}`);
+      throw new Error(
+        `UDP discovery failed for all methods. ${udpErrors.join(" | ")}`
+      );
     } catch (udpError) {
       logger?.log?.(
         `[AutoDetect] Both TCP and UDP failed. TCP error: ${tcpError}, UDP error: ${udpError}`
@@ -18676,4 +20065,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-YUBYINJF.js.map
+//# sourceMappingURL=chunk-ULSFEQSE.js.map