@apocaliss92/nodelink-js 0.6.5 → 0.6.7

package/dist/index.cjs

@@ -8431,7 +8431,6 @@ __export(index_exports, {
   DUAL_LENS_DUAL_MOTION_MODELS: () => DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS: () => DUAL_LENS_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS: () => DUAL_LENS_SINGLE_MOTION_MODELS,
-  Go2rtcTcpServer: () => Go2rtcTcpServer,
   H264RtpDepacketizer: () => H264RtpDepacketizer,
   H265RtpDepacketizer: () => H265RtpDepacketizer,
   HlsSessionManager: () => HlsSessionManager,
@@ -14898,6 +14897,38 @@ function createRtspFlow(transport, videoType) {
   return new H265Flow(transport);
 }
 
+// src/baichuan/stream/rtpVideoTimestamp.ts
+var U32 = 4294967296;
+var DEFAULT_VIDEO_CLOCK_RATE = 9e4;
+function deriveRtpVideoTimestamp(state, frameMicroseconds, clockRate = DEFAULT_VIDEO_CLOCK_RATE) {
+  if (frameMicroseconds === null || frameMicroseconds === void 0 || !Number.isFinite(frameMicroseconds)) {
+    return { timestamp: state.timestamp, state };
+  }
+  const curRaw = frameMicroseconds >>> 0;
+  if (state.baseUnwrappedUs === void 0) {
+    return {
+      timestamp: state.timestamp,
+      state: {
+        ...state,
+        unwrappedUs: curRaw,
+        lastRawUs: curRaw,
+        baseUnwrappedUs: curRaw,
+        baseTimestamp: state.timestamp
+      }
+    };
+  }
+  const lastRaw = state.lastRawUs ?? curRaw;
+  let forwardDelta = curRaw - lastRaw >>> 0;
+  if (forwardDelta > U32 / 2) forwardDelta = 0;
+  const unwrappedUs = (state.unwrappedUs ?? curRaw) + forwardDelta;
+  const deltaUs = unwrappedUs - state.baseUnwrappedUs;
+  const timestamp = state.baseTimestamp + Math.round(deltaUs * clockRate / 1e6) >>> 0;
+  return {
+    timestamp,
+    state: { ...state, unwrappedUs, lastRawUs: curRaw, timestamp }
+  };
+}
+
 // src/baichuan/stream/BaichuanRtspServer.ts
 init_H264Converter();
 init_H265Converter();
@@ -15472,7 +15503,10 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.E
     let useTcpInterleaved = false;
     let clientUdpSocket = null;
     let clientUdpSocketAudio = null;
+    let cleanedUp = false;
     const cleanup = () => {
+      if (cleanedUp) return;
+      cleanedUp = true;
       const sessionDurationMs = Date.now() - connectTime;
       const res = this.clientResources.get(clientId);
       const framesSent = res?.framesSent ?? 0;
@@ -16220,22 +16254,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events5.E
         resources.rtpVideoTimestamp = 0;
       if (resources.rtpVideoBaseTimestamp === void 0)
         resources.rtpVideoBaseTimestamp = resources.rtpVideoTimestamp;
-      if (resources.rtpVideoBaseMicroseconds === void 0) {
+      const { timestamp, state } = deriveRtpVideoTimestamp(
+        {
+          timestamp: resources.rtpVideoTimestamp,
+          baseTimestamp: resources.rtpVideoBaseTimestamp,
+          unwrappedUs: resources.rtpVideoUnwrappedUs,
+          lastRawUs: resources.rtpVideoLastRawUs,
+          baseUnwrappedUs: resources.rtpVideoBaseUnwrappedUs
+        },
+        frameMicroseconds,
+        videoClockRate
+      );
+      resources.rtpVideoTimestamp = timestamp;
+      resources.rtpVideoBaseTimestamp = state.baseTimestamp;
+      resources.rtpVideoUnwrappedUs = state.unwrappedUs;
+      resources.rtpVideoLastRawUs = state.lastRawUs;
+      resources.rtpVideoBaseUnwrappedUs = state.baseUnwrappedUs;
+      resources.rtpVideoLastTimestamp = timestamp;
+      if (resources.rtpVideoBaseMicroseconds === void 0)
         resources.rtpVideoBaseMicroseconds = frameMicroseconds >>> 0;
-        resources.rtpVideoLastTimestamp = resources.rtpVideoTimestamp;
-        return;
-      }
-      const baseUs = resources.rtpVideoBaseMicroseconds >>> 0;
-      const curUs = frameMicroseconds >>> 0;
-      const deltaUs = curUs - baseUs >>> 0;
-      const baseTs = (resources.rtpVideoBaseTimestamp ?? 0) >>> 0;
-      let ts = baseTs + Math.round(deltaUs * videoClockRate / 1e6) >>> 0;
-      const last = resources.rtpVideoLastTimestamp;
-      if (last !== void 0 && ts <= last >>> 0) {
-        ts = (last >>> 0) + 1 >>> 0;
-      }
-      resources.rtpVideoTimestamp = ts;
-      resources.rtpVideoLastTimestamp = ts;
     };
     const sendVideoAccessUnit = (videoType, accessUnitAnnexB, advanceTimestamp = true) => {
       const nals = _BaichuanRtspServer.splitAnnexBNals(accessUnitAnnexB);
@@ -17700,6 +17737,30 @@ function buildSetNtpXml(current, patch) {
   );
 }
 
+// src/reolink/baichuan/utils/channelEnumeration.ts
+async function resolveBaichuanChannels(deps) {
+  const fromPush = dedupeSorted(deps.pushChannels);
+  if (fromPush.length > 0) return fromPush;
+  const slots = dedupeSorted(deps.supportChnIds);
+  const candidates = slots.length > 0 ? slots : [0];
+  const probed = await Promise.all(
+    candidates.map(
+      async (channel) => await deps.probe(channel) ? channel : void 0
+    )
+  );
+  return dedupeSorted(
+    probed.filter((c) => c !== void 0)
+  );
+}
+function dedupeSorted(values) {
+  const set = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    const n = Number(v);
+    if (Number.isFinite(n) && n >= 0) set.add(n);
+  }
+  return [...set].sort((a, b) => a - b);
+}
+
 // src/reolink/baichuan/utils/dst.ts
 init_xml();
 var parseNumberSafe3 = (text) => {
@@ -24109,13 +24170,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * @param options.source - Data source for the channel list (default: `"cgi"`):
    *   - `"cgi"`: Uses HTTP `GetChannelstatus` — returns the channel list immediately,
    *     no dependency on async push messages. Recommended for first-call discovery.
-   *   - `"baichuan"`: Uses the cmd_id 145 push cache populated when the NVR sends channel
-   *     info after login + event subscription. This push is *asynchronous*: if it has not
-   *     arrived yet, the result will have zero channels. Callers must retry (nvr.ts does this
-   *     with a 1-second loop). Note: explicitly requesting cmd_id 145 is not supported.
+   *   - `"baichuan"`: HTTP-free discovery. Prefers the cmd_id 145 push cache when
+   *     populated; otherwise actively probes the channel slots advertised by Support
+   *     (`items[].chnID`) via `getInfo`. Use this for hubs with HTTP disabled.
+   *
+   * When the api was constructed with `nativeOnly`, the source is forced to
+   * `"baichuan"` regardless of this option (no HTTP/CGI is ever attempted).
    */
   async getNvrChannelsSummary(options) {
-    const source = options?.source ?? "cgi";
+    const source = this.nativeOnly ? "baichuan" : options?.source ?? "cgi";
+    const support = await this.getSupportInfo().catch(() => {
+      this.logger.error?.(
+        "[ReolinkBaichuanApi] getNvrChannelsSummary: failed to get support info"
+      );
+      return void 0;
+    });
     let channels;
     const cgiStatusByChannel = /* @__PURE__ */ new Map();
     if (options?.channels?.length) {
@@ -24145,15 +24214,31 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         channels = [];
       }
     } else {
-      const pushInfo2 = this.getChannelInfoFromPushCache();
-      channels = Array.from(pushInfo2.keys()).map((c) => Number(c)).filter((n) => Number.isFinite(n));
+      const pushChannels = Array.from(
+        this.getChannelInfoFromPushCache().keys()
+      ).map((c) => Number(c)).filter((n) => Number.isFinite(n));
+      const supportChnIds = (support?.items ?? []).map((i) => Number(i.chnID)).filter((n) => Number.isFinite(n));
+      const probeTimeoutMs = options?.timeoutMs ?? 2500;
+      channels = await resolveBaichuanChannels({
+        pushChannels,
+        supportChnIds,
+        probe: async (channel) => {
+          try {
+            await this.getInfo(channel, {
+              timeoutMs: probeTimeoutMs,
+              tags: ["type", "name"]
+            });
+            return true;
+          } catch {
+            return false;
+          }
+        }
+      });
+      this.logger.debug?.(
+        `[ReolinkBaichuanApi] getNvrChannelsSummary: baichuan resolved ${channels.length} channel(s): [${channels.join(", ")}]`
+      );
     }
     channels = channels.sort((a, b) => a - b);
-    const support = await this.getSupportInfo().catch(() => {
-      this.logger.error?.(
-        "[ReolinkBaichuanApi] getNvrChannelsSummary: failed to get support info"
-      );
-    });
     const truthyNumberLike = (v) => {
       if (typeof v === "number") return v > 0;
       if (typeof v === "string") {
@@ -38182,811 +38267,8 @@ async function createReplayHttpServer(options) {
 // src/index.ts
 init_BaichuanVideoStream();
 
-// src/baichuan/stream/Go2rtcTcpServer.ts
-var import_node_events8 = require("events");
-var net4 = __toESM(require("net"), 1);
-init_H264Converter();
-init_H265Converter();
-var AsyncBoundedQueue2 = 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 NativeStreamFanout2 = 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 AsyncBoundedQueue2(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 import_node_events8.EventEmitter {
-  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 = net4.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 NativeStreamFanout2({
-      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
-var import_node_events9 = require("events");
+var import_node_events8 = require("events");
 var import_node_child_process10 = require("child_process");
 var http4 = __toESM(require("http"), 1);
 var NAL_START_CODE_4B4 = Buffer.from([0, 0, 0, 1]);
@@ -39033,7 +38315,7 @@ function isH264KeyframeFromAnnexB(annexB) {
   }
   return false;
 }
-var BaichuanHttpStreamServer = class extends import_node_events9.EventEmitter {
+var BaichuanHttpStreamServer = class extends import_node_events8.EventEmitter {
   videoStream;
   listenPort;
   path;
@@ -39305,15 +38587,15 @@ var BaichuanHttpStreamServer = class extends import_node_events9.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-var import_node_events11 = require("events");
+var import_node_events10 = require("events");
 var http5 = __toESM(require("http"), 1);
 
 // src/baichuan/stream/MjpegTransformer.ts
-var import_node_events10 = require("events");
+var import_node_events9 = require("events");
 var import_node_child_process11 = require("child_process");
 var JPEG_SOI = Buffer.from([255, 216]);
 var JPEG_EOI = Buffer.from([255, 217]);
-var MjpegTransformer = class extends import_node_events10.EventEmitter {
+var MjpegTransformer = class extends import_node_events9.EventEmitter {
   options;
   ffmpeg = null;
   started = false;
@@ -39512,7 +38794,7 @@ Content-Length: ${frame.length}\r
 // src/baichuan/stream/BaichuanMjpegServer.ts
 init_H264Converter();
 init_H265Converter();
-var BaichuanMjpegServer = class extends import_node_events11.EventEmitter {
+var BaichuanMjpegServer = class extends import_node_events10.EventEmitter {
   options;
   clients = /* @__PURE__ */ new Map();
   httpServer = null;
@@ -39793,14 +39075,14 @@ var BaichuanMjpegServer = class extends import_node_events11.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-var import_node_events13 = require("events");
+var import_node_events12 = require("events");
 init_BcMediaAnnexBDecoder();
 
 // src/baichuan/stream/AacToOpusTranscoder.ts
 var import_node_child_process12 = require("child_process");
 var import_node_dgram3 = require("dgram");
-var import_node_events12 = require("events");
-var AacToOpusTranscoder = class extends import_node_events12.EventEmitter {
+var import_node_events11 = require("events");
+var AacToOpusTranscoder = class extends import_node_events11.EventEmitter {
   opts;
   socket = null;
   ffmpeg = null;
@@ -40017,7 +39299,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends import_node_events13.EventEmitter {
+var BaichuanWebRTCServer = class extends import_node_events12.EventEmitter {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -41009,7 +40291,7 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-var import_node_events14 = require("events");
+var import_node_events13 = require("events");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
@@ -41089,7 +40371,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events14.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events13.EventEmitter {
   api;
   channel;
   profile;
@@ -41658,10 +40940,10 @@ async function pingHost(host, timeoutMs = 3e3) {
   return false;
 }
 async function tcpReachabilityProbe(host, port, timeoutMs) {
-  const net7 = await import("net");
+  const net6 = await import("net");
   return new Promise((resolve) => {
     let settled = false;
-    const socket = new net7.Socket();
+    const socket = new net6.Socket();
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
@@ -42254,10 +41536,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events15 = require("events");
+var import_node_events14 = require("events");
 var import_node_child_process14 = require("child_process");
-var net5 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events15.EventEmitter {
+var net4 = __toESM(require("net"), 1);
+var CompositeRtspServer = class extends import_node_events14.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -42323,7 +41605,7 @@ var CompositeRtspServer = class extends import_node_events15.EventEmitter {
     const width = widerStreamInfo?.width ?? 1920;
     const height = widerStreamInfo?.height ?? 1080;
     const fps = widerStreamInfo?.frameRate ?? 25;
-    this.rtspServer = net5.createServer((socket) => {
+    this.rtspServer = net4.createServer((socket) => {
       this.handleRtspConnection(socket);
     });
     await new Promise((resolve, reject) => {
@@ -43033,8 +42315,8 @@ var RtspBackchannel = class _RtspBackchannel {
 };
 
 // src/baichuan/stream/BaichuanRtspBackchannelServer.ts
-var import_node_events16 = require("events");
-var net6 = __toESM(require("net"), 1);
+var import_node_events15 = require("events");
+var net5 = __toESM(require("net"), 1);
 var crypto3 = __toESM(require("crypto"), 1);
 var md5Hex = (s) => crypto3.createHash("md5").update(s).digest("hex");
 var RTCP_KEEPALIVE_INTERVAL_MS = 1e4;
@@ -43090,7 +42372,7 @@ function extractPublicEndpoint(url, requestText) {
   if (hostHeader) return hostHeader;
   return null;
 }
-var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events16.EventEmitter {
+var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends import_node_events15.EventEmitter {
   listenHost;
   listenPort;
   logger;
@@ -43207,7 +42489,7 @@ var BaichuanRtspBackchannelServer = class _BaichuanRtspBackchannelServer extends
   async start() {
     if (this.server) return;
     await new Promise((resolve, reject) => {
-      const server = net6.createServer((socket) => this.handleConnection(socket));
+      const server = net5.createServer((socket) => this.handleConnection(socket));
       const onError = (err) => {
         server.removeListener("error", onError);
         reject(err);
@@ -44235,7 +43517,6 @@ function buildInitialStatus(config) {
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
-  Go2rtcTcpServer,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
   HlsSessionManager,