@apocaliss92/nodelink-js 0.6.6 → 0.6.7

package/dist/index.js

@@ -76,7 +76,7 @@ import {
   setGlobalLogger,
   tcpReachabilityProbe,
   xmlIndicatesFloodlight
-} from "./chunk-JQ5NSEVD.js";
+} from "./chunk-T22QCNBR.js";
 import {
   ReolinkCgiApi,
   ReolinkHttpClient,
@@ -4763,809 +4763,8 @@ async function createReplayHttpServer(options) {
   };
 }
 
-// src/baichuan/stream/Go2rtcTcpServer.ts
-import { EventEmitter as EventEmitter2 } from "events";
-import * as net from "net";
-var AsyncBoundedQueue = class {
-  maxItems;
-  queue = [];
-  waiting;
-  closed = false;
-  constructor(maxItems) {
-    this.maxItems = Math.max(1, maxItems | 0);
-  }
-  push(item) {
-    if (this.closed) return;
-    if (this.waiting) {
-      const { resolve } = this.waiting;
-      this.waiting = void 0;
-      resolve({ value: item, done: false });
-      return;
-    }
-    this.queue.push(item);
-    if (this.queue.length > this.maxItems) {
-      this.queue.splice(0, this.queue.length - this.maxItems);
-    }
-  }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    if (this.waiting) {
-      const { resolve } = this.waiting;
-      this.waiting = void 0;
-      resolve({ value: void 0, done: true });
-    }
-  }
-  async next() {
-    if (this.closed) return { value: void 0, done: true };
-    const item = this.queue.shift();
-    if (item !== void 0) return { value: item, done: false };
-    return await new Promise((resolve) => {
-      this.waiting = { resolve };
-    });
-  }
-};
-var NativeStreamFanout = class {
-  opts;
-  queues = /* @__PURE__ */ new Map();
-  source = null;
-  running = false;
-  pumpPromise = null;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  start() {
-    if (this.running) return;
-    this.running = true;
-    this.source = this.opts.createSource();
-    this.pumpPromise = (async () => {
-      try {
-        for await (const frame of this.source) {
-          try {
-            this.opts.onFrame?.(frame);
-          } catch {
-          }
-          for (const q of this.queues.values()) {
-            q.push(frame);
-          }
-        }
-      } catch (e) {
-        this.opts.onError?.(e);
-      } finally {
-        for (const q of this.queues.values()) q.close();
-        this.queues.clear();
-        this.running = false;
-        this.opts.onEnd?.();
-      }
-    })();
-  }
-  subscribe(id) {
-    const q = new AsyncBoundedQueue(this.opts.maxQueueItems);
-    this.queues.set(id, q);
-    const self = this;
-    return (async function* () {
-      try {
-        while (true) {
-          const r = await q.next();
-          if (r.done) return;
-          yield r.value;
-        }
-      } finally {
-        q.close();
-        self.queues.delete(id);
-      }
-    })();
-  }
-  async stop() {
-    if (!this.running) return;
-    this.running = false;
-    const src = this.source;
-    this.source = null;
-    for (const q of this.queues.values()) q.close();
-    this.queues.clear();
-    try {
-      await src?.return(void 0);
-    } catch {
-    }
-    try {
-      await this.pumpPromise;
-    } catch {
-    }
-    this.pumpPromise = null;
-  }
-};
-var Go2rtcTcpServer = class _Go2rtcTcpServer extends EventEmitter2 {
-  api;
-  channel;
-  profile;
-  variant;
-  listenHost;
-  listenPort;
-  logger;
-  deviceId;
-  gracePeriodMs;
-  prebufferMaxMs;
-  maxBufferBytes;
-  streamTimeoutMs;
-  prestartStream;
-  active = false;
-  server;
-  resolvedPort;
-  // Native stream
-  nativeFanout = null;
-  nativeStreamActive = false;
-  // Set only by stopNativeStream() (explicit teardown) so the fanout's onEnd
-  // callback can short-circuit cleanup/restart logic. NOT set by the inactivity-
-  // timeout force-restart path — that flow wants onEnd to run and decide
-  // whether to restart based on prestartStream / connected clients.
-  nativeStreamStopping = false;
-  // Pending retry timer for the unbounded auto-restart loop. When a stream
-  // start fails transiently (camera in maintenance reboot, idle-disconnect
-  // race, etc.) we keep trying with exponential backoff until either the
-  // server is stopped or a frame finally arrives.
-  nativeStreamRetryTimer;
-  nativeStreamRetryDelayMs = 0;
-  dedicatedSessionRelease;
-  detectedVideoType;
-  // Client tracking
-  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;
-    this.channel = options.channel;
-    this.profile = options.profile;
-    this.variant = options.variant ?? "default";
-    this.listenHost = options.listenHost ?? "127.0.0.1";
-    this.listenPort = options.listenPort ?? 0;
-    this.logger = options.logger ?? console;
-    this.deviceId = options.deviceId;
-    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;
-  }
-  // -----------------------------------------------------------------------
-  // Public API
-  // -----------------------------------------------------------------------
-  /** Start listening. Resolves once the TCP server is bound. */
-  async start() {
-    if (this.active) return;
-    this.active = true;
-    this.server = net.createServer((socket) => this.handleClient(socket));
-    this.server.on("error", (err) => {
-      this.logger.error?.(`[Go2rtcTcpServer] server error: ${err.message}`);
-      this.emit("error", err);
-    });
-    await new Promise((resolve, reject) => {
-      this.server.listen(this.listenPort, this.listenHost, () => {
-        const addr = this.server.address();
-        this.resolvedPort = addr.port;
-        this.logger.info?.(
-          `[Go2rtcTcpServer] listening on ${addr.address}:${addr.port}  channel=${this.channel} profile=${this.profile}`
-        );
-        this.emit("listening", { host: addr.address, port: addr.port });
-        resolve();
-      });
-      this.server.once("error", reject);
-    });
-    if (this.prestartStream) {
-      this.logger.info?.(
-        `[Go2rtcTcpServer] pre-starting native stream  channel=${this.channel} profile=${this.profile}`
-      );
-      this.startNativeStream();
-    }
-  }
-  /** Stop the server and all active streams. */
-  async stop() {
-    if (!this.active) return;
-    this.active = false;
-    clearTimeout(this.stopGraceTimer);
-    this.clearNativeStreamRetry();
-    this.stopStreamHealthMonitor();
-    for (const [id, sock] of this.clientSockets) {
-      sock.destroy();
-      this.connectedClients.delete(id);
-    }
-    this.clientSockets.clear();
-    await this.stopNativeStream();
-    if (this.server) {
-      await new Promise((resolve) => {
-        this.server.close(() => resolve());
-      });
-      this.server = void 0;
-    }
-    this.prebuffer = [];
-    this.resolvedPort = void 0;
-    this.emit("close");
-  }
-  /** The actual port the server is listening on (available after start()). */
-  get port() {
-    return this.resolvedPort;
-  }
-  /** The go2rtc-compatible source URL. */
-  get go2rtcSourceUrl() {
-    if (this.resolvedPort == null) return void 0;
-    return `tcp://127.0.0.1:${this.resolvedPort}`;
-  }
-  /** Number of currently connected clients. */
-  get clientCount() {
-    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) {
-    const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
-    socket.setNoDelay(true);
-    this.connectedClients.add(clientId);
-    this.clientSockets.set(clientId, socket);
-    this.logger.info?.(
-      `[Go2rtcTcpServer] client connected  id=${clientId} total=${this.connectedClients.size}`
-    );
-    this.emit("client", clientId);
-    if (this.stopGraceTimer) {
-      clearTimeout(this.stopGraceTimer);
-      this.stopGraceTimer = void 0;
-    }
-    if (!this.nativeStreamActive) {
-      this.startNativeStream();
-    }
-    this.feedClient(clientId, socket).catch((err) => {
-      this.logger.warn?.(
-        `[Go2rtcTcpServer] feedClient error  id=${clientId}: ${err}`
-      );
-    });
-    const cleanup = (reason) => {
-      this.removeClient(clientId, reason);
-      socket.destroy();
-    };
-    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;
-    while (this.active && !this.nativeFanout) {
-      if (socket.destroyed) return;
-      if (Date.now() > fanoutDeadline) {
-        this.logger.warn?.(
-          `[Go2rtcTcpServer] fanout not ready after 30s, dropping client ${clientId}`
-        );
-        return;
-      }
-      await new Promise((r) => setTimeout(r, 100));
-    }
-    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--) {
-      if (prebufferSnap[i].isKeyframe) {
-        lastIdrIdx = i;
-        break;
-      }
-    }
-    if (lastIdrIdx >= 0) {
-      const replay = prebufferSnap.slice(lastIdrIdx);
-      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;
-        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;
-    let liveFrameCount = 0;
-    let liveVideoWritten = 0;
-    let lastLogAt = Date.now();
-    try {
-      this.logger.info?.(
-        `[Go2rtcTcpServer] entering live loop  client=${clientId} seenKeyframe=${seenKeyframe}`
-      );
-      for await (const frame of subscription) {
-        if (socket.destroyed || !this.active) {
-          this.logger.info?.(
-            `[Go2rtcTcpServer] live loop exit  client=${clientId} destroyed=${socket.destroyed} active=${this.active}`
-          );
-          break;
-        }
-        liveFrameCount++;
-        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 (!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
-            });
-          }
-        }
-        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}`
-          );
-          lastLogAt = Date.now();
-        }
-        if (socket.writableLength > this.maxBufferBytes) {
-          this.logger.warn?.(
-            `[Go2rtcTcpServer] buffer overflow (${socket.writableLength} bytes), dropping client ${clientId}`
-          );
-          socket.destroy();
-          break;
-        }
-      }
-      this.logger.info?.(
-        `[Go2rtcTcpServer] live loop ended naturally  client=${clientId} received=${liveFrameCount} written=${liveVideoWritten}`
-      );
-    } finally {
-      await subscription.return(void 0).catch(() => {
-      });
-    }
-  }
-  // -----------------------------------------------------------------------
-  // Frame conversion
-  // -----------------------------------------------------------------------
-  /**
-   * Convert a native video frame to Annex-B.
-   * Returns null for audio frames (handled separately by muxAudio).
-   */
-  convertVideoFrame(frame) {
-    if (frame.audio) return null;
-    if (frame.data.length === 0) return null;
-    try {
-      if (frame.videoType === "H264") {
-        return convertToAnnexB(frame.data);
-      }
-      if (frame.videoType === "H265") {
-        return convertToAnnexB2(frame.data);
-      }
-    } catch {
-    }
-    return frame.data;
-  }
-  /** Check if an Annex-B buffer contains a keyframe (IDR for H.264, IRAP for H.265). */
-  isAnnexBKeyframe(annexB, videoType) {
-    try {
-      if (videoType === "H264") {
-        const nals = _Go2rtcTcpServer.splitAnnexBNals(annexB);
-        return nals.some((n) => n.length >= 1 && (n[0] & 31) === 5);
-      }
-      if (videoType === "H265") {
-        const nals = splitAnnexBToNalPayloads2(annexB);
-        return nals.some(
-          (n) => n.length >= 2 && isH265Irap(n[0] >> 1 & 63)
-        );
-      }
-    } catch {
-    }
-    return false;
-  }
-  /** Split Annex-B byte stream into individual NAL units. */
-  static splitAnnexBNals(buf) {
-    const nals = [];
-    let i = 0;
-    while (i < buf.length) {
-      if (i + 2 < buf.length && buf[i] === 0 && buf[i + 1] === 0) {
-        let scLen;
-        if (buf[i + 2] === 1) {
-          scLen = 3;
-        } else if (i + 3 < buf.length && buf[i + 2] === 0 && buf[i + 3] === 1) {
-          scLen = 4;
-        } else {
-          i++;
-          continue;
-        }
-        const nalStart = i + scLen;
-        let nalEnd = buf.length;
-        for (let j = nalStart; j < buf.length - 2; j++) {
-          if (buf[j] === 0 && buf[j + 1] === 0 && (buf[j + 2] === 1 || j + 3 < buf.length && buf[j + 2] === 0 && buf[j + 3] === 1)) {
-            nalEnd = j;
-            break;
-          }
-        }
-        if (nalEnd > nalStart) {
-          nals.push(buf.subarray(nalStart, nalEnd));
-        }
-        i = nalEnd;
-      } else {
-        i++;
-      }
-    }
-    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
-  // -----------------------------------------------------------------------
-  /**
-   * Schedule another startNativeStream() attempt after the given delay.
-   * Idempotent: a no-op if a retry is already scheduled, the server is no
-   * longer active, or an explicit stop is in progress. Implements unbounded
-   * exponential backoff (5s → 60s) so a camera that stays unreachable for
-   * minutes (e.g. nightly maintenance reboot) eventually recovers without
-   * manual intervention — see issue #16.
-   */
-  scheduleNativeStreamRetry(reason) {
-    if (!this.active) return;
-    if (this.nativeStreamStopping) return;
-    if (this.nativeStreamRetryTimer) return;
-    const delay = this.nativeStreamRetryDelayMs > 0 ? this.nativeStreamRetryDelayMs : 5e3;
-    this.logger.info?.(
-      `[Go2rtcTcpServer] scheduling native stream retry in ${(delay / 1e3).toFixed(0)}s (reason=${reason})`
-    );
-    this.nativeStreamRetryTimer = setTimeout(() => {
-      this.nativeStreamRetryTimer = void 0;
-      if (!this.active) return;
-      if (this.nativeStreamStopping) return;
-      this.startNativeStream().catch((err) => {
-        this.logger.warn?.(
-          `[Go2rtcTcpServer] retry of startNativeStream threw: ${err instanceof Error ? err.message : err}`
-        );
-      });
-    }, delay);
-    this.nativeStreamRetryDelayMs = Math.min(delay * 2, 6e4);
-  }
-  /**
-   * Cancel any pending retry timer and reset the backoff. Called on explicit
-   * stop and on first-frame-received so the next failure starts the backoff
-   * window from scratch.
-   */
-  clearNativeStreamRetry() {
-    if (this.nativeStreamRetryTimer) {
-      clearTimeout(this.nativeStreamRetryTimer);
-      this.nativeStreamRetryTimer = void 0;
-    }
-    this.nativeStreamRetryDelayMs = 0;
-  }
-  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: ${e}`
-        );
-        this.scheduleNativeStreamRetry("ensureConnected failed");
-        return;
-      }
-    }
-    this.nativeStreamActive = true;
-    let dedicatedClient;
-    if (this.deviceId) {
-      try {
-        const session = await this.api.createDedicatedSession(
-          `live:${this.deviceId}:ch${this.channel}:${this.profile}`
-        );
-        dedicatedClient = session.client;
-        this.dedicatedSessionRelease = session.release;
-      } catch (e) {
-        this.logger.warn?.(
-          `[Go2rtcTcpServer] failed to acquire dedicated session, using shared socket: ${e}`
-        );
-      }
-    }
-    this.logger.info?.(
-      `[Go2rtcTcpServer] native stream starting  channel=${this.channel} profile=${this.profile} dedicated=${!!dedicatedClient}`
-    );
-    let hadFrames = false;
-    this.nativeFanout = new NativeStreamFanout({
-      maxQueueItems: 200,
-      createSource: () => createNativeStream(this.api, this.channel, this.profile, {
-        variant: this.variant,
-        ...dedicatedClient ? { client: dedicatedClient } : {}
-      }),
-      onFrame: (frame) => {
-        if (!hadFrames) {
-          this.clearNativeStreamRetry();
-        }
-        hadFrames = true;
-        this.lastFrameAt = Date.now();
-        this.totalFramesReceived++;
-        if (!frame.audio && (frame.videoType === "H264" || frame.videoType === "H265")) {
-          this.detectedVideoType = 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(prebufData),
-          time: Date.now(),
-          isKeyframe,
-          audio: frame.audio,
-          pts
-        });
-        const cutoff = Date.now() - this.prebufferMaxMs;
-        let trimIdx = 0;
-        while (trimIdx < this.prebuffer.length && this.prebuffer[trimIdx].time < cutoff) {
-          trimIdx++;
-        }
-        if (trimIdx > 0) this.prebuffer.splice(0, trimIdx);
-      },
-      onError: (error) => {
-        this.logger.warn?.(`[Go2rtcTcpServer] native stream error: ${error}`);
-      },
-      onEnd: () => {
-        if (this.nativeStreamStopping) 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.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] restarting native stream (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
-          );
-          this.startNativeStream();
-        }
-      }
-    });
-    this.nativeFanout.start();
-    this.startStreamHealthMonitor();
-  }
-  async stopNativeStream() {
-    this.nativeStreamStopping = true;
-    this.nativeStreamActive = false;
-    this.clearNativeStreamRetry();
-    this.stopStreamHealthMonitor();
-    const fanout = this.nativeFanout;
-    this.nativeFanout = null;
-    try {
-      if (fanout) {
-        await fanout.stop();
-      }
-      this.prebuffer = [];
-      if (this.dedicatedSessionRelease) {
-        await this.dedicatedSessionRelease().catch(() => {
-        });
-        this.dedicatedSessionRelease = void 0;
-      }
-    } finally {
-      this.nativeStreamStopping = false;
-    }
-  }
-  // -----------------------------------------------------------------------
-  // 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, 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} 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) {
-      this.scheduleStop();
-    }
-  }
-  scheduleStop() {
-    if (this.stopGraceTimer) return;
-    this.logger.info?.(
-      `[Go2rtcTcpServer] no clients, scheduling stream stop in ${this.gracePeriodMs}ms`
-    );
-    this.stopGraceTimer = setTimeout(async () => {
-      this.stopGraceTimer = void 0;
-      if (this.connectedClients.size === 0 && this.nativeStreamActive) {
-        this.logger.info?.("[Go2rtcTcpServer] grace period expired, stopping native stream");
-        await this.stopNativeStream();
-      }
-    }, this.gracePeriodMs);
-  }
-};
-
 // src/baichuan/stream/BaichuanHttpStreamServer.ts
