@apocaliss92/nodelink-js 0.6.7 → 0.6.8-beta.0

package/dist/{chunk-T22QCNBR.js → chunk-OJ4YR45R.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-IQVVVSXO.js";
+} from "./chunk-27ZKJZFH.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -178,7 +178,7 @@ import {
   splitAnnexBToNalPayloads2,
   talkTraceLog,
   traceLog
-} from "./chunk-MZUSWKF3.js";
+} from "./chunk-4LZABN6I.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -2473,6 +2473,16 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   // Public to allow ReolinkBaichuanApi to check subscription status
   keepAliveTimer;
   keepAlivePingInFlight = false;
+  // Consecutive TCP keepalive (PING) failures with no response. A half-open
+  // socket after a camera reboot is NOT reported as `destroyed`, so
+  // `isSocketConnected()` stays stale-true and recovery never triggers. We
+  // treat repeated unanswered pings as a hard liveness failure and tear the
+  // socket down so the 'close' handler fires (resetting loggedIn/subscribed
+  // and emitting "close"), which lets ensureConnected() rebuild it.
+  consecutiveKeepalivePingFailures = 0;
+  // Number of unanswered keepalive pings tolerated before the TCP socket is
+  // declared dead. 2 misses ≈ up to ~2 keepalive intervals of silence.
+  static KEEPALIVE_MAX_PING_FAILURES = 2;
   // Battery/BCUDP cameras may actively terminate sessions (D2C_DISC) when overwhelmed
   // or sleeping. Without a cooldown, callers can end up in tight reconnect loops.
   udpReconnectCooldownUntilMs = 0;
@@ -3101,8 +3111,21 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
         // Keepalive has empty body
         internal: true
       });
