@apocaliss92/nodelink-js 0.4.7 → 0.4.10

package/dist/{chunk-GKLOJJ34.js → chunk-HGQ53FB3.js}

@@ -31,6 +31,7 @@ import {
   BC_CMD_ID_GET_AUDIO_ALARM,
   BC_CMD_ID_GET_AUDIO_CFG,
   BC_CMD_ID_GET_AUDIO_TASK,
+  BC_CMD_ID_GET_AUTO_FOCUS,
   BC_CMD_ID_GET_BATTERY_INFO,
   BC_CMD_ID_GET_BATTERY_INFO_LIST,
   BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
@@ -39,6 +40,7 @@ import {
   BC_CMD_ID_GET_DING_DONG_LIST,
   BC_CMD_ID_GET_DING_DONG_SILENT,
   BC_CMD_ID_GET_EMAIL_TASK,
+  BC_CMD_ID_GET_ENC,
   BC_CMD_ID_GET_FTP_TASK,
   BC_CMD_ID_GET_HDD_INFO_LIST,
   BC_CMD_ID_GET_KIT_AP_CFG,
@@ -47,6 +49,7 @@ import {
   BC_CMD_ID_GET_ONLINE_USER_LIST,
   BC_CMD_ID_GET_OSD_DATETIME,
   BC_CMD_ID_GET_PIR_INFO,
+  BC_CMD_ID_GET_PRIVACY_MASK,
   BC_CMD_ID_GET_PTZ_POSITION,
   BC_CMD_ID_GET_PTZ_PRESET,
   BC_CMD_ID_GET_RECORD,
@@ -76,11 +79,19 @@ import {
   BC_CMD_ID_QUICK_REPLY_PLAY,
   BC_CMD_ID_SET_AI_ALARM,
   BC_CMD_ID_SET_AI_CFG,
+  BC_CMD_ID_SET_AI_DENOISE,
+  BC_CMD_ID_SET_AUDIO_CFG,
   BC_CMD_ID_SET_AUDIO_TASK,
+  BC_CMD_ID_SET_AUTO_FOCUS,
+  BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD,
   BC_CMD_ID_SET_DING_DONG_CFG,
   BC_CMD_ID_SET_DING_DONG_SILENT,
+  BC_CMD_ID_SET_ENC,
+  BC_CMD_ID_SET_LED_STATE,
   BC_CMD_ID_SET_MOTION_ALARM,
   BC_CMD_ID_SET_PIR_INFO,
+  BC_CMD_ID_SET_PRIVACY_MASK,
+  BC_CMD_ID_SET_VIDEO_INPUT,
   BC_CMD_ID_SET_WHITE_LED_STATE,
   BC_CMD_ID_SET_WHITE_LED_TASK,
   BC_CMD_ID_SET_ZOOM_FOCUS,
@@ -102,6 +113,8 @@ import {
   __require,
   aesDecrypt,
   aesEncrypt,
+  applyStreamPatch,
+  applyXmlTagPatch,
   bcDecrypt,
   bcEncrypt,
   bcHeaderHasPayloadOffset,
@@ -127,6 +140,7 @@ import {
   convertToAnnexB2,
   debugLog,
   deriveAesKey,
+  ensureXmlHeader,
   eventTraceLog,
   extractPpsFromAnnexB,
   extractSpsFromAnnexB,
@@ -134,8 +148,11 @@ import {
   getXmlText,
   isH265Irap,
   md5StrModern,
+  normalizeDayNightMode,
   normalizeDebugOptions,
+  normalizeOpenClose,
   parseRecordingFileName,
+  patchNestedTag,
   recordingsTraceLog,
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
@@ -144,7 +161,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-TR3V5FTO.js";
+} from "./chunk-EDLMKBG2.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -5325,19 +5342,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 });
+            }
+          }
         });
       }
     }
