@apocaliss92/nodelink-js 0.4.6 → 0.4.8

package/dist/cli/rtsp-server.cjs

@@ -1851,7 +1851,7 @@ var init_BaichuanVideoStream = __esm({
             const allowMsgNum0Fallback = this.acceptAnyStreamType && frame.header.msgNum === 0;
             if (!allowMsgNum0Fallback) {
               const frameCount = this._msgNumMismatchCount = (this._msgNumMismatchCount || 0) + 1;
-              if (frameCount <= 5) {
+              if (frameCount <= 5 && this.client.getDebugConfig().general) {
                 this.logger?.log(
                   `[BaichuanVideoStream] Frame msgNum mismatch: received=${frame.header.msgNum}, expected=${this.activeMsgNum}, channel=${this.channel}, profile=${this.profile}, variant=${this.variant} (frame discarded)`
                 );
@@ -1861,7 +1861,7 @@ var init_BaichuanVideoStream = __esm({
           }
           if (!this.acceptAnyStreamType && !this.expectedStreamTypes.has(frame.header.streamType)) {
             const frameCount = this._streamTypeMismatchCount = (this._streamTypeMismatchCount || 0) + 1;
-            if (frameCount <= 5) {
+            if (frameCount <= 5 && this.client.getDebugConfig().general) {
               this.logger?.log(
                 `[BaichuanVideoStream] Frame streamType mismatch: received=${frame.header.streamType}, expectedAny=[${[
                   ...this.expectedStreamTypes
@@ -7815,19 +7815,34 @@ async function* createNativeStream(api, channel, profile, options) {
       }
     });
     streamStarted = true;
-    while (!closed) {
+    const signal = options?.signal;
+    while (!closed && !signal?.aborted) {
       if (frameQueue.length > 0) {
         const frame = frameQueue.shift();
         yield frame;
       } else {
         await new Promise((resolve) => {
           frameResolve = resolve;
-          setTimeout(() => {
+          const timer = setTimeout(() => {
             if (frameResolve === resolve) {
               frameResolve = null;
               resolve();
             }
           }, 1e3);
+          if (signal) {
+            const onAbort = () => {
+              clearTimeout(timer);
+              if (frameResolve === resolve) frameResolve = null;
+              resolve();
+            };
+            if (signal.aborted) {
+              clearTimeout(timer);
+              frameResolve = null;
+              resolve();
+            } else {
+              signal.addEventListener("abort", onAbort, { once: true });
+            }
+          }
         });
       }
     }
@@ -8000,13 +8015,14 @@ var NativeStreamFanout = class {
   source = null;
   running = false;
   pumpPromise = null;
+  abort = new AbortController();
   constructor(opts) {
     this.opts = opts;
   }
   start() {
     if (this.running) return;
     this.running = true;
-    this.source = this.opts.createSource();
+    this.source = this.opts.createSource(this.abort.signal);
     this.pumpPromise = (async () => {
       try {
         for await (const frame of this.source) {
@@ -8052,6 +8068,7 @@ var NativeStreamFanout = class {
     this.source = null;
     for (const q of this.queues.values()) q.close();
     this.queues.clear();
+    this.abort.abort();
     try {
       await src?.return(void 0);
     } catch {
@@ -8090,9 +8107,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   requireAuth;
   authNonces = /* @__PURE__ */ new Map();
   // Track nonces per client
-  AUTH_REALM = "BaichuanRtspServer";
+  AUTH_REALM;
   NONCE_TIMEOUT_MS = 3e5;
   // 5 minutes
+  lazyMetadata;
   // Client tracking
   connectedClients = /* @__PURE__ */ new Set();
   // Set of client IDs (IP:port)
@@ -8104,8 +8122,15 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   // Track all client resources for cleanup
   clientResources = /* @__PURE__ */ new Map();
   isRtspDebugEnabled() {
-    const dbg = this.api.client.getDebugConfig();
-    return dbg.debugRtsp || envBool(process.env.BAICHUAN_DEBUG_RTSP, false);
+    try {
+      if (this.api.isClosed) {
+        return envBool(process.env.BAICHUAN_DEBUG_RTSP, false);
+      }
+      const dbg = this.api.client.getDebugConfig();
+      return dbg.debugRtsp || envBool(process.env.BAICHUAN_DEBUG_RTSP, false);
+    } catch {
+      return envBool(process.env.BAICHUAN_DEBUG_RTSP, false);
+    }
   }
   rtspDebugLog(message) {
     if (!this.isRtspDebugEnabled()) return;
@@ -8127,10 +8152,20 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   // Shared native stream fan-out (single camera stream, multiple RTSP clients)
   nativeFanout = null;
   noClientAutoStopTimer;
+  /** Fires if camera never sends frames after stream start (sleeping), even with clients connected. */
+  noFrameDeadlineTimer;
   /** After last RTSP client; 0 = never auto-stop native stream. */
   nativeStreamIdleStopMs;
   /** Primed-but-no-PLAY timeout; 0 = disabled. */
   nativeStreamPrimeIdleStopMs;
+  /**
+   * Max time to wait for the first camera frame after stream start.
+   * If no frames arrive within this window, the native stream is stopped
+   * (camera is sleeping). Prevents the BaichuanVideoStream watchdog from
+   * firing and waking the camera when no real viewer is watching.
+   * 0 = disabled. Defaults to nativeStreamPrimeIdleStopMs * 2 when > 0.
+   */
+  nativeStreamNoFrameDeadlineMs;
   // Prebuffer: rolling ring of recent video frames for IDR-aligned fast startup.
   // When a new client connects while the stream is already running it does not need
   // to wait up to one full GOP interval for the next keyframe — we replay frames
@@ -8256,14 +8291,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     this.logger = options.logger ?? console;
     this.tcpRtpFraming = options.tcpRtpFraming ?? "rfc4571";
     this.deviceId = options.deviceId;
-    this.externalListener = options.externalListener ?? false;
+    this.externalListener = (options.externalListener ?? false) || (options.muxMode ?? false);
     this.nativeStreamIdleStopMs = options.nativeStreamIdleStopMs ?? 3e4;
     this.nativeStreamPrimeIdleStopMs = options.nativeStreamPrimeIdleStopMs ?? (this.nativeStreamIdleStopMs > 0 ? 15e3 : 0);
-    this.authCredentials = options.credentials ?? [];
+    this.nativeStreamNoFrameDeadlineMs = this.nativeStreamPrimeIdleStopMs > 0 ? Math.min(this.nativeStreamPrimeIdleStopMs * 2, 3e4) : 0;
+    this.authCredentials = (options.credentials ?? []).map((c) => ({
+      username: c.username,
+      ...c.password !== void 0 ? { password: c.password } : {},
+      ...c.ha1 !== void 0 ? { ha1: c.ha1 } : {}
+    }));
     this.requireAuth = options.requireAuth ?? this.authCredentials.length > 0;
+    this.AUTH_REALM = options.authRealm ?? "BaichuanRtspServer";
+    this.lazyMetadata = options.lazyMetadata ?? false;
     const transport = this.api.client.getTransport();
     this.flow = createRtspFlow(transport, "H264");
   }
+  /** Number of currently connected RTSP clients. */
+  get clientCount() {
+    return this.connectedClients.size;
+  }
   // --- Authentication helpers ---
   /**
    * Generate a new nonce for Digest authentication
@@ -8324,9 +8370,16 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       this.rtspDebugLog(`Auth failed: nonce mismatch for client ${clientId}`);
       return false;
     }
+    if (realm !== this.AUTH_REALM) {
+      this.rtspDebugLog(
+        `Auth failed: realm mismatch (client="${realm}", server="${this.AUTH_REALM}")`
+      );
+      return false;
+    }
     for (const cred of this.authCredentials) {
       if (username !== cred.username) continue;
-      const ha1 = this.md5(`${cred.username}:${realm}:${cred.password}`);
+      const ha1 = cred.ha1 ?? (cred.password !== void 0 ? this.md5(`${cred.username}:${this.AUTH_REALM}:${cred.password}`) : void 0);
+      if (!ha1) continue;
       const ha2 = this.md5(`${method}:${authUri || uri}`);
       const expectedResponse = this.md5(`${ha1}:${nonce}:${ha2}`);
       if (response === expectedResponse) {
@@ -8355,6 +8408,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       this.noClientAutoStopTimer = void 0;
     }
   }
+  clearNoFrameDeadlineTimer() {
+    if (this.noFrameDeadlineTimer) {
+      clearTimeout(this.noFrameDeadlineTimer);
+      this.noFrameDeadlineTimer = void 0;
+    }
+  }
   setFlowVideoType(videoType, reason) {
     if (this.flow.videoType === videoType) return;
     const transport = this.api.client.getTransport();
@@ -8369,25 +8428,31 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     if (this.active) {
       throw new Error("RTSP server is already active");
     }
-    try {
-      const metadata = await this.api.getStreamMetadata(this.channel);
-      const stream = metadata.streams.find((s) => s.profile === this.profile);
-      if (stream) {
-        this.streamMetadata = {
-          frameRate: stream.frameRate || 25,
-          width: stream.width,
-          height: stream.height
-        };
-        const enc = String(stream.videoEncType ?? "").trim().toLowerCase();
-        const metaVideoType = enc.includes("265") || enc.includes("hevc") ? "H265" : "H264";
-        this.setFlowVideoType(metaVideoType, "metadata");
-      }
-    } catch (error) {
-      this.logger.warn(
-        `[BaichuanRtspServer] Could not get stream metadata: ${error}`
+    if (this.lazyMetadata) {
+      this.logger.info(
+        `[BaichuanRtspServer] lazy metadata: skipping initial getStreamMetadata; will fetch on first DESCRIBE`
       );
-      this.streamMetadata = { frameRate: 25 };
-      this.setFlowVideoType("H264", "metadata unavailable");
+    } else {
+      try {
+        const metadata = await this.api.getStreamMetadata(this.channel);
+        const stream = metadata.streams.find((s) => s.profile === this.profile);
+        if (stream) {
+          this.streamMetadata = {
+            frameRate: stream.frameRate || 25,
+            width: stream.width,
+            height: stream.height
+          };
+          const enc = String(stream.videoEncType ?? "").trim().toLowerCase();
+          const metaVideoType = enc.includes("265") || enc.includes("hevc") ? "H265" : "H264";
+          this.setFlowVideoType(metaVideoType, "metadata");
+        }
+      } catch (error) {
+        this.logger.warn(
+          `[BaichuanRtspServer] Could not get stream metadata: ${error}`
+        );
+        this.streamMetadata = { frameRate: 25 };
+        this.setFlowVideoType("H264", "metadata unavailable");
+      }
     }
     if (!this.externalListener) {
       this.clientConnectionServer = net.createServer((socket) => {
@@ -8428,6 +8493,30 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     }
     this.handleRtspConnection(socket, initialBuffer);
   }
+  /**
+   * Inject an already-accepted client socket from a multiplexer
+   * (e.g. `LocalRtspMux`) that owns the listening port.
+   *
+   * The mux reads the first RTSP request line to determine the target path,
+   * then hands the socket over. Any bytes already consumed during routing
+   * are replayed back onto the socket via `unshift()` so the RTSP parser in
+   * `handleRtspConnection` sees the complete original request.
+   *
+   * @param socket - Client TCP socket, already accepted by the mux.
+   * @param preReadData - Bytes the mux has already pulled off the socket
+   *   while parsing the request line. Replayed via `socket.unshift()`
+   *   before any further reads.
+   */
+  injectSocket(socket, preReadData) {
+    if (!this.active) {
+      socket.end("RTSP/1.0 503 Service Unavailable\r\n\r\n");
+      return;
+    }
+    if (preReadData && preReadData.length > 0) {
+      socket.unshift(preReadData);
+    }
+    this.handleRtspConnection(socket);
+  }
   /**
    * Handle RTSP connection from a client.
    */
@@ -8592,6 +8681,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
             Public: "DESCRIBE, SETUP, TEARDOWN, PLAY, PAUSE, OPTIONS"
           });
         } else if (method === "DESCRIBE") {
+          if (!this.api.isClosed && !this.api.isReady && !this.nativeStreamActive) {
+            void this.api.ensureConnected().catch(() => {
+            });
+          }
           if (!this.flow.getFmtp().hasParamSets && this.connectedClients.size === 0) {
             try {
               if (!this.nativeStreamActive) {
@@ -8629,6 +8722,27 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
               }
             }
           }
+          if (!this.hasAudio && this.firstAudioPromise) {
+            const audioPrimingMs = this.api.client.getTransport() === "udp" ? 3e3 : 2e3;
+            const audioPrimingStart = Date.now();
+            try {
+              await Promise.race([
+                this.firstAudioPromise,
+                new Promise((resolve) => setTimeout(resolve, audioPrimingMs))
+              ]);
+            } catch {
+            }
+            const audioPrimingElapsed = Date.now() - audioPrimingStart;
+            if (this.hasAudio) {
+              this.logger.info(
+                `[rebroadcast] DESCRIBE audio priming: AAC detected after ${audioPrimingElapsed}ms  client=${clientId} path=${this.path}`
+              );
+            } else {
+              this.logger.info(
+                `[rebroadcast] DESCRIBE audio priming: no audio after ${audioPrimingElapsed}ms \u2014 SDP will be video-only  client=${clientId} path=${this.path}`
+              );
+            }
+          }
           {
             const { fmtp, hasParamSets } = this.flow.getFmtp();
             const fmtpPreview = fmtp.length > 160 ? `${fmtp.slice(0, 160)}...` : fmtp;
@@ -8637,12 +8751,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
             );
           }
           const sdp = this.generateSdp();
+          const contentHost = (socket.localAddress && socket.localAddress !== "0.0.0.0" && socket.localAddress !== "::" ? socket.localAddress.replace(/^::ffff:/, "") : null) ?? this.listenHost;
           sendResponse(
             200,
             "OK",
             {
               "Content-Type": "application/sdp",
-              "Content-Base": `rtsp://${this.listenHost}:${this.listenPort}${this.path}/`
+              "Content-Base": `rtsp://${contentHost}:${this.listenPort}${this.path}/`
             },
             sdp
           );
@@ -8665,7 +8780,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
           this.emit("client", clientId);
           this.clearNoClientAutoStopTimer();
           if (this.connectedClients.size === 1 && !this.nativeStreamActive) {
-            await this.startNativeStream();
+            void this.startNativeStream();
           }
           const transportMatch = requestText.match(/Transport:\s*([^\r\n]+)/i);
           const transport = (transportMatch?.[1] ?? "").trim();
@@ -8799,12 +8914,23 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
         }
       }
     };
+    const runProcessBuffer = () => {
+      processBuffer().catch((err) => {
+        this.logger.debug(
+          `[BaichuanRtspServer] processBuffer failed for ${clientId}: ${err?.message ?? err}`
+        );
+        try {
+          socket.destroy();
+        } catch {
+        }
+      });
+    };
     socket.on("data", (data) => {
       buffer = Buffer.concat([buffer, data]);
-      void processBuffer();
+      runProcessBuffer();
     });
     if (buffer.includes("\r\n\r\n")) {
-      void processBuffer();
+      runProcessBuffer();
     }
   }
   /**
@@ -9672,6 +9798,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     if (this.nativeStreamActive) {
       return;
     }
+    if (!this.api.isReady) {
+      if (this.api.isClosed) {
+        this.logger.warn?.(
+          `[rebroadcast] API has been explicitly closed \u2014 stream cannot start  profile=${this.profile}`
+        );
+        return;
+      }
+      try {
+        this.logger.info?.(
+          `[rebroadcast] API not ready (idle disconnect?), calling ensureConnected  profile=${this.profile}`
+        );
+        await this.api.ensureConnected();
+      } catch (e) {
+        this.logger.warn?.(
+          `[rebroadcast] ensureConnected failed, aborting stream start: ${e}`
+        );
+        return;
+      }
+    }
     this.nativeStreamActive = true;
     this.firstFrameReceived = false;
     this.firstAudioDetected = false;
@@ -9706,13 +9851,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     await this.flow.startKeepAlive(this.api);
     this.nativeFanout = new NativeStreamFanout({
       maxQueueItems: 200,
-      createSource: () => createNativeStream(this.api, this.channel, this.profile, {
+      createSource: (signal) => createNativeStream(this.api, this.channel, this.profile, {
         variant: this.variant,
-        ...dedicatedClient ? { client: dedicatedClient } : {}
+        ...dedicatedClient ? { client: dedicatedClient } : {},
+        signal
       }),
       onFrame: (frame) => {
         if (frame.audio) {
-          if (!this.hasAudio && this.api.client.getTransport() === "tcp" && _BaichuanRtspServer.isAdtsAacFrame(frame.data)) {
+          if (!this.hasAudio && _BaichuanRtspServer.isAdtsAacFrame(frame.data)) {
             const info = _BaichuanRtspServer.parseAdtsSamplingInfo(frame.data);
             if (info) {
               this.hasAudio = true;
@@ -9761,6 +9907,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       onEnd: () => {
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
+        this.clearNoFrameDeadlineTimer();
+        const hadFrames = this.firstFrameReceived;
         this.firstFrameReceived = false;
         this.firstFramePromise = null;
         this.firstFrameResolve = null;
@@ -9785,7 +9933,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
             } catch {
             }
           }
-          if (this.connectedClients.size > 0) {
+          if (this.connectedClients.size > 0 && hadFrames) {
             this.logger.info(
               `[rebroadcast] restarting native stream for ${this.connectedClients.size} active client(s)`
             );
@@ -9797,6 +9945,19 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
       }
     });
     this.nativeFanout.start();
+    this.clearNoFrameDeadlineTimer();
+    if (this.nativeStreamNoFrameDeadlineMs > 0) {
+      this.noFrameDeadlineTimer = setTimeout(() => {
+        this.noFrameDeadlineTimer = void 0;
+        if (!this.firstFrameReceived && this.nativeStreamActive) {
+          this.logger.info(
+            `[rebroadcast] no frames within ${this.nativeStreamNoFrameDeadlineMs}ms \u2014 camera sleeping, stopping stream  profile=${this.profile} channel=${this.channel}`
+          );
+          void this.stopNativeStream();
+        }
+      }, this.nativeStreamNoFrameDeadlineMs);
+      this.noFrameDeadlineTimer?.unref?.();
+    }
     this.clearNoClientAutoStopTimer();
     if (this.nativeStreamPrimeIdleStopMs > 0) {
       this.noClientAutoStopTimer = setTimeout(() => {
@@ -9813,6 +9974,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
   markFirstFrameReceived() {
     if (!this.firstFrameReceived && this.firstFrameResolve) {
       this.firstFrameReceived = true;
+      this.clearNoFrameDeadlineTimer();
       this.rtspDebugLog(
         `First frame received from camera for profile ${this.profile}`
       );
@@ -9839,6 +10001,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events2.E
     );
     this.flow.stopKeepAlive();
     this.clearNoClientAutoStopTimer();
+    this.clearNoFrameDeadlineTimer();
     this.nativeStreamActive = false;
     this.firstFrameReceived = false;
     this.firstFramePromise = null;
@@ -10055,149 +10218,17 @@ init_BcMediaAnnexBDecoder();
 // src/baichuan/stream/MpegTsMuxer.ts
 var TS_PACKET_SIZE = 188;
 var TS_SYNC_BYTE = 71;
-var PAT_PID = 0;
-var PMT_PID = 4096;
-var VIDEO_PID = 256;
+var TS_PAYLOAD_SIZE = TS_PACKET_SIZE - 4;
+var PID_PAT = 0;
+var PID_PMT = 4096;
+var PID_VIDEO = 256;
+var PID_AUDIO = 257;
 var STREAM_TYPE_H264 = 27;
 var STREAM_TYPE_H265 = 36;
-var patCc = 0;
-var pmtCc = 0;
-var videoCc = 0;
-function createPat() {
-  const packet = Buffer.alloc(TS_PACKET_SIZE, 255);
-  packet[0] = TS_SYNC_BYTE;
-  packet[1] = 64 | PAT_PID >> 8 & 31;
-  packet[2] = PAT_PID & 255;
-  packet[3] = 16 | patCc & 15;
-  patCc = patCc + 1 & 15;
-  packet[4] = 0;
-  let idx = 5;
-  packet[idx++] = 0;
-  packet[idx++] = 176;
-  packet[idx++] = 13;
-  packet[idx++] = 0;
-  packet[idx++] = 1;
-  packet[idx++] = 193;
-  packet[idx++] = 0;
-  packet[idx++] = 0;
-  packet[idx++] = 0;
-  packet[idx++] = 1;
-  packet[idx++] = 224 | PMT_PID >> 8 & 31;
-  packet[idx++] = PMT_PID & 255;
-  const crc = crc32Mpeg(packet.subarray(5, idx));
-  packet.writeUInt32BE(crc, idx);
-  return packet;
-}
-function createPmt(streamType) {
-  const packet = Buffer.alloc(TS_PACKET_SIZE, 255);
-  packet[0] = TS_SYNC_BYTE;
-  packet[1] = 64 | PMT_PID >> 8 & 31;
-  packet[2] = PMT_PID & 255;
-  packet[3] = 16 | pmtCc & 15;
-  pmtCc = pmtCc + 1 & 15;
-  packet[4] = 0;
-  let idx = 5;
-  packet[idx++] = 2;
-  packet[idx++] = 176;
-  packet[idx++] = 18;
-  packet[idx++] = 0;
-  packet[idx++] = 1;
-  packet[idx++] = 193;
-  packet[idx++] = 0;
-  packet[idx++] = 0;
-  packet[idx++] = 224 | VIDEO_PID >> 8 & 31;
-  packet[idx++] = VIDEO_PID & 255;
-  packet[idx++] = 240;
-  packet[idx++] = 0;
-  packet[idx++] = streamType;
-  packet[idx++] = 224 | VIDEO_PID >> 8 & 31;
-  packet[idx++] = VIDEO_PID & 255;
-  packet[idx++] = 240;
-  packet[idx++] = 0;
-  const crc = crc32Mpeg(packet.subarray(5, idx));
-  packet.writeUInt32BE(crc, idx);
-  return packet;
-}
-function createVideoPes(data, pts, isKeyframe) {
-  const packets = [];
-  const pts90k = Math.floor(pts * 9e4 / 1e6);
-  const pesHeaderLen = 14;
-  const pesHeader = Buffer.alloc(pesHeaderLen);
-  let idx = 0;
-  pesHeader[idx++] = 0;
-  pesHeader[idx++] = 0;
-  pesHeader[idx++] = 1;
-  pesHeader[idx++] = 224;
-  pesHeader[idx++] = 0;
-  pesHeader[idx++] = 0;
-  pesHeader[idx++] = 128;
-  pesHeader[idx++] = 128;
-  pesHeader[idx++] = 5;
-  pesHeader[idx++] = 33 | pts90k >> 29 & 14;
-  pesHeader[idx++] = pts90k >> 22 & 255;
-  pesHeader[idx++] = 1 | pts90k >> 14 & 254;
-  pesHeader[idx++] = pts90k >> 7 & 255;
-  pesHeader[idx++] = 1 | pts90k << 1 & 254;
-  const pesData = Buffer.concat([pesHeader, data]);
-  let pesOffset = 0;
-  let isFirst = true;
-  while (pesOffset < pesData.length) {
-    const packet = Buffer.alloc(TS_PACKET_SIZE, 255);
-    let pktIdx = 0;
-    packet[pktIdx++] = TS_SYNC_BYTE;
-    packet[pktIdx++] = (isFirst ? 64 : 0) | VIDEO_PID >> 8 & 31;
-    packet[pktIdx++] = VIDEO_PID & 255;
-    const remaining = pesData.length - pesOffset;
-    const maxPayload = TS_PACKET_SIZE - 4;
-    if (remaining >= maxPayload) {
-      packet[pktIdx++] = 16 | videoCc & 15;
-      videoCc = videoCc + 1 & 15;
-      pesData.copy(packet, pktIdx, pesOffset, pesOffset + maxPayload);
-      pesOffset += maxPayload;
-    } else {
-      const adaptLen = maxPayload - remaining - 1;
-      if (adaptLen < 0) {
-        packet[pktIdx++] = 48 | videoCc & 15;
-        videoCc = videoCc + 1 & 15;
-        packet[pktIdx++] = TS_PACKET_SIZE - 4 - 1 - remaining;
-        if (isFirst && isKeyframe) {
-          packet[pktIdx++] = 64;
-          for (let i = pktIdx; i < TS_PACKET_SIZE - remaining; i++) {
-            packet[i] = 255;
-          }
-        } else {
-          packet[pktIdx++] = 0;
-          for (let i = pktIdx; i < TS_PACKET_SIZE - remaining; i++) {
-            packet[i] = 255;
-          }
-        }
-        pesData.copy(packet, TS_PACKET_SIZE - remaining, pesOffset);
-        pesOffset += remaining;
-      } else {
-        packet[pktIdx++] = 48 | videoCc & 15;
-        videoCc = videoCc + 1 & 15;
-        if (adaptLen === 0) {
-          packet[pktIdx++] = 0;
-        } else {
-          packet[pktIdx++] = adaptLen;
-          if (isFirst && isKeyframe) {
-            packet[pktIdx++] = 64;
-          } else {
-            packet[pktIdx++] = 0;
-          }
-          for (let i = 0; i < adaptLen - 1; i++) {
-            packet[pktIdx++] = 255;
-          }
-        }
-        pesData.copy(packet, pktIdx, pesOffset, pesOffset + remaining);
-        pesOffset += remaining;
-      }
-    }
-    packets.push(packet);
-    isFirst = false;
-  }
-  return packets;
-}
+var STREAM_TYPE_AAC = 15;
+var PES_STREAM_ID_VIDEO = 224;
+var PES_STREAM_ID_AUDIO = 192;
+var PAT_PMT_INTERVAL = 40;
 function crc32Mpeg(data) {
   let crc = 4294967295;
   for (let i = 0; i < data.length; i++) {
@@ -10212,45 +10243,218 @@ function crc32Mpeg(data) {
   }
   return crc >>> 0;
 }
+function usToPts(us) {
+  return Math.floor(us * 90 / 1e3) & 8589934591;
+}
+function encodePts(buf, offset, pts, prefix) {
+  buf[offset + 0] = prefix << 4 | (pts >>> 30 & 7) << 1 | 1;
+  buf[offset + 1] = pts >>> 22 & 255;
+  buf[offset + 2] = (pts >>> 15 & 127) << 1 | 1;
+  buf[offset + 3] = pts >>> 7 & 255;
+  buf[offset + 4] = (pts & 127) << 1 | 1;
+}
+function writeTsHeader(buf, pid, pusi, cc, hasAdapt, hasPayload) {
+  buf[0] = TS_SYNC_BYTE;
+  buf[1] = (pusi ? 64 : 0) | pid >> 8 & 31;
+  buf[2] = pid & 255;
+  buf[3] = (hasAdapt ? 32 : 0) | (hasPayload ? 16 : 0) | cc & 15;
+}
+function pesToTsPackets(pesData, pid, ccRef, isKeyframe) {
+  const totalPackets = Math.ceil(pesData.length / TS_PAYLOAD_SIZE);
+  const out = Buffer.allocUnsafe(totalPackets * TS_PACKET_SIZE);
+  let pesOffset = 0;
+  let outOffset = 0;
+  let isFirst = true;
+  while (pesOffset < pesData.length) {
+    const remaining = pesData.length - pesOffset;
+    const packet = out.subarray(outOffset, outOffset + TS_PACKET_SIZE);
+    outOffset += TS_PACKET_SIZE;
+    if (remaining >= TS_PAYLOAD_SIZE) {
+      writeTsHeader(packet, pid, isFirst, ccRef.cc, false, true);
+      ccRef.cc = ccRef.cc + 1 & 15;
+      pesData.copy(packet, 4, pesOffset, pesOffset + TS_PAYLOAD_SIZE);
+      pesOffset += TS_PAYLOAD_SIZE;
+    } else {
+      const paddingNeeded = TS_PAYLOAD_SIZE - remaining;
+      if (paddingNeeded === 1) {
+        writeTsHeader(packet, pid, isFirst, ccRef.cc, true, true);
+        ccRef.cc = ccRef.cc + 1 & 15;
+        packet[4] = 0;
+        pesData.copy(packet, 5, pesOffset, pesOffset + remaining);
+      } else {
+        writeTsHeader(packet, pid, isFirst, ccRef.cc, true, true);
+        ccRef.cc = ccRef.cc + 1 & 15;
+        const adaptLen = paddingNeeded - 1;
+        packet[4] = adaptLen;
+        packet[5] = isFirst && isKeyframe ? 64 : 0;
+        packet.fill(255, 6, 4 + paddingNeeded);
+        pesData.copy(packet, 4 + paddingNeeded, pesOffset, pesOffset + remaining);
+      }
+      pesOffset += remaining;
+    }
+    isFirst = false;
+  }
+  return out;
+}
+function buildPat(cc) {
+  const pkt = Buffer.alloc(TS_PACKET_SIZE, 255);
+  pkt[0] = TS_SYNC_BYTE;
+  pkt[1] = 64 | PID_PAT >> 8 & 31;
+  pkt[2] = PID_PAT & 255;
+  pkt[3] = 16 | cc & 15;
+  pkt[4] = 0;
+  const sectionStart = 5;
+  let i = sectionStart;
+  pkt[i++] = 0;
+  pkt[i++] = 176;
+  pkt[i++] = 13;
+  pkt[i++] = 0;
+  pkt[i++] = 1;
+  pkt[i++] = 193;
+  pkt[i++] = 0;
+  pkt[i++] = 0;
+  pkt[i++] = 0;
+  pkt[i++] = 1;
+  pkt[i++] = 224 | PID_PMT >> 8 & 31;
+  pkt[i++] = PID_PMT & 255;
+  const crc = crc32Mpeg(pkt.subarray(sectionStart, i));
+  pkt.writeUInt32BE(crc, i);
+  return pkt;
+}
+function buildPmt(videoStreamType, includeAudio, cc) {
+  const pkt = Buffer.alloc(TS_PACKET_SIZE, 255);
+  pkt[0] = TS_SYNC_BYTE;
+  pkt[1] = 64 | PID_PMT >> 8 & 31;
+  pkt[2] = PID_PMT & 255;
+  pkt[3] = 16 | cc & 15;
+  pkt[4] = 0;
+  const sectionStart = 5;
+  let i = sectionStart;
+  pkt[i++] = 2;
+  pkt[i++] = 176;
+  const sectionLenPos = i;
+  i += 1;
+  pkt[i++] = 0;
+  pkt[i++] = 1;
+  pkt[i++] = 193;
+  pkt[i++] = 0;
+  pkt[i++] = 0;
+  pkt[i++] = 224 | PID_VIDEO >> 8 & 31;
+  pkt[i++] = PID_VIDEO & 255;
+  pkt[i++] = 240;
+  pkt[i++] = 0;
+  pkt[i++] = videoStreamType;
+  pkt[i++] = 224 | PID_VIDEO >> 8 & 31;
+  pkt[i++] = PID_VIDEO & 255;
+  pkt[i++] = 240;
+  pkt[i++] = 0;
+  if (includeAudio) {
+    pkt[i++] = STREAM_TYPE_AAC;
+    pkt[i++] = 224 | PID_AUDIO >> 8 & 31;
+    pkt[i++] = PID_AUDIO & 255;
+    pkt[i++] = 240;
+    pkt[i++] = 0;
+  }
+  const sectionLen = i - sectionStart - 3 + 4;
+  pkt[sectionLenPos] = sectionLen;
+  const crc = crc32Mpeg(pkt.subarray(sectionStart, i));
+  pkt.writeUInt32BE(crc, i);
+  return pkt;
+}
+function buildVideoPes(annexBData, ptsUs, isKeyframe) {
+  const pts = usToPts(ptsUs);
+  const pesHeader = Buffer.allocUnsafe(14);
+  pesHeader[0] = 0;
+  pesHeader[1] = 0;
+  pesHeader[2] = 1;
+  pesHeader[3] = PES_STREAM_ID_VIDEO;
+  pesHeader[4] = 0;
+  pesHeader[5] = 0;
+  pesHeader[6] = 128 | (isKeyframe ? 4 : 0);
+  pesHeader[7] = 128;
+  pesHeader[8] = 5;
+  encodePts(pesHeader, 9, pts, 2);
+  return Buffer.concat([pesHeader, annexBData]);
+}
+function buildAudioPes(adtsData, ptsUs) {
+  const pts = usToPts(ptsUs);
+  const pesPayloadLen = 8 + adtsData.length;
+  const pesHeader = Buffer.allocUnsafe(14);
+  pesHeader[0] = 0;
+  pesHeader[1] = 0;
+  pesHeader[2] = 1;
+  pesHeader[3] = PES_STREAM_ID_AUDIO;
+  pesHeader[4] = pesPayloadLen >> 8 & 255;
+  pesHeader[5] = pesPayloadLen & 255;
+  pesHeader[6] = 128;
+  pesHeader[7] = 128;
+  pesHeader[8] = 5;
+  encodePts(pesHeader, 9, pts, 2);
+  return Buffer.concat([pesHeader, adtsData]);
+}
 var MpegTsMuxer = class {
-  streamType;
-  patSent = false;
-  pmtSent = false;
-  patPmtInterval = 0;
-  patPmtIntervalMax = 40;
-  // Send PAT/PMT every ~40 frames
+  videoStreamType;
+  includeAudio;
+  // Per-instance continuity counters (4-bit, wrap at 16)
+  patCc = 0;
+  pmtCc = 0;
+  videoCc = 0;
+  audioCc = 0;
+  framesSinceTableSend = 0;
+  tablesSent = false;
   constructor(options) {
-    this.streamType = options.videoType === "H265" ? STREAM_TYPE_H265 : STREAM_TYPE_H264;
+    this.videoStreamType = options.videoType === "H265" ? STREAM_TYPE_H265 : STREAM_TYPE_H264;
+    this.includeAudio = options.includeAudio ?? true;
   }
   /**
-   * Reset continuity counters (call when starting a new stream).
+   * Mux a video frame (Annex-B H.264 or H.265) into MPEG-TS packets.
+   * PAT and PMT are emitted before keyframes and periodically.
+   *
+   * @param annexBData - Annex-B video data (with start codes)
+   * @param ptsUs      - Presentation timestamp in microseconds
+   * @param isKeyframe - Whether this is an IDR / IRAP frame
    */
-  static resetCounters() {
-    patCc = 0;
-    pmtCc = 0;
-    videoCc = 0;
+  muxVideo(annexBData, ptsUs, isKeyframe) {
+    const chunks = [];
+    const needTables = !this.tablesSent || isKeyframe || this.framesSinceTableSend >= PAT_PMT_INTERVAL;
+    if (needTables) {
+      chunks.push(buildPat(this.patCc));
+      this.patCc = this.patCc + 1 & 15;
+      chunks.push(buildPmt(this.videoStreamType, this.includeAudio, this.pmtCc));
+      this.pmtCc = this.pmtCc + 1 & 15;
+      this.tablesSent = true;
+      this.framesSinceTableSend = 0;
+    }
+    this.framesSinceTableSend++;
+    const pes = buildVideoPes(annexBData, ptsUs, isKeyframe);
+    const ccRef = { cc: this.videoCc };
+    chunks.push(pesToTsPackets(pes, PID_VIDEO, ccRef, isKeyframe));
+    this.videoCc = ccRef.cc;
+    return Buffer.concat(chunks);
   }
   /**
-   * Mux a video frame into MPEG-TS packets.
+   * Mux an audio frame (ADTS AAC) into MPEG-TS packets.
+   * Returns an empty Buffer when includeAudio is false.
    *
-   * @param data - Annex-B video data (with start codes)
-   * @param microseconds - Frame timestamp in microseconds
-   * @param isKeyframe - Whether this is a keyframe
-   * @returns Buffer containing all TS packets for this frame
-   */
-  mux(data, microseconds, isKeyframe) {
-    const packets = [];
-    if (!this.patSent || !this.pmtSent || isKeyframe || this.patPmtInterval >= this.patPmtIntervalMax) {
-      packets.push(createPat());
-      packets.push(createPmt(this.streamType));
-      this.patSent = true;
-      this.pmtSent = true;
-      this.patPmtInterval = 0;
-    }
-    this.patPmtInterval++;
-    const videoPackets = createVideoPes(data, microseconds, isKeyframe);
-    packets.push(...videoPackets);
-    return Buffer.concat(packets);
+   * @param adtsData - Raw ADTS AAC frame (starting with 0xFF 0xF1/0xF9 syncword)
+   * @param ptsUs    - Presentation timestamp in microseconds
+   */
+  muxAudio(adtsData, ptsUs) {
+    if (!this.includeAudio || adtsData.length === 0) return Buffer.alloc(0);
+    const pes = buildAudioPes(adtsData, ptsUs);
+    const ccRef = { cc: this.audioCc };
+    const result = pesToTsPackets(pes, PID_AUDIO, ccRef, false);
+    this.audioCc = ccRef.cc;
+    return result;
+  }
+  /** Reset all continuity counters and table state (e.g. after stream restart). */
+  reset() {
+    this.patCc = 0;
+    this.pmtCc = 0;
+    this.videoCc = 0;
+    this.audioCc = 0;
+    this.framesSinceTableSend = 0;
+    this.tablesSent = false;
   }
 };
 
@@ -15526,6 +15730,53 @@ var getAiStateViaGetAiAlarm = async (params) => {
   throw lastErr instanceof Error ? lastErr : new Error(String(lastErr ?? "getAiState failed"));
 };
 
+// src/reolink/baichuan/utils/sleepInference.ts
+function decideSleepInferenceTransition(input) {
+  const { inferred, committed, pending, hysteresisPolls } = input;
+  if (committed === void 0) {
+    return {
+      emit: inferred === "sleeping" ? "sleeping" : null,
+      nextCommitted: inferred,
+      nextPending: void 0
+    };
+  }
+  if (inferred === committed) {
+    return {
+      emit: null,
+      nextCommitted: committed,
+      nextPending: void 0
+    };
+  }
+  const effectivePolls = Math.max(1, hysteresisPolls);
+  if (!pending || pending.state !== inferred) {
+    if (effectivePolls <= 1) {
+      return {
+        emit: inferred === "sleeping" ? "sleeping" : "awake",
+        nextCommitted: inferred,
+        nextPending: void 0
+      };
+    }
+    return {
+      emit: null,
+      nextCommitted: committed,
+      nextPending: { state: inferred, count: 1 }
+    };
+  }
+  const nextCount = pending.count + 1;
+  if (nextCount < effectivePolls) {
+    return {
+      emit: null,
+      nextCommitted: committed,
+      nextPending: { state: inferred, count: nextCount }
+    };
+  }
+  return {
+    emit: inferred === "sleeping" ? "sleeping" : "awake",
+    nextCommitted: inferred,
+    nextPending: void 0
+  };
+}
+
 // src/reolink/baichuan/utils/channelInfoPush.ts
 init_xml();
 var parseOptionalInt = (value) => {
@@ -17495,6 +17746,13 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * - "replay:XXX" - dedicated per replay session
    */
   socketPool = /* @__PURE__ */ new Map();
+  /**
+   * Consecutive stream-start (cmdId=3) timeout counter per socket tag.
+   * When a streaming socket has N consecutive timeouts, the socket is force-closed
+   * so the next attempt creates a fresh connection. Resets on success.
+   */
+  consecutiveStreamTimeouts = /* @__PURE__ */ new Map();
+  static MAX_CONSECUTIVE_STREAM_TIMEOUTS = 3;
   /** BaichuanClientOptions to use when creating new sockets */
   clientOptions;
   /**
@@ -17649,14 +17907,20 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         if (!xml) return;
         const channel = frame.header.channelId;
         const battery = this.parseBatteryInfoXml(xml, channel);
-        if (battery.batteryPercent !== void 0 || battery.chargeStatus !== void 0 || battery.adapterStatus !== void 0) {
-          this.dispatchSimpleEvent({
-            type: "battery",
-            channel,
-            timestamp: Date.now(),
-            battery
-          });
+        if (battery.batteryPercent === void 0 && battery.chargeStatus === void 0 && battery.adapterStatus === void 0) {
+          return;
         }
+        const key = `${battery.batteryPercent ?? ""}|${battery.chargeStatus ?? ""}|${battery.adapterStatus ?? ""}`;
+        if (this.lastBatteryPushKey.get(channel) === key) {
+          return;
+        }
+        this.lastBatteryPushKey.set(channel, key);
+        this.dispatchSimpleEvent({
+          type: "battery",
+          channel,
+          timestamp: Date.now(),
+          battery
+        });
       } catch (e) {
         this.logger.debug?.(
           "[ReolinkBaichuanApi] Error parsing battery push",
@@ -17789,7 +18053,17 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   statePollingInterval;
   udpSleepInferenceInterval;
   udpLastInferredSleepStateByChannel = /* @__PURE__ */ new Map();
+  /**
+   * Per-channel pending sleep-state candidate for hysteresis.
+   * When the inference flips to a new state we require N consecutive polls
+   * of that same state before committing it — this filters out transient
+   * flapping caused by non-waking traffic drifting in/out of the 10 s
+   * getSleepStatus() observation window during stream teardown.
+   */
+  udpPendingSleepStateByChannel = /* @__PURE__ */ new Map();
   udpSleepInferenceIntervalMs = 2e3;
+  /** Consecutive inference polls required to commit a new sleeping/awake state. */
+  udpSleepInferenceHysteresisPolls = 2;
   lastMotionState;
   lastAiState;
   aiStatePollingDisabled = false;
@@ -17822,6 +18096,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   deviceCapabilitiesCache = /* @__PURE__ */ new Map();
   static CAPABILITIES_CACHE_TTL_MS = 5 * 60 * 1e3;
   // 5 minutes
+  /**
+   * Dedupe key for battery push events (cmd_id 252), per channel.
+   * Cameras emit BatteryInfoList frequently while streaming (every few
+   * seconds). We only forward an event when the meaningful fields change
+   * (percent, chargeStatus, adapterStatus) to avoid flooding SSE/MQTT
+   * consumers and the UI event log.
+   */
+  lastBatteryPushKey = /* @__PURE__ */ new Map();
   // ─────────────────────────────────────────────────────────────────────────────
   // SOCKET POOL CONSTANTS
   // ─────────────────────────────────────────────────────────────────────────────
@@ -18248,6 +18530,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    */
   attachD2cDiscListener(client) {
     client.on("d2c_disc", () => this.notifyD2cDisc());
+    client.on("error", () => {
+    });
   }
   /**
    * Acquire a socket from the pool by tag.
@@ -18366,6 +18650,11 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         const clientOpts = log ? { ...this.clientOptions, logger: log } : this.clientOptions;
         const newClient = new BaichuanClient(clientOpts);
         this.attachD2cDiscListener(newClient);
+        newClient.on("error", (err) => {
+          log?.debug?.(
+            `[SocketPool] tag=${tag} client error: ${err?.message ?? err}`
+          );
+        });
         await newClient.login();
         const existingCooldown = this.socketPoolCooldowns.get(this.host);
         if (existingCooldown) {
@@ -18881,6 +19170,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Only counts sessions from our own IP address.
    */
   async maybeRebootOnTooManySessions() {
+    if (!this.client.isSocketConnected?.()) return;
     const threshold = this.maxDedicatedSessionsBeforeReboot ?? 10;
     if (this.sessionGuardRebootInFlight) return;
     const cooldownMs = 10 * 6e4;
@@ -19322,6 +19612,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   }
   async renewSimpleEventSubscription() {
     if (this.simpleEventListeners.size === 0) return;
+    if (!this.client.isSocketConnected?.()) return;
     if (this.simpleEventResubscribeInFlight)
       return await this.simpleEventResubscribeInFlight;
     this.simpleEventResubscribeInFlight = (async () => {
@@ -23089,23 +23380,32 @@ ${stderr}`)
         return;
       }
       const channel = this.client.getConfiguredChannel?.() ?? 0;
+      if (!this.client.isSocketConnected?.()) {
+        this.udpPendingSleepStateByChannel.delete(channel);
+        return;
+      }
       const status = this.getSleepStatus({ channel });
       if (status.state === "unknown") return;
-      const prev = this.udpLastInferredSleepStateByChannel.get(channel);
-      this.udpLastInferredSleepStateByChannel.set(channel, status.state);
-      if (prev === void 0) {
-        if (status.state === "sleeping") {
-          this.dispatchSimpleEvent({
-            type: "sleeping",
-            channel,
-            timestamp: Date.now()
-          });
-        }
-        return;
+      const committed = this.udpLastInferredSleepStateByChannel.get(channel);
+      const pending = this.udpPendingSleepStateByChannel.get(channel);
+      const decision = decideSleepInferenceTransition({
+        inferred: status.state,
+        committed,
+        pending,
+        hysteresisPolls: this.udpSleepInferenceHysteresisPolls
+      });
+      this.udpLastInferredSleepStateByChannel.set(
+        channel,
+        decision.nextCommitted
+      );
+      if (decision.nextPending === void 0) {
+        this.udpPendingSleepStateByChannel.delete(channel);
+      } else {
+        this.udpPendingSleepStateByChannel.set(channel, decision.nextPending);
       }
-      if (prev !== status.state) {
+      if (decision.emit) {
         this.dispatchSimpleEvent({
-          type: status.state === "sleeping" ? "sleeping" : "awake",
+          type: decision.emit,
           channel,
           timestamp: Date.now()
         });
@@ -23128,6 +23428,7 @@ ${stderr}`)
       this.udpSleepInferenceInterval = void 0;
     }
     this.udpLastInferredSleepStateByChannel.clear();
+    this.udpPendingSleepStateByChannel.clear();
   }
   /**
    * GetEvents via Baichuan (legacy - use subscribeEvents for real-time events).
@@ -23294,6 +23595,7 @@ ${stderr}`)
           `${ch}:${profile}:${variant}`,
           frame.header.msgNum
         );
+        this.resetStreamTimeoutCounter(targetClient);
         return;
       } catch (error) {
         lastError = error;
@@ -23308,6 +23610,10 @@ ${stderr}`)
         }
       }
     }
+    const isTimeout = lastError instanceof Error && lastError.message?.includes("timeout");
+    if (isTimeout) {
+      this.trackStreamTimeout(targetClient);
+    }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
   }
   /**
@@ -23767,6 +24073,18 @@ ${stderr}`)
   notifyD2cDisc() {
     const now = Date.now();
     this.lastD2cDiscAtMs = now;
+    const streamingTags = Array.from(this.socketPool.keys()).filter(
+      (tag) => tag.startsWith("streaming:")
+    );
+    if (streamingTags.length > 0) {
+      this.logger?.log?.(
+        `[D2C_DISC] Force-closing ${streamingTags.length} streaming socket(s): ${streamingTags.join(", ")}`
+      );
+      for (const tag of streamingTags) {
+        this.forceClosePooledSocket(tag, this.logger).catch(() => {
+        });
+      }
+    }
     const immediateCooldownUntil = now + _ReolinkBaichuanApi.D2C_DISC_IMMEDIATE_COOLDOWN_MS;
     const existing = this.socketPoolCooldowns.get(this.host);
     if (!existing || existing.cooldownUntil < immediateCooldownUntil) {
@@ -23799,6 +24117,43 @@ ${stderr}`)
       }
     }
   }
+  /**
+   * Find the socket pool tag for a given BaichuanClient instance.
+   * Returns undefined if the client is not in the pool (e.g. it's the general socket used directly).
+   */
+  findSocketTagForClient(client) {
+    for (const [tag, entry] of this.socketPool) {
+      if (entry.client === client) return tag;
+    }
+    return void 0;
+  }
+  /**
+   * Reset the consecutive stream-start timeout counter for a streaming socket.
+   * Called on successful stream start.
+   */
+  resetStreamTimeoutCounter(client) {
+    const tag = this.findSocketTagForClient(client);
+    if (tag) this.consecutiveStreamTimeouts.delete(tag);
+  }
+  /**
+   * Track a stream-start timeout on a streaming socket.
+   * After MAX_CONSECUTIVE_STREAM_TIMEOUTS consecutive timeouts, force-close the
+   * socket so the next attempt creates a fresh connection.
+   */
+  trackStreamTimeout(client) {
+    const tag = this.findSocketTagForClient(client);
+    if (!tag || !tag.startsWith("streaming:")) return;
+    const count = (this.consecutiveStreamTimeouts.get(tag) ?? 0) + 1;
+    this.consecutiveStreamTimeouts.set(tag, count);
+    if (count >= _ReolinkBaichuanApi.MAX_CONSECUTIVE_STREAM_TIMEOUTS) {
+      this.logger?.warn?.(
+        `[SocketPool] ${count} consecutive stream timeouts on tag=${tag}, force-closing socket`
+      );
+      this.consecutiveStreamTimeouts.delete(tag);
+      this.forceClosePooledSocket(tag, this.logger).catch(() => {
+      });
+    }
+  }
   /**
    * Best-effort sleeping inference for battery/BCUDP cameras.
    *
@@ -26672,8 +27027,8 @@ ${scheduleItems}
       );
       let args;
       if (useMpegTsMuxer) {
-        MpegTsMuxer.resetCounters();
-        tsMuxer = new MpegTsMuxer({ videoType });
+        tsMuxer = new MpegTsMuxer({ videoType, includeAudio: false });
+        tsMuxer.reset();
         args = [
           "-hide_banner",
           "-loglevel",
@@ -26837,7 +27192,7 @@ ${scheduleItems}
         startFfmpeg(videoType);
         frameCount++;
         if (useMpegTsMuxer && tsMuxer) {
-          const tsData = tsMuxer.mux(data, microseconds, isKeyframe);
+          const tsData = tsMuxer.muxVideo(data, microseconds, isKeyframe);
           input.write(tsData);
         } else {
           if (videoType === "H264") input.write(H264_AUD);
@@ -27126,8 +27481,8 @@ ${scheduleItems}
       logger?.log?.(
         `[createRecordingReplayHlsSession] Starting ffmpeg HLS with videoType=${videoType}, transcode=${needsTranscode}, hlsTime=${hlsSegmentDuration}s, fileName=${params.fileName}`
       );
-      MpegTsMuxer.resetCounters();
-      tsMuxer = new MpegTsMuxer({ videoType });
+      tsMuxer = new MpegTsMuxer({ videoType, includeAudio: false });
+      tsMuxer.reset();
       const args = [
         "-hide_banner",
         "-loglevel",
@@ -27292,7 +27647,7 @@ ${scheduleItems}
         startFfmpeg(videoType);
         frameCount++;
         if (tsMuxer) {
-          const tsData = tsMuxer.mux(data, microseconds, isKeyframe);
+          const tsData = tsMuxer.muxVideo(data, microseconds, isKeyframe);
           input.write(tsData);
         }
         if (frameCount === 1) {
@@ -28036,16 +28391,16 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
   return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("socket hang up") || message.includes("TCP connection timeout") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
 }
 async function pingHost(host, timeoutMs = 3e3) {
+  const { exec } = await import("child_process");
+  const platform2 = process.platform;
+  const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "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}`
+  );
   return new Promise((resolve) => {
-    const { exec } = require("child_process");
-    const platform2 = process.platform;
-    const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "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);
     });
@@ -28127,9 +28482,10 @@ async function autoDetectDeviceType(inputs) {
     const msg = fmtErr(e);
     return msg.includes("Not running") || msg.includes("Baichuan UDP stream closed") || msg.includes("Baichuan socket closed") || msg.includes("ETIMEDOUT") || msg.toLowerCase().includes("timeout");
   };
-  const withRetries = async (label, max, op, shouldRetry) => {
+  const withRetries = async (label, max, op, shouldRetry, isAborted) => {
     let lastErr;
     for (let attempt = 1; attempt <= max; attempt++) {
+      if (isAborted?.()) throw new Error(`${label}: aborted (race won by another method)`);
       try {
         if (attempt > 1) {
           logger?.log?.(`[AutoDetect] ${label}: retry ${attempt}/${max}...`);
@@ -28138,7 +28494,7 @@ async function autoDetectDeviceType(inputs) {
       } catch (e) {
         lastErr = e;
         const msg = fmtErr(e);
-        const retryable = attempt < max && shouldRetry(e);
+        const retryable = attempt < max && !isAborted?.() && shouldRetry(e);
         logger?.log?.(
           `[AutoDetect] ${label} attempt ${attempt}/${max} failed: ${msg}${retryable ? " (will retry)" : ""}`
         );
@@ -28148,6 +28504,31 @@ async function autoDetectDeviceType(inputs) {
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr ?? `${label} failed`));
   };
+  const runUdpMethodsParallel = async (methods, loginAndDetect, errorPrefix) => {
+    let raceWon = false;
+    const methodErrors = /* @__PURE__ */ new Map();
+    try {
+      return await Promise.any(
+        methods.map(async (m) => {
+          try {
+            const result = await loginAndDetect(m, () => raceWon);
+            raceWon = true;
+            return result;
+          } catch (e) {
+            if (!raceWon) methodErrors.set(m, fmtErr(e));
+            logger?.log?.(`[AutoDetect] UDP (${m}) failed: ${fmtErr(e)}`);
+            throw e;
+          }
+        })
+      );
+    } catch (e) {
+      if (e instanceof AggregateError) {
+        const msgs = methods.map((m) => `${m}: ${methodErrors.get(m) ?? "unknown"}`);
+        throw new Error(`${errorPrefix} ${msgs.join(" | ")}`);
+      }
+      throw e;
+    }
+  };
   const effectiveUid = normalizeUid(uid);
   logger?.log?.(`[AutoDetect] Pinging ${host}...`);
   const isReachable = await pingHost(host);
@@ -28177,9 +28558,9 @@ async function autoDetectDeviceType(inputs) {
       normalizedUid = normalizedDiscovered;
     }
     const methodsToTry = inputs.udpDiscoveryMethod ? [inputs.udpDiscoveryMethod] : ["local-direct", "local-broadcast", "remote", "relay", "map"];
-    const udpErrors = [];
-    for (const m of methodsToTry) {
-      try {
+    return await runUdpMethodsParallel(
+      methodsToTry,
+      async (m, isAborted) => {
         logger?.log?.(`[AutoDetect] Trying UDP discovery method: ${m}...`);
         const udpApi = await withRetries(
           `UDP(${m})`,
@@ -28202,11 +28583,14 @@ async function autoDetectDeviceType(inputs) {
               throw e;
             }
           },
-          shouldRetryUdp
+          shouldRetryUdp,
+          isAborted
         );
-        const deviceInfo = await udpApi.getInfo();
-        const capabilities = await udpApi.getDeviceCapabilities();
-        const hostNetworkInfo = await udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0);
+        const [deviceInfo, capabilities, hostNetworkInfo] = await Promise.all([
+          udpApi.getInfo(),
+          udpApi.getDeviceCapabilities(),
+          udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0)
+        ]);
         const channelNum = capabilities?.support?.channelNum ?? 1;
         const model = deviceInfo.type?.trim();
         const normalizedModel = model ? model.trim() : void 0;
@@ -28245,14 +28629,8 @@ async function autoDetectDeviceType(inputs) {
           channelNum: 1,
           api: udpApi
         };
-      } catch (e) {
-        const msg = fmtErr(e);
-        udpErrors.push(`${m}: ${msg}`);
-        logger?.log?.(`[AutoDetect] UDP (${m}) failed: ${msg}`);
-      }
-    }
-    throw new Error(
-      `Forced UDP autodetect failed for all methods. ${udpErrors.join(" | ")}`
+      },
+      "Forced UDP autodetect failed for all methods."
     );
   }
   let tcpApi;
@@ -28305,54 +28683,57 @@ async function autoDetectDeviceType(inputs) {
       }
       return void 0;
     };
-    const infoProbe = await runProbeVariants(
-      "getInfo",
-      [
+    const [infoProbe, supportProbe] = await Promise.all([
+      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
+            })
+          }
+        ]
+      ),
+      // Support probes (cmd 199). Some firmwares may not support it or are slow.
+      runProbeVariants("getSupportInfo", [
         {
-          variant: "cmd80 class=0x6414",
-          op: () => api.getInfo(void 0, {
+          variant: "cmd199 class=0x6414",
+          op: () => api.getSupportInfo({
             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, {
+          variant: "cmd199 class=0x6614",
+          op: () => api.getSupportInfo({
             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;
@@ -28444,9 +28825,11 @@ async function autoDetectDeviceType(inputs) {
     }
     try {
       const detectOverUdpApi = async (udpApi, udpDiscoveryMethod) => {
-        const deviceInfo = await udpApi.getInfo();
-        const capabilities = await udpApi.getDeviceCapabilities();
-        const hostNetworkInfo = await udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0);
+        const [deviceInfo, capabilities, hostNetworkInfo] = await Promise.all([
+          udpApi.getInfo(),
+          udpApi.getDeviceCapabilities(),
+          udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0)
+        ]);
         const channelNum = capabilities?.support?.channelNum ?? 1;
         const model = deviceInfo.type?.trim();
         const normalizedModel = model ? model.trim() : void 0;
@@ -28490,21 +28873,17 @@ async function autoDetectDeviceType(inputs) {
         };
       };
       const methodsToTry = ["local-direct", "local-broadcast", "remote", "relay", "map"];
-      const udpErrors = [];
-      for (const m of methodsToTry) {
-        try {
+      const viableMethods = normalizedUid ? methodsToTry : methodsToTry.filter((m) => m === "local-direct" || m === "local-broadcast");
+      return await runUdpMethodsParallel(
+        viableMethods,
+        async (m, isAborted) => {
           logger?.log?.(`[AutoDetect] Trying UDP discovery method: ${m}...`);
           const udpApi = await withRetries(
             `UDP(${m})`,
             maxRetries,
             async (attempt) => {
-              const apiInputs = {
-                ...inputs,
-                udpDiscoveryMethod: m
-              };
-              if (normalizedUid) {
-                apiInputs.uid = normalizedUid;
-              }
+              const apiInputs = { ...inputs, udpDiscoveryMethod: m };
+              if (normalizedUid) apiInputs.uid = normalizedUid;
               const api = createBaichuanApi(apiInputs, "udp");
               try {
                 await api.login();
@@ -28519,20 +28898,12 @@ async function autoDetectDeviceType(inputs) {
                 throw e;
               }
             },
-            shouldRetryUdp
+            shouldRetryUdp,
+            isAborted
           );
-          return await detectOverUdpApi(udpApi, m);
-        } catch (e) {
-          const msg = e?.message || e?.toString?.() || String(e);
-          udpErrors.push(`${m}: ${msg}`);
-          try {
-          } catch {
-          }
-          logger?.log?.(`[AutoDetect] UDP (${m}) failed: ${msg}`);
-        }
-      }
-      throw new Error(
-        `UDP discovery failed for all methods. ${udpErrors.join(" | ")}`
+          return detectOverUdpApi(udpApi, m);
+        },
+        "UDP discovery failed for all methods."
       );
     } catch (udpError) {
       logger?.log?.(