@apocaliss92/nodelink-js 0.4.6 → 0.4.8

package/dist/index.cjs

@@ -2462,7 +2462,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)`
                 );
@@ -2472,7 +2472,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
@@ -7896,6 +7896,7 @@ __export(index_exports, {
   HlsSessionManager: () => HlsSessionManager,
   Intercom: () => Intercom,
   MjpegTransformer: () => MjpegTransformer,
+  MpegTsMuxer: () => MpegTsMuxer,
   NVR_HUB_EXACT_TYPES: () => NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS: () => NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi: () => ReolinkBaichuanApi,
@@ -7954,6 +7955,7 @@ __export(index_exports, {
   createRfc4571TcpServerForReplay: () => createRfc4571TcpServerForReplay,
   createRtspProxyServer: () => createRtspProxyServer,
   createTaggedLogger: () => createTaggedLogger,
+  decideSleepInferenceTransition: () => decideSleepInferenceTransition,
   decideVideoclipTranscodeMode: () => decideVideoclipTranscodeMode,
   decodeHeader: () => decodeHeader,
   deriveAesKey: () => deriveAesKey,
@@ -13234,19 +13236,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 });
+            }
+          }
         });
       }
     }
@@ -13419,13 +13436,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) {
@@ -13471,6 +13489,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 {
@@ -13509,9 +13528,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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)
@@ -13523,8 +13543,15 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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;
@@ -13546,10 +13573,20 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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
@@ -13675,14 +13712,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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
@@ -13743,9 +13791,16 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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) {
@@ -13774,6 +13829,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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();
@@ -13788,25 +13849,31 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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 = net2.createServer((socket) => {
@@ -13847,6 +13914,30 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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.
    */
@@ -14011,6 +14102,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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) {
@@ -14048,6 +14143,27 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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: hasParamSets2 } = this.flow.getFmtp();
             const fmtpPreview = fmtp.length > 160 ? `${fmtp.slice(0, 160)}...` : fmtp;
@@ -14056,12 +14172,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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
           );
@@ -14084,7 +14201,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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();
@@ -14218,12 +14335,23 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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();
     }
   }
   /**
@@ -15091,6 +15219,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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;
@@ -15125,13 +15272,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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;
@@ -15180,6 +15328,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
       onEnd: () => {
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
+        this.clearNoFrameDeadlineTimer();
+        const hadFrames = this.firstFrameReceived;
         this.firstFrameReceived = false;
         this.firstFramePromise = null;
         this.firstFrameResolve = null;
@@ -15204,7 +15354,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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)`
             );
