@apocaliss92/nodelink-js 0.3.4 → 0.3.9

package/dist/index.cjs

@@ -3103,6 +3103,7 @@ var init_urls = __esm({
 // src/debug/DiagnosticsTools.ts
 var DiagnosticsTools_exports = {};
 __export(DiagnosticsTools_exports, {
+  captureModelFixtures: () => captureModelFixtures,
   collectCgiDiagnostics: () => collectCgiDiagnostics,
   collectMultifocalDiagnostics: () => collectMultifocalDiagnostics,
   collectNativeDiagnostics: () => collectNativeDiagnostics,
@@ -3136,6 +3137,10 @@ function writeJson(filePath, obj) {
   mkdirp(path4.dirname(filePath));
   fs4.writeFileSync(filePath, JSON.stringify(obj, null, 2));
 }
+function writeText(filePath, text) {
+  mkdirp(path4.dirname(filePath));
+  fs4.writeFileSync(filePath, text);
+}
 function appendNdjson(filePath, obj) {
   mkdirp(path4.dirname(filePath));
   fs4.appendFileSync(filePath, JSON.stringify(obj) + "\n");
@@ -5399,6 +5404,172 @@ async function runAllDiagnosticsConsecutively(params) {
     streamsDir
   };
 }
+async function captureModelFixtures(params) {
+  const { api, channel, outDir } = params;
+  const log = params.log ?? console.log;
+  mkdirp(outDir);
+  const calls = {};
+  const errors = [];
+  async function capture(name, fn, writer) {
+    try {
+      const value = await fn();
+      calls[name] = { ok: true, value };
+      if (writer && value !== void 0 && value !== null) {
+        writer(value);
+      }
+      log(`  \u2713 ${name}`);
+      return value;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      calls[name] = { ok: false, error: msg };
+      errors.push(`${name}: ${msg}`);
+      log(`  \u2717 ${name}: ${msg}`);
+      return void 0;
+    }
+  }
+  const info = await capture(
+    "getInfo",
+    () => api.getInfo(channel),
+    (v) => writeJson(path4.join(outDir, "device-info.json"), v)
+  );
+  const support = await capture(
+    "getSupportInfo",
+    () => api.getSupportInfo(),
+    (v) => writeJson(path4.join(outDir, "support-info.json"), v)
+  );
+  const abilities = await capture(
+    "getAbilityInfo",
+    () => api.getAbilityInfo(),
+    (v) => writeJson(path4.join(outDir, "ability-info.json"), v)
+  );
+  await capture(
+    "getDeviceCapabilities",
+    () => api.getDeviceCapabilities(channel),
+    (v) => writeJson(path4.join(outDir, "capabilities.json"), v)
+  );
+  await capture("cmd289-WhiteLed", () => api.sendXml({
+    cmdId: BC_CMD_ID_GET_WHITE_LED,
+    channel,
+    timeoutMs: 3e3
+  }), (v) => writeText(path4.join(outDir, "cmd289-white-led.xml"), v));
+  await capture(
+    "getStreamMetadata",
+    () => api.getStreamMetadata(channel),
+    (v) => writeJson(path4.join(outDir, "stream-metadata.json"), v)
+  );
+  await capture(
+    "getEncXml",
+    () => api.getEncXml(channel),
+    (v) => writeText(path4.join(outDir, "enc-config.xml"), v)
+  );
+  await capture(
+    "getPorts",
+    () => api.getPorts(),
+    (v) => writeJson(path4.join(outDir, "ports.json"), v)
+  );
+  await capture(
+    "getTalkAbility",
+    () => api.getTalkAbility(channel),
+    (v) => writeJson(path4.join(outDir, "talk-ability.json"), v)
+  );
+  await capture(
+    "getTwoWayAudioConfig",
+    () => api.getTwoWayAudioConfig(channel),
+    (v) => writeJson(path4.join(outDir, "two-way-audio-config.json"), v)
+  );
+  await capture(
+    "getAiState",
+    () => api.getAiState(channel),
+    (v) => writeJson(path4.join(outDir, "ai-state.json"), v)
+  );
+  await capture(
+    "getAiCfg",
+    () => api.getAiCfg(channel),
+    (v) => writeJson(path4.join(outDir, "ai-cfg.json"), v)
+  );
+  await capture(
+    "getOsd",
+    () => api.getOsd(channel),
+    (v) => writeJson(path4.join(outDir, "osd.json"), v)
+  );
+  await capture(
+    "getMotionAlarm",
+    () => api.getMotionAlarm(channel),
+    (v) => writeJson(path4.join(outDir, "motion-alarm.json"), v)
+  );
+  await capture(
+    "getRecordCfg",
+    () => api.getRecordCfg(channel),
+    (v) => writeJson(path4.join(outDir, "record-cfg.json"), v)
+  );
+  await capture(
+    "getVideoInput",
+    () => api.getVideoInput(channel),
+    (v) => writeJson(path4.join(outDir, "video-input.json"), v)
+  );
+  await capture(
+    "getPtzPresets",
+    () => api.getPtzPresets(channel),
+    (v) => writeJson(path4.join(outDir, "ptz-presets.json"), v)
+  );
+  await capture(
+    "getNetworkInfo",
+    () => api.getNetworkInfo(),
+    (v) => writeJson(path4.join(outDir, "network-info.json"), v)
+  );
+  await capture(
+    "getSystemGeneral",
+    () => api.getSystemGeneral(),
+    (v) => writeJson(path4.join(outDir, "system-general.json"), v)
+  );
+  await capture(
+    "getWifiSignal",
+    () => api.getWifiSignal(channel),
+    (v) => writeJson(path4.join(outDir, "wifi-signal.json"), v)
+  );
+  await capture(
+    "getWhiteLedState",
+    () => api.getWhiteLedState(channel),
+    (v) => writeJson(path4.join(outDir, "white-led-state.json"), v)
+  );
+  await capture(
+    "getFloodlightOnMotion",
+    () => api.getFloodlightOnMotion(channel),
+    (v) => writeJson(path4.join(outDir, "floodlight-on-motion.json"), v)
+  );
+  await capture(
+    "buildVideoStreamOptions",
+    () => api.buildVideoStreamOptions({ channel }),
+    (v) => writeJson(path4.join(outDir, "video-stream-options.json"), v)
+  );
+  const total = Object.keys(calls).length;
+  const ok = Object.values(calls).filter((c) => c.ok).length;
+  const failed = total - ok;
+  const summary = { total, ok, failed, errors };
+  writeJson(path4.join(outDir, "_summary.json"), {
+    collectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    model: info?.type ?? "unknown",
+    itemNo: info?.itemNo ?? "unknown",
+    firmwareVersion: info?.firmwareVersion ?? "unknown",
+    channel,
+    ...summary,
+    calls: Object.fromEntries(
+      Object.entries(calls).map(([k, v]) => [
+        k,
+        v.ok ? "ok" : `FAILED: ${v.error}`
+      ])
+    )
+  });
+  log(`
+  Summary: ${ok}/${total} ok, ${failed} failed`);
+  if (errors.length) {
+    log(`  Errors:`);
+    for (const err of errors) {
+      log(`    - ${err}`);
+    }
+  }
+  return { calls, outDir, summary };
+}
 var fs4, path4, import_node_child_process, import_node_path;
 var init_DiagnosticsTools = __esm({
   "src/debug/DiagnosticsTools.ts"() {
@@ -7444,6 +7615,7 @@ __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,
@@ -7485,6 +7657,7 @@ __export(index_exports, {
   buildSirenTimesXml: () => buildSirenTimesXml,
   buildStartZoomFocusXml: () => buildStartZoomFocusXml,
   buildWhiteLedStateXml: () => buildWhiteLedStateXml,
+  captureModelFixtures: () => captureModelFixtures,
   collectCgiDiagnostics: () => collectCgiDiagnostics,
   collectMultifocalDiagnostics: () => collectMultifocalDiagnostics,
   collectNativeDiagnostics: () => collectNativeDiagnostics,
@@ -7566,6 +7739,7 @@ __export(index_exports, {
   splitH265AnnexBToNalPayloads: () => splitAnnexBToNalPayloads2,
   testChannelStreams: () => testChannelStreams,
   xmlEscape: () => xmlEscape,
+  xmlIndicatesFloodlight: () => xmlIndicatesFloodlight,
   zipDirectory: () => zipDirectory
 });
 module.exports = __toCommonJS(index_exports);
@@ -9261,6 +9435,22 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
   static coverPreviewBackoffMs = /* @__PURE__ */ new Map();
   static COVER_PREVIEW_INITIAL_BACKOFF_MS = 1e3;
   static COVER_PREVIEW_MAX_BACKOFF_MS = 3e4;
+  /**
+   * Per-client snapshot (cmd_id=109) serialization queue.
+   * 
+   * WHY: On NVR/multi-camera devices sharing one socket, concurrent snapshot requests
+   * can cause JPEG data to mix (even with per-request msgNum filtering):
+   * - Camera A and B both send frames on same socket
+   * - Frame listener is global per socket
+   * - Timing quirks can cause chunk reordering or listener confusion
+   * 
+   * FIX: Serialize all cmd_id=109 requests on THIS client instance.
+   * Each snapshot waits for previous one to complete before starting.
+   * This ensures clean frame sequences per request, zero data corruption.
+   * 
+   * Impact: Snapshots are ~0–50ms slower per camera (negligible for users).
+   */
+  snapshotQueueTail = Promise.resolve();
   opts;
   debugCfg;
   logger;
@@ -11742,6 +11932,20 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
     });
   }
   async sendBinarySnapshot109(params) {
+    const prevTail = this.snapshotQueueTail;
+    let resolve;
+    const newTail = new Promise((r) => {
+      resolve = r;
+    });
+    this.snapshotQueueTail = newTail;
+    try {
+      await prevTail;
+      return await this.sendBinarySnapshot109Impl(params);
+    } finally {
+      resolve();
+    }
+  }
+  async sendBinarySnapshot109Impl(params) {
     await this.connect();
     const channel = params.channel ?? this.opts.channel ?? 0;
     const channelId = params.channelIdOverride ?? (params.channel == null ? this.hostChannelId : channel + 1);
@@ -11801,7 +12005,8 @@ var BaichuanClient = class _BaichuanClient extends import_node_events2.EventEmit
       };
       const onFrame = (frame) => {
         if (frame.header.cmdId !== cmdId) return;
-        if (frame.header.msgNum === msgNum && frame.header.responseCode >= 400) {
+        if (frame.header.msgNum !== msgNum) return;
+        if (frame.header.responseCode >= 400) {
           fail(
             new Error(
               `Baichuan snapshot request rejected (cmdId=${cmdId} msgNum=${msgNum} responseCode=${frame.header.responseCode})`
@@ -15285,6 +15490,17 @@ function computeDeviceCapabilities(params) {
   if (ptzMode !== void 0) result.ptzMode = ptzMode;
   return result;
 }
+function xmlIndicatesFloodlight(xml) {
+  if (/(<FloodlightTask\b|<FloodlightManual\b|<FloodlightStatusList\b)/i.test(
+    xml
+  )) {
+    return true;
+  }
+  if (/<WhiteLed\b/i.test(xml)) {
+    return /(<brightness_cur>|<bright>|<LightingSchedule\b)/i.test(xml);
+  }
+  return false;
+}
 
 // src/reolink/baichuan/utils/abilityInfo.ts
 init_xml();
@@ -24321,9 +24537,7 @@ ${stderr}`)
         `probeFloodlightSupportByCmd289: received XML for channel ${ch}:
 ${xml}`
       );
-      return /(<FloodlightTask\b|<FloodlightManual\b|<FloodlightStatusList\b|<WhiteLed\b)/i.test(
-        xml
-      );
+      return xmlIndicatesFloodlight(xml);
     } catch {
       return false;
     }
@@ -32724,8 +32938,529 @@ async function createReplayHttpServer(options) {
 // src/index.ts
 init_BaichuanVideoStream();
 
-// src/baichuan/stream/BaichuanHttpStreamServer.ts
+// src/baichuan/stream/Go2rtcTcpServer.ts
 var import_node_events6 = 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_events6.EventEmitter {
+  api;
+  channel;
+  profile;
+  variant;
+  listenHost;
+  listenPort;
+  logger;
+  deviceId;
+  gracePeriodMs;
+  prebufferMaxMs;
+  maxBufferBytes;
+  prestartStream;
+  active = false;
+  server;
+  resolvedPort;
+  // Native stream
+  nativeFanout = null;
+  nativeStreamActive = false;
+  dedicatedSessionRelease;
+  detectedVideoType;
+  // Client tracking
+  connectedClients = /* @__PURE__ */ new Set();
+  clientSockets = /* @__PURE__ */ new Map();
+  stopGraceTimer;
+  // Prebuffer
+  prebuffer = [];
+  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.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);
+    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;
+  }
+  // -----------------------------------------------------------------------
+  // 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 = () => {
+      this.removeClient(clientId);
+      socket.destroy();
+    };
+    socket.on("error", cleanup);
+    socket.on("close", cleanup);
+  }
+  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);
+    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}`
+      );
+      for (const entry of replay) {
+        if (socket.destroyed) return;
+        socket.write(entry.data);
+      }
+    }
+    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++;
+        const annexB = this.convertFrame(frame);
+        if (!annexB) continue;
+        if (!seenKeyframe) {
+          if (!this.isAnnexBKeyframe(annexB, frame.videoType)) continue;
+          seenKeyframe = true;
+          this.logger.info?.(
+            `[Go2rtcTcpServer] first live keyframe  client=${clientId} after ${liveFrameCount} frames`
+          );
+        }
+        socket.write(annexB);
+        liveVideoWritten++;
+        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 frame to wire-ready Annex-B.
+   * Audio frames are skipped — raw TCP carries only video (Annex-B).
+   * go2rtc auto-detects the codec from SPS/PPS/VPS NALUs.
+   */
+  convertFrame(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;
+  }
+  // -----------------------------------------------------------------------
+  // Native stream management
+  // -----------------------------------------------------------------------
+  async startNativeStream() {
+    if (this.nativeStreamActive) 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}`
+    );
+    this.nativeFanout = new NativeStreamFanout2({
+      maxQueueItems: 200,
+      createSource: () => createNativeStream(this.api, this.channel, this.profile, {
+        variant: this.variant,
+        ...dedicatedClient ? { client: dedicatedClient } : {}
+      }),
+      onFrame: (frame) => {
+        if (!frame.audio && (frame.videoType === "H264" || frame.videoType === "H265")) {
+          this.detectedVideoType = frame.videoType;
+        }
+        const wireData = this.convertFrame(frame);
+        if (!wireData || wireData.length === 0) return;
+        const isKeyframe = !frame.audio && this.isAnnexBKeyframe(wireData, frame.videoType);
+        this.prebuffer.push({
+          data: Buffer.from(wireData),
+          time: Date.now(),
+          isKeyframe,
+          audio: frame.audio
+        });
+        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.nativeStreamActive) return;
+        this.nativeStreamActive = false;
+        this.nativeFanout = null;
+        if (this.dedicatedSessionRelease) {
+          this.dedicatedSessionRelease().catch(() => {
+          });
+          this.dedicatedSessionRelease = void 0;
+        }
+        if (this.active && (this.connectedClients.size > 0 || this.prestartStream)) {
+          this.logger.info?.(
+            `[Go2rtcTcpServer] native stream ended, restarting (clients=${this.connectedClients.size}, prestart=${this.prestartStream})`
+          );
+          this.startNativeStream();
+        }
+      }
+    });
+    this.nativeFanout.start();
+  }
+  async stopNativeStream() {
+    this.nativeStreamActive = false;
+    const fanout = this.nativeFanout;
+    this.nativeFanout = null;
+    if (fanout) {
+      await fanout.stop();
+    }
+    this.prebuffer = [];
+    if (this.dedicatedSessionRelease) {
+      await this.dedicatedSessionRelease().catch(() => {
+      });
+      this.dedicatedSessionRelease = void 0;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Client lifecycle
+  // -----------------------------------------------------------------------
+  removeClient(clientId) {
+    if (!this.connectedClients.has(clientId)) return;
+    this.connectedClients.delete(clientId);
+    this.clientSockets.delete(clientId);
+    this.logger.info?.(
+      `[Go2rtcTcpServer] client disconnected  id=${clientId} remaining=${this.connectedClients.size}`
+    );
+    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_events7 = require("events");
 var import_node_child_process9 = require("child_process");
 var http4 = __toESM(require("http"), 1);
 var NAL_START_CODE_4B4 = Buffer.from([0, 0, 0, 1]);
@@ -32772,7 +33507,7 @@ function isH264KeyframeFromAnnexB(annexB) {
   }
   return false;
 }
-var BaichuanHttpStreamServer = class extends import_node_events6.EventEmitter {
+var BaichuanHttpStreamServer = class extends import_node_events7.EventEmitter {
   videoStream;
   listenPort;
   path;
@@ -33039,15 +33774,15 @@ var BaichuanHttpStreamServer = class extends import_node_events6.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanMjpegServer.ts
-var import_node_events8 = require("events");
+var import_node_events9 = require("events");
 var http5 = __toESM(require("http"), 1);
 
 // src/baichuan/stream/MjpegTransformer.ts
-var import_node_events7 = require("events");
+var import_node_events8 = require("events");
 var import_node_child_process10 = require("child_process");
 var JPEG_SOI = Buffer.from([255, 216]);
 var JPEG_EOI = Buffer.from([255, 217]);
-var MjpegTransformer = class extends import_node_events7.EventEmitter {
+var MjpegTransformer = class extends import_node_events8.EventEmitter {
   options;
   ffmpeg = null;
   started = false;
@@ -33246,7 +33981,7 @@ Content-Length: ${frame.length}\r
 // src/baichuan/stream/BaichuanMjpegServer.ts
 init_H264Converter();
 init_H265Converter();
-var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
+var BaichuanMjpegServer = class extends import_node_events9.EventEmitter {
   options;
   clients = /* @__PURE__ */ new Map();
   httpServer = null;
@@ -33527,7 +34262,7 @@ var BaichuanMjpegServer = class extends import_node_events8.EventEmitter {
 };
 
 // src/baichuan/stream/BaichuanWebRTCServer.ts
-var import_node_events9 = require("events");
+var import_node_events10 = require("events");
 init_BcMediaAnnexBDecoder();
 init_H264Converter();
 function parseAnnexBNalUnits(annexB) {
@@ -33564,7 +34299,7 @@ function getH264NalType(nalUnit) {
 function getH265NalType2(nalUnit) {
   return nalUnit[0] >> 1 & 63;
 }
-var BaichuanWebRTCServer = class extends import_node_events9.EventEmitter {
+var BaichuanWebRTCServer = class extends import_node_events10.EventEmitter {
   options;
   sessions = /* @__PURE__ */ new Map();
   sessionIdCounter = 0;
@@ -34466,7 +35201,7 @@ Error: ${err}`
 };
 
 // src/baichuan/stream/BaichuanHlsServer.ts
-var import_node_events10 = require("events");
+var import_node_events11 = 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);
@@ -34546,7 +35281,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events11.EventEmitter {
   api;
   channel;
   profile;
@@ -35547,10 +36282,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events11 = require("events");
+var import_node_events12 = require("events");
 var import_node_child_process12 = require("child_process");
-var net4 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events11.EventEmitter {
+var net5 = __toESM(require("net"), 1);
+var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -35616,7 +36351,7 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
     const width = widerStreamInfo?.width ?? 1920;
     const height = widerStreamInfo?.height ?? 1080;
     const fps = widerStreamInfo?.frameRate ?? 25;
-    this.rtspServer = net4.createServer((socket) => {
+    this.rtspServer = net5.createServer((socket) => {
       this.handleRtspConnection(socket);
     });
     await new Promise((resolve, reject) => {
@@ -35892,6 +36627,7 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   DUAL_LENS_DUAL_MOTION_MODELS,
   DUAL_LENS_MODELS,
   DUAL_LENS_SINGLE_MOTION_MODELS,
+  Go2rtcTcpServer,
   H264RtpDepacketizer,
   H265RtpDepacketizer,
   HlsSessionManager,
@@ -35933,6 +36669,7 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   buildSirenTimesXml,
   buildStartZoomFocusXml,
   buildWhiteLedStateXml,
+  captureModelFixtures,
   collectCgiDiagnostics,
   collectMultifocalDiagnostics,
   collectNativeDiagnostics,
@@ -36014,6 +36751,7 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   splitH265AnnexBToNalPayloads,
   testChannelStreams,
   xmlEscape,
+  xmlIndicatesFloodlight,
   zipDirectory
 });
 //# sourceMappingURL=index.cjs.map