+      this.consecutiveKeepalivePingFailures = 0;
     } catch (e) {
-      this.logDebug("keepalive_ping_failed", e);
+      this.consecutiveKeepalivePingFailures++;
+      this.logDebug("keepalive_ping_failed", {
+        error: e,
+        consecutiveFailures: this.consecutiveKeepalivePingFailures
+      });
+      if (this.transport === "tcp" && this.consecutiveKeepalivePingFailures >= _BaichuanClient.KEEPALIVE_MAX_PING_FAILURES && this.tcpSocket && !this.tcpSocket.destroyed) {
+        this.logFixed(
+          "keepalive_dead",
+          `transport=tcp host=${this.opts.host} consecutiveFailures=${this.consecutiveKeepalivePingFailures} \u2014 destroying half-open socket`
+        );
+        this.consecutiveKeepalivePingFailures = 0;
+        this.tcpSocket.destroy();
+      }
     }
   }
   async connect() {
@@ -3195,6 +3218,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     this.tcpSocket = sock;
     this.transport = "tcp";
     this.socketClosed = false;
+    this.consecutiveKeepalivePingFailures = 0;
     this.socketSessionId = this.newSocketSessionId("tcp");
     try {
       sock.setKeepAlive(true, 3e4);
@@ -6676,6 +6700,20 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter4 {
   // from the last IDR in the prebuffer immediately.
   PREBUFFER_MAX_MS = 3e3;
   prebuffer = [];
+  /**
+   * Hard cap on the userspace TCP send buffer for a single RTSP client. A
+   * healthy consumer drains near-instantly; if this much data backs up the
+   * client is dead or far too slow to keep up with the live stream.
+   */
+  static MAX_CLIENT_BUFFERED_BYTES = 8 * 1024 * 1024;
+  /**
+   * Pure backpressure decision: should the client socket be disconnected
+   * because its send buffer has grown past the hard cap? Extracted so the
+   * decision can be unit-tested without a live socket.
+   */
+  static shouldDisconnectForBackpressure(bufferedBytes) {
+    return bufferedBytes > _BaichuanRtspServer.MAX_CLIENT_BUFFERED_BYTES;
+  }
   static isAdtsAacFrame(b) {
     return b.length >= 2 && b[0] === 255 && (b[1] & 240) === 240;
   }
@@ -7652,14 +7690,36 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter4 {
     const rtspDebugLog = (message) => this.rtspDebugLog(message);
     const sendInterleaved = (channel, msg) => {
       if (!rtspSocket || rtspSocket.destroyed || !rtspSocket.writable)
-        return false;
+        return true;
+      if (_BaichuanRtspServer.shouldDisconnectForBackpressure(
+        rtspSocket.writableLength
+      )) {
+        this.logger.warn(
+          `[rebroadcast] backpressure: ${Math.round(rtspSocket.writableLength / 1024)}KB buffered for client=${clientId} \u2014 disconnecting`
+        );
+        rtspSocket.destroy();
+        return true;
+      }
       try {
         return rtspSocket.write(frameRtpOverTcp(channel, msg));
       } catch (error) {
         if (error && typeof error === "object" && "code" in error && error.code === "EPIPE")
-          return false;
+          return true;
       }
-      return false;
+      return true;
+    };
+    const awaitClientDrain = async () => {
+      if (!rtspSocket || rtspSocket.destroyed) return;
+      if (!rtspSocket.writableNeedDrain) return;
+      await new Promise((resolve) => {
+        const done = () => {
+          rtspSocket.removeListener("drain", done);
+          rtspSocket.removeListener("close", done);
+          resolve();
+        };
+        rtspSocket.once("drain", done);
+        rtspSocket.once("close", done);
+      });
     };
     const getVideoChannel = () => resources?.track0RtpChannel ?? 0;
     const getAudioChannel = () => resources?.track1RtpChannel ?? 2;
@@ -8238,6 +8298,7 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends EventEmitter4 {
               resources.framesSent = (resources.framesSent ?? 0) + 1;
             }
             sendVideoAccessUnit(videoType, normalizedVideoData, true);
+            await awaitClientDrain();
           } else {
             try {
               if (stdin && !stdin.destroyed && !stdin.writableEnded && !stdin.writableFinished) {
@@ -14528,7 +14589,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       return;
     }
     entry.startInFlight = (async () => {
-      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-OCLOM452.js");
+      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-6Y2JSBLN.js");
       const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
       const dedicated = await this.createDedicatedSession(sessionKey);
       const stream = new BaichuanVideoStream2({
@@ -14679,9 +14740,45 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const generalEntry = this.socketPool.get("general");
     if (!generalEntry) return;
     if (!generalEntry.client.isSocketConnected?.() || !generalEntry.client.loggedIn) {
-      this.logger.debug?.(
-        `[ReolinkBaichuanApi] event watchdog tick: skipping (connection not alive: connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+      if (!this.eventWatchdogSilenceResubscribeEnabled) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] event watchdog tick: skipping (connection not alive, battery/UDP \u2014 not forcing reconnect: connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+        );
+        return;
+      }
+      const now2 = Date.now();
+      const backoffMs = Math.min(
+        3e4 * Math.pow(2, this.simpleEventWatchdogRecoveryAttempts),
+        this.simpleEventWatchdogSilenceThresholdMs
+      );
+      if (now2 - this.simpleEventWatchdogLastRecoveryAt < backoffMs) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] event watchdog tick: connection down, reconnect backoff active (connected=${generalEntry.client.isSocketConnected?.()} loggedIn=${generalEntry.client.loggedIn})`
+        );
+        return;
+      }
+      this.simpleEventWatchdogRecoveryAttempts++;
+      this.simpleEventWatchdogLastRecoveryAt = now2;
+      (this.logger.info ?? this.logger.log).call(
+        this.logger,
+        `[ReolinkBaichuanApi] event watchdog: control socket down, forcing full reconnect (attempt #${this.simpleEventWatchdogRecoveryAttempts})`,
+        { host: this.host }
       );
+      try {
+        await this.ensureConnected();
+        this.simpleEventLastReceivedAt = Date.now();
+        this.simpleEventWatchdogRecoveryAttempts = 0;
+        (this.logger.info ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: full reconnect successful`
+        );
+      } catch (e) {
+        (this.logger.debug ?? this.logger.log).call(
+          this.logger,
+          `[ReolinkBaichuanApi] event watchdog: full reconnect attempt #${this.simpleEventWatchdogRecoveryAttempts} failed`,
+          formatErrorForLog(e)
+        );
+      }
       return;
     }
     const now = Date.now();
@@ -21282,7 +21379,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-QJ3CRYGA.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-G3S6L3FX.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -21298,7 +21395,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-QJ3CRYGA.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-G3S6L3FX.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -26090,4 +26187,4 @@ export {
   tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-T22QCNBR.js.map
+//# sourceMappingURL=chunk-OJ4YR45R.js.map