-import { EventEmitter as EventEmitter3 } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 import { spawn as spawn5 } from "child_process";
 import * as http4 from "http";
 var NAL_START_CODE_4B = Buffer.from([0, 0, 0, 1]);
@@ -5612,7 +4811,7 @@ function isH264KeyframeFromAnnexB(annexB) {
   }
   return false;
 }
-var BaichuanHttpStreamServer = class extends EventEmitter3 {
+var BaichuanHttpStreamServer = class extends EventEmitter2 {
   videoStream;
   listenPort;
   path;
@@ -5884,15 +5083,15 @@ var BaichuanHttpStreamServer = class extends EventEmitter3 {
 };
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-import { EventEmitter as EventEmitter5 } from "events";
+import { EventEmitter as EventEmitter4 } from "events";
 import * as http5 from "http";
 
 // src/baichuan/stream/MjpegTransformer.ts
-import { EventEmitter as EventEmitter4 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 import { spawn as spawn6 } from "child_process";
 var JPEG_SOI = Buffer.from([255, 216]);
 var JPEG_EOI = Buffer.from([255, 217]);
-var MjpegTransformer = class extends EventEmitter4 {
+var MjpegTransformer = class extends EventEmitter3 {
   options;
   ffmpeg = null;
   started = false;
@@ -6089,7 +5288,7 @@ Content-Length: ${frame.length}\r
 }
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-var BaichuanMjpegServer = class extends EventEmitter5 {
+var BaichuanMjpegServer = class extends EventEmitter4 {
   options;
   clients = /* @__PURE__ */ new Map();
   httpServer = null;
@@ -6370,13 +5569,13 @@ var BaichuanMjpegServer = class extends EventEmitter5 {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-import { EventEmitter as EventEmitter7 } from "events";
+import { EventEmitter as EventEmitter6 } from "events";
 
 // src/baichuan/stream/AacToOpusTranscoder.ts
 import { spawn as spawn7 } from "child_process";
 import { createSocket } from "dgram";
-import { EventEmitter as EventEmitter6 } from "events";
-var AacToOpusTranscoder = class extends EventEmitter6 {
+import { EventEmitter as EventEmitter5 } from "events";
+var AacToOpusTranscoder = class extends EventEmitter5 {
   opts;
   socket = null;
   ffmpeg = null;
@@ -6592,7 +5791,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends EventEmitter7 {
+var BaichuanWebRTCServer = class extends EventEmitter6 {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -7584,7 +6783,7 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-import { EventEmitter as EventEmitter8 } from "events";
+import { EventEmitter as EventEmitter7 } from "events";
 import fs from "fs";
 import fsp from "fs/promises";
 import os from "os";
@@ -7661,7 +6860,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends EventEmitter8 {
+var BaichuanHlsServer = class extends EventEmitter7 {
   api;
   channel;
   profile;
@@ -8086,10 +7285,10 @@ var BaichuanHlsServer = class extends EventEmitter8 {
 };
 
 // src/multifocal/compositeRtspServer.ts
-import { EventEmitter as EventEmitter9 } from "events";
+import { EventEmitter as EventEmitter8 } from "events";
 import { spawn as spawn9 } from "child_process";
-import * as net2 from "net";
-var CompositeRtspServer = class extends EventEmitter9 {
+import * as net from "net";
+var CompositeRtspServer = class extends EventEmitter8 {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -8155,7 +7354,7 @@ var CompositeRtspServer = class extends EventEmitter9 {
     const width = widerStreamInfo?.width ?? 1920;
     const height = widerStreamInfo?.height ?? 1080;
     const fps = widerStreamInfo?.frameRate ?? 25;
-    this.rtspServer = net2.createServer((socket) => {
+    this.rtspServer = net.createServer((socket) => {
       this.handleRtspConnection(socket);
     });
     await new Promise((resolve, reject) => {
@@ -8865,8 +8064,8 @@ var RtspBackchannel = class _RtspBackchannel {
 };
 
 // src/baichuan/stream/BaichuanRtspBackchannelServer.ts
-import { EventEmitter as EventEmitter10 } from "events";
-import * as net3 from "net";
+import { EventEmitter as EventEmitter9 } from "events";
+import * as net2 from "net";
 import * as crypto2 from "crypto";
 var md5Hex = (s) => crypto2.createHash("md5").update(s).digest("hex");
 var RTCP_KEEPALIVE_INTERVAL_MS = 1e4;
@@ -8922,7 +8121,7 @@ function extractPublicEndpoint(url, requestText) {
   if (hostHeader) return hostHeader;
   return null;
 }
-var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends EventEmitter10 {
+var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends EventEmitter9 {
   listenHost;
   listenPort;
   logger;
@@ -9039,7 +8238,7 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
   async start() {
     if (this.server) return;
     await new Promise((resolve, reject) => {
-      const server = net3.createServer((socket) => this.handleConnection(socket));
+      const server = net2.createServer((socket) => this.handleConnection(socket));
       const onError = (err) => {
         server.removeListener("error", onError);
         reject(err);
@@ -10066,7 +9265,6 @@ export {
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
-  Go2rtcTcpServer,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
   HlsSessionManager,