@@ -15216,6 +15366,19 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.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(() => {
@@ -15232,6 +15395,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
   markFirstFrameReceived() {
     if (!this.firstFrameReceived && this.firstFrameResolve) {
       this.firstFrameReceived = true;
+      this.clearNoFrameDeadlineTimer();
       this.rtspDebugLog(
         `First frame received from camera for profile ${this.profile}`
       );
@@ -15258,6 +15422,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     );
     this.flow.stopKeepAlive();
     this.clearNoClientAutoStopTimer();
+    this.clearNoFrameDeadlineTimer();
     this.nativeStreamActive = false;
     this.firstFrameReceived = false;
     this.firstFramePromise = null;
@@ -15474,149 +15639,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++) {
@@ -15631,45 +15664,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;
-  }
-  /**
-   * Reset continuity counters (call when starting a new stream).
-   */
-  static resetCounters() {
-    patCc = 0;
-    pmtCc = 0;
-    videoCc = 0;
+    this.videoStreamType = options.videoType === "H265" ? STREAM_TYPE_H265 : STREAM_TYPE_H264;
+    this.includeAudio = options.includeAudio ?? true;
   }
   /**
-   * Mux a video frame into MPEG-TS packets.
+   * 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 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
+   * @param annexBData - Annex-B video data (with start codes)
+   * @param ptsUs      - Presentation timestamp in microseconds
+   * @param isKeyframe - Whether this is an IDR / IRAP 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);
+  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 an audio frame (ADTS AAC) into MPEG-TS packets.
+   * Returns an empty Buffer when includeAudio is false.
+   *
+   * @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;
   }
 };
 
@@ -16103,6 +16309,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) => {
@@ -18072,6 +18325,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;
   /**
@@ -18226,14 +18486,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",
@@ -18366,7 +18632,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;
@@ -18399,6 +18675,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
   // ─────────────────────────────────────────────────────────────────────────────
@@ -18825,6 +19109,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    */
   attachD2cDiscListener(client) {
     client.on("d2c_disc", () => this.notifyD2cDisc());
+    client.on("error", () => {
+    });
   }
   /**
    * Acquire a socket from the pool by tag.
@@ -18943,6 +19229,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) {
@@ -19458,6 +19749,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;
@@ -19899,6 +20191,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 () => {
@@ -23666,23 +23959,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()
         });
@@ -23705,6 +24007,7 @@ ${stderr}`)
       this.udpSleepInferenceInterval = void 0;
     }
     this.udpLastInferredSleepStateByChannel.clear();
+    this.udpPendingSleepStateByChannel.clear();
   }
   /**
    * GetEvents via Baichuan (legacy - use subscribeEvents for real-time events).
@@ -23871,6 +24174,7 @@ ${stderr}`)
           `${ch}:${profile}:${variant}`,
           frame.header.msgNum
         );
+        this.resetStreamTimeoutCounter(targetClient);
         return;
       } catch (error) {
         lastError = error;
@@ -23885,6 +24189,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));
   }
   /**
@@ -24344,6 +24652,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) {
@@ -24376,6 +24696,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.
    *
@@ -27249,8 +27606,8 @@ ${scheduleItems}
       );
       let args;
       if (useMpegTsMuxer) {
-        MpegTsMuxer.resetCounters();
-        tsMuxer = new MpegTsMuxer({ videoType });
+        tsMuxer = new MpegTsMuxer({ videoType, includeAudio: false });
+        tsMuxer.reset();
         args = [
           "-hide_banner",
           "-loglevel",
@@ -27414,7 +27771,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);
@@ -27703,8 +28060,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",
@@ -27869,7 +28226,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) {
@@ -33640,6 +33997,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   gracePeriodMs;
   prebufferMaxMs;
   maxBufferBytes;
+  streamTimeoutMs;
   prestartStream;
   active = false;
   server;
@@ -33653,8 +34011,16 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   connectedClients = /* @__PURE__ */ new Set();
   clientSockets = /* @__PURE__ */ new Map();
   stopGraceTimer;
+  // Stream health monitoring
+  lastFrameAt = 0;
+  streamHealthTimer;
+  totalFramesReceived = 0;
+  totalVideoFramesWritten = 0;
   // Prebuffer
   prebuffer = [];
+  // Audio metadata — populated on first valid ADTS AAC frame.
+  // Exposed via getAudioInfo() for the stream-diagnostics feature.
+  audioInfo = null;
   constructor(options) {
     super();
     this.api = options.api;
@@ -33668,6 +34034,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     this.gracePeriodMs = options.gracePeriodMs ?? 3e4;
     this.prebufferMaxMs = options.prebufferMs ?? 3e3;
     this.maxBufferBytes = options.maxBufferBytes ?? 1e8;
+    this.streamTimeoutMs = options.streamTimeoutMs ?? 15e3;
     this.prestartStream = options.prestartStream ?? true;
   }
   // -----------------------------------------------------------------------
@@ -33706,6 +34073,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     if (!this.active) return;
     this.active = false;
     clearTimeout(this.stopGraceTimer);
+    this.stopStreamHealthMonitor();
     for (const [id, sock] of this.clientSockets) {
       sock.destroy();
       this.connectedClients.delete(id);
@@ -33736,6 +34104,45 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     return this.connectedClients.size;
   }
   // -----------------------------------------------------------------------
+  // Diagnostic subscription API (implements DiagnosticStreamServer)
+  //
+  // Matches the shape of BaichuanRtspServer's diagnostic API so the
+  // stream-diagnostic feature in the Manager app can drive either backend
+  // with identical code.
+  // -----------------------------------------------------------------------
+  /**
+   * Subscribe to the raw native stream for diagnostic purposes.
+   * The subscriber receives the same frames the MPEG-TS muxer consumes
+   * (pre-muxing). Counts as a "consumer" so the native stream is kept alive
+   * for the lifetime of the subscription. If the stream is not already
+   * running (battery camera, prestart=false), this starts it.
+   */
+  async subscribeDiagnostic(id) {
+    this.connectedClients.add(`diag:${id}`);
+    if (!this.nativeStreamActive) {
+      await this.startNativeStream();
+    }
+    if (!this.nativeFanout) {
+      this.connectedClients.delete(`diag:${id}`);
+      throw new Error(
+        "Go2rtcTcpServer: native stream failed to start \u2014 cannot subscribe diagnostic"
+      );
+    }
+    return this.nativeFanout.subscribe(`diag:${id}`);
+  }
+  /** Unsubscribe a diagnostic session and release its consumer slot. */
+  unsubscribeDiagnostic(id) {
+    this.removeClient(`diag:${id}`, "diagnostic unsubscribe");
+  }
+  /**
+   * Returns ADTS AAC audio metadata detected from the native stream, or
+   * null if no audio frame has been observed yet (e.g. video-only cameras
+   * or before the first audio packet arrives).
+   */
+  getAudioInfo() {
+    return this.audioInfo;
+  }
+  // -----------------------------------------------------------------------
   // Client handling
   // -----------------------------------------------------------------------
   handleClient(socket) {
@@ -33759,12 +34166,12 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         `[Go2rtcTcpServer] feedClient error  id=${clientId}: ${err}`
       );
     });