@@ -5513,13 +5545,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) {
@@ -5565,6 +5598,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 {
@@ -5603,9 +5637,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   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)
@@ -5617,8 +5652,15 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   // 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;
@@ -5640,10 +5682,20 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   // 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
@@ -5769,14 +5821,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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
@@ -5837,9 +5900,16 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       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) {
@@ -5868,6 +5938,12 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       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();
@@ -5882,25 +5958,31 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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) => {
@@ -5941,6 +6023,30 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     }
     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.
    */
@@ -6105,6 +6211,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             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) {
@@ -6142,6 +6252,27 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
               }
             }
           }
+          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;
@@ -6150,12 +6281,13 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             );
           }
           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
           );
@@ -6178,7 +6310,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
           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();
@@ -6312,12 +6444,23 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
         }
       }
     };
+    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();
     }
   }
   /**
@@ -7185,6 +7328,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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;
@@ -7219,13 +7381,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     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;
@@ -7274,6 +7437,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       onEnd: () => {
         if (!this.nativeStreamActive) return;
         this.nativeStreamActive = false;
+        this.clearNoFrameDeadlineTimer();
+        const hadFrames = this.firstFrameReceived;
         this.firstFrameReceived = false;
         this.firstFramePromise = null;
         this.firstFrameResolve = null;
@@ -7298,7 +7463,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
             } 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)`
             );
@@ -7310,6 +7475,19 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
       }
     });
     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(() => {
@@ -7326,6 +7504,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   markFirstFrameReceived() {
     if (!this.firstFrameReceived && this.firstFrameResolve) {
       this.firstFrameReceived = true;
+      this.clearNoFrameDeadlineTimer();
       this.rtspDebugLog(
         `First frame received from camera for profile ${this.profile}`
       );
@@ -7352,6 +7531,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
     );
     this.flow.stopKeepAlive();
     this.clearNoClientAutoStopTimer();
+    this.clearNoFrameDeadlineTimer();
     this.nativeStreamActive = false;
     this.firstFrameReceived = false;
     this.firstFramePromise = null;
@@ -7561,6 +7741,249 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter3 {
   }
 };
 
+// src/baichuan/stream/MpegTsMuxer.ts
+var TS_PACKET_SIZE = 188;
+var TS_SYNC_BYTE = 71;
+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 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++) {
+    crc ^= data[i] << 24;
+    for (let j = 0; j < 8; j++) {
+      if (crc & 2147483648) {
+        crc = (crc << 1 ^ 79764919) >>> 0;
+      } else {
+        crc = crc << 1 >>> 0;
+      }
+    }
+  }
+  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 {
+  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.videoStreamType = options.videoType === "H265" ? STREAM_TYPE_H265 : STREAM_TYPE_H264;
+    this.includeAudio = options.includeAudio ?? true;
+  }
+  /**
+   * 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
+   */
+  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;
+  }
+};
+
 // src/reolink/baichuan/capabilities.ts
 function toNumberOrUndefined(value) {
   if (value == null) return void 0;
@@ -7774,214 +8197,59 @@ function xmlIndicatesFloodlight(xml) {
   return false;
 }
 
+// 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/ReolinkBaichuanApi.ts
 import { spawn as spawn2 } from "child_process";
 import { mkdir } from "fs/promises";
 import { dirname } from "path";
 import { PassThrough } from "stream";
 
-// 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 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;
-}
-function crc32Mpeg(data) {
-  let crc = 4294967295;
-  for (let i = 0; i < data.length; i++) {
-    crc ^= data[i] << 24;
-    for (let j = 0; j < 8; j++) {
-      if (crc & 2147483648) {
-        crc = (crc << 1 ^ 79764919) >>> 0;
-      } else {
-        crc = crc << 1 >>> 0;
-      }
-    }
-  }
-  return crc >>> 0;
-}
-var MpegTsMuxer = class {
-  streamType;
-  patSent = false;
-  pmtSent = false;
-  patPmtInterval = 0;
-  patPmtIntervalMax = 40;
-  // Send PAT/PMT every ~40 frames
-  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;
-  }
-  /**
-   * Mux a video frame into MPEG-TS packets.
-   *
-   * @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);
-  }
-};
-
 // src/reolink/baichuan/utils/xml.ts
 import { XMLParser } from "fast-xml-parser";
 var parser = new XMLParser({
@@ -10437,7 +10705,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;
@@ -10904,6 +11182,8 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    */
   attachD2cDiscListener(client) {
     client.on("d2c_disc", () => this.notifyD2cDisc());
+    client.on("error", () => {
+    });
   }
   /**
    * Acquire a socket from the pool by tag.
@@ -11022,6 +11302,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) {
@@ -11537,6 +11822,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;
@@ -11978,6 +12264,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 () => {
@@ -15745,23 +16032,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()
         });
@@ -15784,6 +16080,7 @@ ${stderr}`)
       this.udpSleepInferenceInterval = void 0;
     }
     this.udpLastInferredSleepStateByChannel.clear();
+    this.udpPendingSleepStateByChannel.clear();
   }
   /**
    * GetEvents via Baichuan (legacy - use subscribeEvents for real-time events).
@@ -18180,7 +18477,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-UMN4C7SY.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-RNIDFEJK.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -18196,7 +18493,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-UMN4C7SY.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-RNIDFEJK.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -18214,6 +18511,373 @@ ${xml}`
     await this.cgiApi.login();
     return await this.cgiApi.getAllChannelsEvents(options);
   }
+  // ====================================================================
+  // Native Baichuan tunable-settings setters
+  //
+  // Replace the CGI passthroughs above with on-wire Baichuan binary
+  // calls. Mirrors the @http_cmd-decorated methods in reolink_aio's
+  // baichuan.py — every command has a documented `cmd_id` (read) and
+  // `cmd_id` (write) pair. The pattern is:
+  //
+  //   1. read XML via `sendXml({ cmdId: GET, channel })`
+  //   2. patch fields via regex (camera firmware is XML-strict; using
+  //      the parser would force us to rebuild the document and risk
+  //      losing unmodified attributes / element order).
+  //   3. write back via `sendXml({ cmdId: SET, channel, payloadXml })`
+  //
+  // All getters parse via `parseXmlFragmentToJson` so the consumer gets
+  // a clean JSON object instead of XML.
+  // ====================================================================
+  /**
+   * GetEnc via Baichuan (cmdId=56). Returns the `<Compression>` block:
+   * per-stream `mainStream` / `subStream` / `thirdStream` with `audio`
+   * flag, `width`, `height`, `frame` (NOT `frameRate`), `bitRate`,
+   * `videoEncType` (0=h264, 1=h265), `encoderProfile`, `gop`. Mirrors
+   * reolink_aio's `GetEnc` — note the wire payload wraps everything
+   * in `Compression`, not `Enc`.
+   */
+  async getEnc(channel, options) {
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_ENC,
+      ...channel != null ? { channel } : {},
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseXmlFragmentToJson(xml);
+  }
+  /**
+   * SetEnc via Baichuan (cmdId=57). Read-modify-write — preserves
+   * unspecified fields. Mirrors reolink_aio's `SetEnc`.
+   *
+   * @param channel - Channel number (0-based)
+   * @param patch - Fields to update on `mainStream` and/or `subStream`,
+   *   plus a top-level `audio` toggle (0/1). Pass only what you want
+   *   to change.
+   */
+  async setEnc(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_ENC,
+      channel: ch,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    if (patch.audio !== void 0) {
+      xml = xml.replace(
+        /<audio>[^<]*<\/audio>/g,
+        `<audio>${patch.audio}</audio>`
+      );
+    }
+    xml = applyStreamPatch(xml, "mainStream", patch.mainStream);
+    xml = applyStreamPatch(xml, "subStream", patch.subStream);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_ENC,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * SetImage via Baichuan (cmdId=25, read via cmdId=26). Patches the
+   * `<VideoInput>` block: bright / contrast / saturation / hue /
+   * sharpen. Mirrors reolink_aio's `SetImage`.
+   */
+  async setImage(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_VIDEO_INPUT,
+      channel: ch,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    xml = applyXmlTagPatch(xml, "bright", patch.bright);
+    xml = applyXmlTagPatch(xml, "contrast", patch.contrast);
+    xml = applyXmlTagPatch(xml, "saturation", patch.saturation);
+    xml = applyXmlTagPatch(xml, "hue", patch.hue);
+    xml = applyXmlTagPatch(xml, "sharpen", patch.sharpen);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_VIDEO_INPUT,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
+  /**
+   * SetIsp via Baichuan (cmdId=25 for image side, cmdId=297 for
+   * dayNightThreshold). Patches the `<InputAdvanceCfg>` block:
+   * `DayNight/mode`, `Exposure/mode`, `binning_mode`, `hdrSwitch`.
+   * Mirrors reolink_aio's `SetIsp`.
+   *
+   * @param channel - Channel number (0-based)
+   * @param patch - Fields to update. `dayNight` accepts the camera's
+   *   raw enum (`color`, `auto`, `blackAndWhite`, …) — pass it as the
+   *   camera reports it (PascalCase / dotted forms get normalized
+   *   server-side).
+   */
+  async setIsp(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    const wantsImageWrite = patch.dayNight !== void 0 || patch.exposure !== void 0 || patch.binningMode !== void 0 || patch.hdr !== void 0;
+    if (wantsImageWrite) {
+      let xml = await this.sendXml({
+        cmdId: BC_CMD_ID_GET_VIDEO_INPUT,
+        channel: ch,
+        ...timeoutOpts
+      });
+      if (patch.dayNight !== void 0) {
+        const normalized = normalizeDayNightMode(patch.dayNight);
+        xml = patchNestedTag(xml, "DayNight", "mode", normalized);
+      }
+      if (patch.exposure !== void 0) {
+        xml = patchNestedTag(
+          xml,
+          "Exposure",
+          "mode",
+          patch.exposure.toLowerCase()
+        );
+      }
+      if (patch.binningMode !== void 0) {
+        xml = applyXmlTagPatch(xml, "binning_mode", patch.binningMode);
+      }
+      if (patch.hdr !== void 0) {
+        xml = applyXmlTagPatch(xml, "hdrSwitch", patch.hdr);
+      }
+      await this.sendXml({
+        cmdId: BC_CMD_ID_SET_VIDEO_INPUT,
+        channel: ch,
+        payloadXml: ensureXmlHeader(xml),
+        ...timeoutOpts
+      });
+    }
+    if (patch.dayNightThreshold !== void 0) {
+      let xml = await this.sendXml({
+        cmdId: BC_CMD_ID_GET_DAY_NIGHT_THRESHOLD,
+        channel: ch,
+        ...timeoutOpts
+      });
+      xml = applyXmlTagPatch(xml, "cur", patch.dayNightThreshold);
+      await this.sendXml({
+        cmdId: BC_CMD_ID_SET_DAY_NIGHT_THRESHOLD,
+        channel: ch,
+        payloadXml: ensureXmlHeader(xml),
+        ...timeoutOpts
+      });
+    }
+  }
+  /**
+   * GetIsp via Baichuan (cmdId=26). Convenience alias of
+   * `getVideoInput()` so callers that switched from CGI keep the
+   * familiar name. Both return the merged VideoInput +
+   * InputAdvanceCfg blob.
+   */
+  async getIsp(channel, options) {
+    return this.getVideoInput(channel, options);
+  }
+  /** GetImage via Baichuan (cmdId=26). Same payload as `getIsp` —
+   *  Reolink merged VideoInput + InputAdvanceCfg under one cmdId. */
+  async getImage(channel, options) {
+    return this.getVideoInput(channel, options);
+  }
+  /**
+   * GetIrLights via Baichuan (cmdId=208). Returns LedState block:
+   * `IRLedBrightness`, `state` (ir on/off), `lightState` (status LED
+   * open/close), `doorbellLightState`. Mirrors reolink_aio's
+   * `get_status_led`.
+   */
+  async getIrLights(channel, options) {
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_LED_STATE,
+      ...channel != null ? { channel } : {},
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseXmlFragmentToJson(xml);
+  }
+  /**
+   * SetIrLights via Baichuan (cmdId=209, read via cmdId=208). Patches
+   * IR LED + status LED + doorbell LED + IR brightness. Mirrors
+   * reolink_aio's `set_status_led`.
+   *
+   * @param channel - Channel number (0-based)
+   * @param patch - `irState` ("On" | "Off" | "Auto"), `lightState`
+   *   (status LED), `doorbellLightState`, `irBrightness` (0..255).
+   *   Camera-side accepts lowercase strings (`open`/`close`); the
+   *   helper normalizes from the friendly variants.
+   */
+  async setIrLights(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_LED_STATE,
+      channel: ch,
+      ...timeoutOpts
+    });
+    if (patch.lightState !== void 0) {
+      xml = applyXmlTagPatch(
+        xml,
+        "lightState",
+        patch.lightState === "On" ? "open" : "close"
+      );
+    }
+    if (patch.doorbellLightState !== void 0) {
+      xml = applyXmlTagPatch(
+        xml,
+        "doorbellLightState",
+        normalizeOpenClose(patch.doorbellLightState)
+      );
+    }
+    if (patch.irState !== void 0) {
+      const v = String(patch.irState);
+      const out = v === "Off" ? "close" : v.toLowerCase();
+      xml = applyXmlTagPatch(xml, "state", out);
+    }
+    if (patch.irBrightness !== void 0) {
+      xml = applyXmlTagPatch(xml, "IRLedBrightness", patch.irBrightness);
+    }
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_LED_STATE,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...timeoutOpts
+    });
+  }
+  /**
+   * SetAudioCfg via Baichuan (cmdId=265, read via cmdId=264). Patches
+   * volume / talk-and-reply / visitor settings. Mirrors reolink_aio's
+   * `SetAudioCfg`.
+   */
+  async setAudioCfg(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_AUDIO_CFG,
+      channel: ch,
+      ...timeoutOpts
+    });
+    xml = applyXmlTagPatch(xml, "volume", patch.volume);
+    xml = applyXmlTagPatch(
+      xml,
+      "talkAndReplyVolume",
+      patch.talkAndReplyVolume
+    );
+    xml = applyXmlTagPatch(xml, "visitorVolume", patch.visitorVolume);
+    xml = applyXmlTagPatch(xml, "visitorLoudspeaker", patch.visitorLoudspeaker);
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_AUDIO_CFG,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...timeoutOpts
+    });
+  }
+  /**
+   * GetMask (privacy mask) via Baichuan (cmdId=52). Returns the
+   * `<Shelter>` block — `enable` flag + `shelterList`. Mirrors
+   * reolink_aio's `GetMask`.
+   */
+  async getMask(channel, options) {
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_PRIVACY_MASK,
+      ...channel != null ? { channel } : {},
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseXmlFragmentToJson(xml);
+  }
+  /**
+   * SetMask (privacy mask) via Baichuan (cmdId=53, read via cmdId=52).
+   * Toggles the `<Shelter><enable>` flag. Mirrors reolink_aio's
+   * `SetMask` (which only touches enable too — shelter zone editing
+   * goes through a separate flow).
+   */
+  async setMask(channel, patch, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_PRIVACY_MASK,
+      channel: ch,
+      ...timeoutOpts
+    });
+    if (patch.enable !== void 0) {
+      xml = applyXmlTagPatch(xml, "enable", patch.enable ? 1 : 0);
+    }
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_PRIVACY_MASK,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...timeoutOpts
+    });
+  }
+  /**
+   * GetAudioNoise via Baichuan (cmdId=439). Reads `enable` + `level`
+   * from the aiDenoise block. Mirrors reolink_aio's `GetAudioNoise`.
+   *
+   * Note: `getAiDenoise` already returns the same payload typed as
+   * `AiDenoiseConfig`. This getter exists for naming parity with
+   * reolink_aio + the reolink CGI.
+   */
+  async getAudioNoise(channel, options) {
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_AI_DENOISE,
+      ...channel != null ? { channel } : {},
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseXmlFragmentToJson(xml);
+  }
+  /**
+   * SetAudioNoise via Baichuan (cmdId=440, read via cmdId=439).
+   * Mirrors reolink_aio's `SetAudioNoise` — `level <= 0` flips the
+   * enable flag off; positive values turn it on and update the level.
+   */
+  async setAudioNoise(channel, level, options) {
+    const ch = this.normalizeChannel(channel);
+    const timeoutOpts = options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {};
+    let xml = await this.sendXml({
+      cmdId: BC_CMD_ID_GET_AI_DENOISE,
+      channel: ch,
+      ...timeoutOpts
+    });
+    xml = applyXmlTagPatch(xml, "enable", level > 0 ? 1 : 0);
+    if (level > 0) {
+      xml = applyXmlTagPatch(xml, "level", level);
+    }
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_AI_DENOISE,
+      channel: ch,
+      payloadXml: ensureXmlHeader(xml),
+      ...timeoutOpts
+    });
+  }
+  /**
+   * GetAutoFocus via Baichuan (cmdId=224). Returns the `<AutoFocus>`
+   * block — only `disable` (0 = AF on, 1 = AF off). Mirrors
+   * reolink_aio's `GetAutoFocus`.
+   */
+  async getAutoFocus(channel, options) {
+    const ch = this.normalizeChannel(channel);
+    const xml = await this.sendPcapDerivedSettingsGetXml({
+      cmdId: BC_CMD_ID_GET_AUTO_FOCUS,
+      channel: ch,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+    return parseXmlFragmentToJson(xml);
+  }
+  /**
+   * SetAutoFocus via Baichuan (cmdId=225). Mirrors reolink_aio's
+   * `SetAutoFocus`. Note: write-only command — the payload is built
+   * from scratch (no read-modify-write needed).
+   */
+  async setAutoFocus(channel, disable, options) {
+    const ch = this.normalizeChannel(channel);
+    const disableVal = disable ? 1 : 0;
+    const payloadXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<body>
+<AutoFocus version="1.1">
+<channelId>${ch}</channelId>
+<disable>${disableVal}</disable>
+</AutoFocus>
+</body>`;
+    await this.sendXml({
+      cmdId: BC_CMD_ID_SET_AUTO_FOCUS,
+      channel: ch,
+      payloadXml,
+      ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
+    });
+  }
   /**
    * Passthrough to ReolinkCgiApi.getAllChannelsBatteryInfo.
    * Fetches battery info for all channels via CGI (merged with channel status sleep flag).
@@ -19382,8 +20046,8 @@ ${scheduleItems}
       );
       let args;
       if (useMpegTsMuxer) {
-        MpegTsMuxer.resetCounters();
-        tsMuxer = new MpegTsMuxer({ videoType });
+        tsMuxer = new MpegTsMuxer({ videoType, includeAudio: false });
+        tsMuxer.reset();
         args = [
           "-hide_banner",
           "-loglevel",
@@ -19547,7 +20211,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);
@@ -19836,8 +20500,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",
@@ -20002,7 +20666,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) {
@@ -21414,9 +22078,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}...`);
@@ -21425,7 +22090,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)" : ""}`
         );
@@ -21435,6 +22100,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);
@@ -21464,9 +22154,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})`,
@@ -21489,11 +22179,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;
@@ -21532,14 +22225,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;
@@ -21592,54 +22279,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;
@@ -21731,9 +22421,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;
@@ -21777,21 +22469,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();
@@ -21806,20 +22494,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?.(
@@ -21851,12 +22531,14 @@ export {
   BaichuanEventEmitter,
   createNativeStream,
   BaichuanRtspServer,
+  MpegTsMuxer,
   flattenAbilitiesForChannel,
   abilitiesHasAny,
   parseSupportXml,
   getSupportItemForChannel,
   computeDeviceCapabilities,
   xmlIndicatesFloodlight,
+  decideSleepInferenceTransition,
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
   DUAL_LENS_MODELS,
@@ -21878,4 +22560,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-GKLOJJ34.js.map
+//# sourceMappingURL=chunk-HGQ53FB3.js.map