-    const cleanup = () => {
-      this.removeClient(clientId);
+    const cleanup = (reason) => {
+      this.removeClient(clientId, reason);
       socket.destroy();
     };
-    socket.on("error", cleanup);
-    socket.on("close", cleanup);
+    socket.on("error", (err) => cleanup(`error: ${err.message}`));
+    socket.on("close", (hadError) => cleanup(hadError ? "close (with error)" : "close (clean)"));
   }
   async feedClient(clientId, socket) {
     const fanoutDeadline = Date.now() + 3e4;
@@ -33780,6 +34187,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     }
     if (!this.active || !this.nativeFanout) return;
     const subscription = this.nativeFanout.subscribe(clientId);
+    let muxer = null;
     const prebufferSnap = this.prebuffer.slice();
     let lastIdrIdx = -1;
     for (let i = prebufferSnap.length - 1; i >= 0; i--) {
@@ -33793,9 +34201,21 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
       this.logger.info?.(
         `[Go2rtcTcpServer] prebuffer replay  client=${clientId} frames=${replay.length}`
       );
+      if (!muxer) {
+        muxer = new MpegTsMuxer({
+          videoType: this.detectedVideoType ?? "H264",
+          includeAudio: true
+        });
+      }
       for (const entry of replay) {
         if (socket.destroyed) return;
-        socket.write(entry.data);
+        let ts;
+        if (!entry.audio) {
+          ts = muxer.muxVideo(entry.data, entry.pts, entry.isKeyframe);
+        } else {
+          ts = muxer.muxAudio(entry.data, entry.pts);
+        }
+        if (ts.length > 0) socket.write(ts);
       }
     }
     let seenKeyframe = lastIdrIdx >= 0;
@@ -33814,17 +34234,35 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
           break;
         }
         liveFrameCount++;
-        const annexB = this.convertFrame(frame);
+        if (frame.audio) {
+          if (muxer) {
+            const pts2 = frame.microseconds ?? Date.now() * 1e3;
+            const ts2 = muxer.muxAudio(frame.data, pts2);
+            if (ts2.length > 0) socket.write(ts2);
+          }
+          continue;
+        }
+        const annexB = this.convertVideoFrame(frame);
         if (!annexB) continue;
+        const isKf = this.isAnnexBKeyframe(annexB, frame.videoType);
         if (!seenKeyframe) {
-          if (!this.isAnnexBKeyframe(annexB, frame.videoType)) continue;
+          if (!isKf) continue;
           seenKeyframe = true;
           this.logger.info?.(
             `[Go2rtcTcpServer] first live keyframe  client=${clientId} after ${liveFrameCount} frames`
           );
+          if (!muxer) {
+            muxer = new MpegTsMuxer({
+              videoType: frame.videoType ?? this.detectedVideoType ?? "H264",
+              includeAudio: true
+            });
+          }
         }
-        socket.write(annexB);
+        const pts = frame.microseconds ?? Date.now() * 1e3;
+        const ts = muxer.muxVideo(annexB, pts, isKf);
+        socket.write(ts);
         liveVideoWritten++;
+        this.totalVideoFramesWritten++;
         if (Date.now() - lastLogAt > 1e4) {
           this.logger.info?.(
             `[Go2rtcTcpServer] live stats  client=${clientId} received=${liveFrameCount} written=${liveVideoWritten} bufLen=${socket.writableLength}`
@@ -33851,14 +34289,11 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
   // Frame conversion
   // -----------------------------------------------------------------------
   /**
-   * Convert a native frame to wire-ready Annex-B.
-   * Audio frames are skipped — raw TCP carries only video (Annex-B).
-   * go2rtc auto-detects the codec from SPS/PPS/VPS NALUs.
+   * Convert a native video frame to Annex-B.
+   * Returns null for audio frames (handled separately by muxAudio).
    */
-  convertFrame(frame) {
-    if (frame.audio) {
-      return null;
-    }
+  convertVideoFrame(frame) {
+    if (frame.audio) return null;
     if (frame.data.length === 0) return null;
     try {
       if (frame.videoType === "H264") {
@@ -33922,10 +34357,71 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     return nals;
   }
   // -----------------------------------------------------------------------
+  // ADTS AAC parsing (used for audio metadata exposed via getAudioInfo)
+  // -----------------------------------------------------------------------
+  /** True if `b` starts with an ADTS AAC syncword (0xFFF). */
+  static isAdtsAacFrame(b) {
+    return b.length >= 2 && b[0] === 255 && (b[1] & 240) === 240;
+  }
+  /**
+   * Parse an ADTS header into {sampleRate, channels, AudioSpecificConfig hex}.
+   * Returns null when the buffer is not a valid ADTS frame.
+   */
+  static parseAdtsSamplingInfo(b) {
+    if (b.length < 7) return null;
+    if (!_Go2rtcTcpServer.isAdtsAacFrame(b)) return null;
+    const samplingIndex = b[2] >> 2 & 15;
+    const sampleRates = [
+      96e3,
+      88200,
+      64e3,
+      48e3,
+      44100,
+      32e3,
+      24e3,
+      22050,
+      16e3,
+      12e3,
+      11025,
+      8e3,
+      7350
+    ];
+    const sampleRate = sampleRates[samplingIndex] ?? null;
+    if (!sampleRate) return null;
+    const channelConfig = (b[2] & 1) << 2 | b[3] >> 6 & 3;
+    const channels = channelConfig === 0 ? 1 : channelConfig;
+    const profile = b[2] >> 6 & 3;
+    const audioObjectType = profile + 1;
+    const asc = audioObjectType << 11 | samplingIndex << 7 | channelConfig << 3;
+    const configHex = Buffer.from([asc >> 8 & 255, asc & 255]).toString(
+      "hex"
+    );
+    return { sampleRate, channels, configHex };
+  }
+  // -----------------------------------------------------------------------
   // Native stream management
   // -----------------------------------------------------------------------
   async startNativeStream() {
     if (this.nativeStreamActive) return;
+    if (!this.api.isReady) {
+      if (this.api.isClosed) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] API has been explicitly closed \u2014 stream cannot start`
+        );
+        return;
+      }
+      try {
+        this.logger.info?.(
+          `[Go2rtcTcpServer] API not ready (idle disconnect?), calling ensureConnected`
+        );
+        await this.api.ensureConnected();
+      } catch (e) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] ensureConnected failed, aborting stream start: ${e}`
+        );
+        return;
+      }
+    }
     this.nativeStreamActive = true;
     let dedicatedClient;
     if (this.deviceId) {
@@ -33944,6 +34440,7 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     this.logger.info?.(
       `[Go2rtcTcpServer] native stream starting  channel=${this.channel} profile=${this.profile} dedicated=${!!dedicatedClient}`
     );
+    let hadFrames = false;
     this.nativeFanout = new NativeStreamFanout2({
       maxQueueItems: 200,
       createSource: () => createNativeStream(this.api, this.channel, this.profile, {
@@ -33951,17 +34448,37 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         ...dedicatedClient ? { client: dedicatedClient } : {}
       }),
       onFrame: (frame) => {
+        hadFrames = true;
+        this.lastFrameAt = Date.now();
+        this.totalFramesReceived++;
         if (!frame.audio && (frame.videoType === "H264" || frame.videoType === "H265")) {
           this.detectedVideoType = frame.videoType;
         }
-        const wireData = this.convertFrame(frame);
-        if (!wireData || wireData.length === 0) return;
-        const isKeyframe = !frame.audio && this.isAnnexBKeyframe(wireData, frame.videoType);
+        let prebufData;
+        let isKeyframe;
+        if (frame.audio) {
+          if (frame.data.length === 0) return;
+          if (!this.audioInfo) {
+            const parsed = _Go2rtcTcpServer.parseAdtsSamplingInfo(frame.data);
+            if (parsed) {
+              this.audioInfo = { codec: "aac-adts", ...parsed };
+            }
+          }
+          prebufData = frame.data;
+          isKeyframe = false;
+        } else {
+          const annexB = this.convertVideoFrame(frame);
+          if (!annexB || annexB.length === 0) return;
+          prebufData = annexB;
+          isKeyframe = this.isAnnexBKeyframe(annexB, frame.videoType);
+        }
+        const pts = frame.microseconds ?? Date.now() * 1e3;
         this.prebuffer.push({
-          data: Buffer.from(wireData),
+          data: Buffer.from(prebufData),
           time: Date.now(),
           isKeyframe,
-          audio: frame.audio
+          audio: frame.audio,
+          pts
         });
         const cutoff = Date.now() - this.prebufferMaxMs;
         let trimIdx = 0;
@@ -33977,23 +34494,47 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
         this.nativeFanout = null;
+        this.stopStreamHealthMonitor();
+        const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+        const diagnosis = silenceMs > this.streamTimeoutMs ? "camera stopped sending frames" : silenceMs >= 0 ? "stream source closed" : "no frames were ever received";
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] native stream ended  diagnosis="${diagnosis}" lastFrame=${silenceMs >= 0 ? `${(silenceMs / 1e3).toFixed(1)}s ago` : "never"} totalRx=${this.totalFramesReceived} clients=${this.connectedClients.size}`
+        );
         if (this.dedicatedSessionRelease) {
           this.dedicatedSessionRelease().catch(() => {
           });
           this.dedicatedSessionRelease = void 0;
         }
-        if (this.active && (this.connectedClients.size > 0 || this.prestartStream)) {
+        if (!this.prestartStream) {
+          this.logger.info?.(
+            `[Go2rtcTcpServer] battery native stream ended  hadFrames=${hadFrames} channel=${this.channel} profile=${this.profile} \u2014 dropping ${this.connectedClients.size} client(s) to prevent wake loop`
+          );
+          for (const [, sock] of this.clientSockets) {
+            sock.destroy();
+          }
+        } else if (this.active) {
+          if (typeof this.api.isStreamProfileRejected === "function" && this.api.isStreamProfileRejected(this.channel, this.profile)) {
+            this.logger.warn?.(
+              `[Go2rtcTcpServer] profile rejected by device  channel=${this.channel} profile=${this.profile} \u2014 not restarting`
+            );
+            for (const [, sock] of this.clientSockets) {
+              sock.destroy();
+            }
+            return;
+          }
           this.logger.info?.(
-            `[Go2rtcTcpServer] native stream ended, restarting (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
+            `[Go2rtcTcpServer] restarting native stream (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
           );
           this.startNativeStream();
         }
       }
     });
     this.nativeFanout.start();
+    this.startStreamHealthMonitor();
   }
   async stopNativeStream() {
     this.nativeStreamActive = false;
+    this.stopStreamHealthMonitor();
     const fanout = this.nativeFanout;
     this.nativeFanout = null;
     if (fanout) {
@@ -34007,14 +34548,50 @@ var Go2rtcTcpServer = class _Go2rtcTcpServer extends import_node_events6.EventEm
     }
   }
   // -----------------------------------------------------------------------
+  // Stream health monitoring
+  // -----------------------------------------------------------------------
+  startStreamHealthMonitor() {
+    this.stopStreamHealthMonitor();
+    if (this.streamTimeoutMs <= 0) return;
+    this.lastFrameAt = Date.now();
+    this.streamHealthTimer = setInterval(() => {
+      if (!this.nativeStreamActive || !this.active) {
+        this.stopStreamHealthMonitor();
+        return;
+      }
+      const silenceMs = Date.now() - this.lastFrameAt;
+      if (silenceMs > this.streamTimeoutMs) {
+        this.logger.warn?.(
+          `[Go2rtcTcpServer] stream inactivity timeout: no frames for ${(silenceMs / 1e3).toFixed(1)}s (threshold=${this.streamTimeoutMs}ms), totalReceived=${this.totalFramesReceived} clients=${this.connectedClients.size} \u2014 forcing stream restart`
+        );
+        this.stopStreamHealthMonitor();
+        const fanout = this.nativeFanout;
+        if (fanout) {
+          this.nativeStreamActive = false;
+          this.nativeFanout = null;
+          fanout.stop().catch(() => {
+          });
+        }
+      }
+    }, Math.min(this.streamTimeoutMs / 2, 5e3));
+  }
+  stopStreamHealthMonitor() {
+    if (this.streamHealthTimer) {
+      clearInterval(this.streamHealthTimer);
+      this.streamHealthTimer = void 0;
+    }
+  }
+  // -----------------------------------------------------------------------
   // Client lifecycle
   // -----------------------------------------------------------------------
-  removeClient(clientId) {
+  removeClient(clientId, reason) {
     if (!this.connectedClients.has(clientId)) return;
     this.connectedClients.delete(clientId);
     this.clientSockets.delete(clientId);
+    const silenceMs = this.lastFrameAt > 0 ? Date.now() - this.lastFrameAt : -1;
+    const silenceInfo = silenceMs >= 0 ? ` lastFrame=${(silenceMs / 1e3).toFixed(1)}s ago` : "";
     this.logger.info?.(
-      `[Go2rtcTcpServer] client disconnected  id=${clientId} remaining=${this.connectedClients.size}`
+      `[Go2rtcTcpServer] client disconnected  id=${clientId} reason=${reason ?? "unknown"}  remaining=${this.connectedClients.size}  totalRx=${this.totalFramesReceived} totalTx=${this.totalVideoFramesWritten}${silenceInfo}`
     );
     this.emit("clientDisconnected", clientId);
     if (this.connectedClients.size === 0 && !this.prestartStream) {
@@ -36349,16 +36926,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);
     });
@@ -36440,9 +37017,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}...`);
@@ -36451,7 +37029,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)" : ""}`
         );
@@ -36461,6 +37039,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);
@@ -36490,9 +37093,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})`,
@@ -36515,11 +37118,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;
@@ -36558,14 +37164,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;
@@ -36618,54 +37218,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;
@@ -36757,9 +37360,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;
@@ -36803,21 +37408,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();
@@ -36832,20 +37433,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?.(
@@ -37210,6 +37803,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   HlsSessionManager,
   Intercom,
   MjpegTransformer,
+  MpegTsMuxer,
   NVR_HUB_EXACT_TYPES,
   NVR_HUB_MODEL_PATTERNS,
   ReolinkBaichuanApi,
@@ -37268,6 +37862,7 @@ var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   createRfc4571TcpServerForReplay,
   createRtspProxyServer,
   createTaggedLogger,
+  decideSleepInferenceTransition,
   decideVideoclipTranscodeMode,
   decodeHeader,
   deriveAesKey,