@apocaliss92/nodelink-js 0.2.5 → 0.3.5

package/dist/index.cjs

@@ -7444,6 +7444,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,
@@ -7511,7 +7512,11 @@ __export(index_exports, {
   detectIosClient: () => detectIosClient,
   detectVideoCodecFromNal: () => detectVideoCodecFromNal,
   discoverReolinkDevices: () => discoverReolinkDevices,
+  discoverViaArpTable: () => discoverViaArpTable,
+  discoverViaDhcpListener: () => discoverViaDhcpListener,
   discoverViaHttpScan: () => discoverViaHttpScan,
+  discoverViaOnvif: () => discoverViaOnvif,
+  discoverViaTcpPortScan: () => discoverViaTcpPortScan,
   discoverViaUdpBroadcast: () => discoverViaUdpBroadcast,
   discoverViaUdpDirect: () => discoverViaUdpDirect,
   encodeHeader: () => encodeHeader,
@@ -9257,6 +9262,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;
@@ -11738,6 +11759,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);
@@ -11797,7 +11832,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})`
@@ -13379,14 +13415,16 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
 `;
           }
           if (body) {
-            response += `Content-Length: ${Buffer.byteLength(body, "utf8")}\r
+            const bodyBuf = Buffer.from(body, "utf8");
+            response += `Content-Length: ${bodyBuf.length}\r
 `;
+            response += "\r\n";
+            socket.write(response);
+            socket.write(bodyBuf);
+          } else {
+            response += "\r\n";
+            socket.write(response);
           }
-          response += "\r\n";
-          if (body) {
-            response += body;
-          }
-          socket.write(response);
         };
         this.rtspDebugLog(`RTSP ${method} ${url}`);
         if (this.requireAuth) {
@@ -13596,10 +13634,25 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
               );
             }
           }
-          sendResponse(200, "OK", {
-            Session: sessionId,
-            Range: "npt=0.000-"
-          });
+          {
+            const baseUrl = `rtsp://${this.listenHost}:${this.listenPort}${this.path}`;
+            const resources = this.clientResources.get(clientId);
+            const rtpInfoParts = [];
+            if (resources?.setupTrack0) {
+              rtpInfoParts.push(`url=${baseUrl}/track0`);
+            }
+            if (resources?.setupTrack1) {
+              rtpInfoParts.push(`url=${baseUrl}/track1`);
+            }
+            const playHeaders = {
+              Session: sessionId,
+              Range: "npt=now-"
+            };
+            if (rtpInfoParts.length > 0) {
+              playHeaders["RTP-Info"] = rtpInfoParts.join(",");
+            }
+            sendResponse(200, "OK", playHeaders);
+          }
         } else if (method === "TEARDOWN") {
           this.logger.info(
             `[rebroadcast] TEARDOWN  client=${clientId} session=${sessionId}`
@@ -13629,6 +13682,8 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
     sdp += `c=IN IP4 ${this.listenHost}\r
 `;
     sdp += "t=0 0\r\n";
+    sdp += "a=range:npt=now-\r\n";
+    sdp += "a=control:*\r\n";
     sdp += `m=video 0 RTP/AVP ${videoPayloadType}\r
 `;
     sdp += `a=rtpmap:${videoPayloadType} ${codec}/90000\r
@@ -14571,7 +14626,14 @@ var BaichuanRtspServer = class _BaichuanRtspServer extends import_node_events4.E
         this.firstFramePromise = null;
         this.firstFrameResolve = null;
         this.nativeFanout = null;
-        this.prebuffer = [];
+        for (const [, resources] of this.clientResources) {
+          const res = resources;
+          res.rtpVideoBaseMicroseconds = void 0;
+          res.rtpVideoBaseTimestamp = void 0;
+          res.rtpVideoLastTimestamp = void 0;
+          res.seenFirstVideoKeyframe = false;
+          res.rtpSentVideoConfig = false;
+        }
         if (this.dedicatedSessionRelease) {
           const release = this.dedicatedSessionRelease;
           this.dedicatedSessionRelease = void 0;
@@ -22571,13 +22633,13 @@ ${stderr}`)
    */
   async muxToMp4(params) {
     const { spawn: spawn12 } = await import("child_process");
-    const { randomUUID: randomUUID2 } = await import("crypto");
+    const { randomUUID: randomUUID3 } = await import("crypto");
     const fs6 = await import("fs/promises");
     const os2 = await import("os");
     const path6 = await import("path");
     const ffmpeg = params.ffmpegPath ?? "ffmpeg";
     const tmpDir = os2.tmpdir();
-    const id = randomUUID2();
+    const id = randomUUID3();
     const videoFormat = params.videoCodec === "H265" ? "hevc" : "h264";
     const videoPath = path6.join(tmpDir, `reolink-${id}.${videoFormat}`);
     const outputPath = path6.join(tmpDir, `reolink-${id}.mp4`);
@@ -27918,9 +27980,14 @@ function buildHlsRedirectUrl(originalUrl) {
 }
 
 // src/reolink/discovery.ts
+var import_node_child_process4 = require("child_process");
+var import_node_crypto3 = require("crypto");
 var import_node_dgram2 = __toESM(require("dgram"), 1);
+var net3 = __toESM(require("net"), 1);
 var import_node_os2 = require("os");
+var import_node_util = require("util");
 init_ReolinkCgiApi();
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process4.execFile);
 async function discoverViaUdpDirect(host, options) {
   if (!options.enableUdpDiscovery) return [];
   const logger = options.logger;
@@ -28282,6 +28349,348 @@ async function discoverViaUdpBroadcast(options) {
     });
   });
 }
+var REOLINK_MAC_PREFIXES = [
+  "EC:71:DB",
+  // Most common Reolink OUI
+  "2C:1B:3A",
+  // WiFi cameras (E1 Zoom, etc.)
+  "18:2C:65",
+  // Battery cameras (Video Doorbell, Argus, etc.)
+  "DC:E5:37",
+  // Some newer models
+  "9C:8E:CD",
+  // Some WiFi models
+  "B4:4B:D6",
+  // Some models
+  "E4:3D:1A"
+  // Some models
+];
+async function discoverViaArpTable(options) {
+  if (!options.enableArpLookup) return [];
+  const logger = options.logger;
+  logger?.log?.("[Discovery] Starting ARP table lookup for Reolink MAC prefix...");
+  const discovered = [];
+  try {
+    let entries = [];
+    if ((0, import_node_os2.platform)() === "linux") {
+      try {
+        const { readFile } = await import("fs/promises");
+        const content = await readFile("/proc/net/arp", "utf8");
+        for (const line of content.split("\n").slice(1)) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length >= 4 && parts[0] && parts[3] && parts[3] !== "00:00:00:00:00:00") {
+            entries.push({ ip: parts[0], mac: parts[3].toUpperCase() });
+          }
+        }
+      } catch {
+        const { stdout } = await runArpCommand();
+        entries = parseArpOutput(stdout);
+      }
+    } else {
+      const { stdout } = await runArpCommand();
+      entries = parseArpOutput(stdout);
+    }
+    logger?.log?.(`[Discovery] ARP table has ${entries.length} entries`);
+    for (const { ip, mac } of entries) {
+      const isReolink = REOLINK_MAC_PREFIXES.some(
+        (prefix) => mac.startsWith(prefix)
+      );
+      if (isReolink) {
+        logger?.log?.(`[Discovery] Found Reolink device via ARP: ${ip} (MAC: ${mac})`);
+        discovered.push({
+          host: ip,
+          discoveryMethod: "arp"
+        });
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger?.warn?.(`[Discovery] ARP table lookup failed: ${msg}`);
+  }
+  logger?.log?.(`[Discovery] ARP lookup complete. Found ${discovered.length} device(s).`);
+  return discovered;
+}
+async function runArpCommand() {
+  const paths = ["/usr/sbin/arp", "/sbin/arp", "/usr/bin/arp", "arp"];
+  for (const arpPath of paths) {
+    try {
+      return await execFileAsync(arpPath, ["-an"], { timeout: 5e3 });
+    } catch {
+    }
+  }
+  throw new Error("arp command not found");
+}
+function parseArpOutput(stdout) {
+  const results = [];
+  for (const line of stdout.split("\n")) {
+    const match = /\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-fA-F:]+)/i.exec(line);
+    if (match && match[1] && match[2] && match[2] !== "(incomplete)") {
+      results.push({ ip: match[1], mac: match[2].toUpperCase() });
+    }
+  }
+  return results;
+}
+async function discoverViaDhcpListener(options) {
+  if (!options.enableDhcpListener) return [];
+  const logger = options.logger;
+  const timeoutMs = options.dhcpListenerTimeoutMs ?? 1e4;
+  logger?.log?.(`[Discovery] Starting passive DHCP listener (${timeoutMs}ms)...`);
+  const discovered = /* @__PURE__ */ new Map();
+  return new Promise((resolve) => {
+    let socket;
+    let timeout;
+    try {
+      socket = import_node_dgram2.default.createSocket({ type: "udp4", reuseAddr: true });
+    } catch (err) {
+      logger?.warn?.(`[Discovery] DHCP: failed to create socket: ${err instanceof Error ? err.message : String(err)}`);
+      resolve([]);
+      return;
+    }
+    socket.on("message", (msg) => {
+      try {
+        if (msg.length < 240) return;
+        const op = msg[0];
+        const hlen = msg[2];
+        if (hlen !== 6) return;
+        const mac = [
+          msg[28]?.toString(16).padStart(2, "0"),
+          msg[29]?.toString(16).padStart(2, "0"),
+          msg[30]?.toString(16).padStart(2, "0"),
+          msg[31]?.toString(16).padStart(2, "0"),
+          msg[32]?.toString(16).padStart(2, "0"),
+          msg[33]?.toString(16).padStart(2, "0")
+        ].join(":").toUpperCase();
+        const isReolinkMac = REOLINK_MAC_PREFIXES.some((p) => mac.startsWith(p));
+        let hostname = "";
+        let i = 240;
+        while (i < msg.length - 1) {
+          const optType = msg[i];
+          if (optType === 255) break;
+          if (optType === 0) {
+            i++;
+            continue;
+          }
+          const optLen = msg[i + 1] ?? 0;
+          if (optType === 12 && optLen > 0) {
+            hostname = msg.subarray(i + 2, i + 2 + optLen).toString("ascii").toLowerCase();
+          }
+          i += 2 + optLen;
+        }
+        const isReolinkHostname = hostname.startsWith("reolink");
+        if (!isReolinkMac && !isReolinkHostname) return;
+        const yiaddr = `${msg[16]}.${msg[17]}.${msg[18]}.${msg[19]}`;
+        const ciaddr = `${msg[12]}.${msg[13]}.${msg[14]}.${msg[15]}`;
+        const ip = yiaddr !== "0.0.0.0" ? yiaddr : ciaddr;
+        if (ip === "0.0.0.0" || !ip) return;
+        if (!discovered.has(ip)) {
+          logger?.log?.(`[Discovery] DHCP: found Reolink device ${ip} (MAC: ${mac}, hostname: ${hostname || "n/a"}, op: ${op === 1 ? "request" : "reply"})`);
+          const device = {
+            host: ip,
+            discoveryMethod: "dhcp"
+          };
+          if (hostname) device.name = hostname;
+          discovered.set(ip, device);
+        }
+      } catch {
+      }
+    });
+    socket.on("error", (err) => {
+      logger?.warn?.(`[Discovery] DHCP socket error: ${err.message}`);
+      clearTimeout(timeout);
+      socket.close();
+      resolve(Array.from(discovered.values()));
+    });
+    socket.bind(67, "0.0.0.0", () => {
+      logger?.log?.("[Discovery] DHCP listener bound on port 67");
+      timeout = setTimeout(() => {
+        socket.close();
+        logger?.log?.(`[Discovery] DHCP listener complete. Found ${discovered.size} device(s).`);
+        resolve(Array.from(discovered.values()));
+      }, timeoutMs);
+    });
+  });
+}
+function probeTcpPort(ip, port, timeoutMs) {
+  return new Promise((resolve) => {
+    const socket = new net3.Socket();
+    let settled = false;
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.on("connect", () => done(true));
+    socket.on("timeout", () => done(false));
+    socket.on("error", () => done(false));
+    socket.connect(port, ip);
+  });
+}
+async function discoverViaTcpPortScan(options) {
+  if (!options.enableTcpPortScan) return [];
+  const logger = options.logger;
+  const networkCidr = options.networkCidr ?? getLocalNetworks()[0];
+  const timeoutMs = options.tcpProbeTimeoutMs ?? 1500;
+  const maxConcurrent = options.maxConcurrentProbes ?? 80;
+  if (!networkCidr) {
+    logger?.warn?.("[Discovery] No network CIDR available for TCP port scan");
+    return [];
+  }
+  logger?.log?.(`[Discovery] Starting TCP port 9000 scan on network ${networkCidr}...`);
+  const ipRange = parseCidr(networkCidr);
+  if (!ipRange) {
+    logger?.warn?.(`[Discovery] Invalid CIDR: ${networkCidr}`);
+    return [];
+  }
+  const discovered = [];
+  const ipAddresses = [];
+  for (let ipNum = ipRange.start; ipNum <= ipRange.end && ipNum <= ipRange.start + 254; ipNum++) {
+    ipAddresses.push(ipNumberToString(ipNum));
+  }
+  logger?.log?.(`[Discovery] Scanning ${ipAddresses.length} IPs on port 9000...`);
+  for (let i = 0; i < ipAddresses.length; i += maxConcurrent) {
+    const batch = ipAddresses.slice(i, i + maxConcurrent);
+    const batchResults = await Promise.allSettled(
+      batch.map(async (ip) => {
+        const open = await probeTcpPort(ip, 9e3, timeoutMs);
+        if (open) {
+          logger?.log?.(`[Discovery] Found Baichuan device at ${ip}:9000`);
+          return { host: ip, discoveryMethod: "tcp_port_scan" };
+        }
+        return null;
+      })
+    );
+    for (const result of batchResults) {
+      if (result.status === "fulfilled" && result.value) {
+        discovered.push(result.value);
+      }
+    }
+  }
+  logger?.log?.(`[Discovery] TCP port scan complete. Found ${discovered.length} device(s).`);
+  return discovered;
+}
+async function discoverViaOnvif(options) {
+  if (!options.enableOnvifDiscovery) return [];
+  const logger = options.logger;
+  const timeoutMs = options.onvifDiscoveryTimeoutMs ?? 5e3;
+  logger?.log?.(`[Discovery] Starting ONVIF WS-Discovery (${timeoutMs}ms)...`);
+  const discovered = /* @__PURE__ */ new Map();
+  const MULTICAST_ADDR = "239.255.255.250";
+  const MULTICAST_PORT = 3702;
+  const messageId = `uuid:${(0, import_node_crypto3.randomUUID)()}`;
+  const probeMessage = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope"',
+    '  xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing"',
+    '  xmlns:d="http://schemas.xmlsoap.org/ws/2005/04/discovery"',
+    '  xmlns:dn="http://www.onvif.org/ver10/network/wsdl">',
+    "  <s:Header>",
+    `    <a:MessageID>${messageId}</a:MessageID>`,
+    "    <a:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</a:To>",
+    "    <a:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</a:Action>",
+    "  </s:Header>",
+    "  <s:Body>",
+    "    <d:Probe>",
+    "      <d:Types>dn:NetworkVideoTransmitter</d:Types>",
+    "    </d:Probe>",
+    "  </s:Body>",
+    "</s:Envelope>"
+  ].join("\n");
+  return new Promise((resolve) => {
+    const socket = import_node_dgram2.default.createSocket({ type: "udp4", reuseAddr: true });
+    let timeout;
+    socket.on("message", (msg, rinfo) => {
+      try {
+        const xml = msg.toString("utf8");
+        const xaddrsMatch = /<[^:]*:?XAddrs>([^<]+)<\/[^:]*:?XAddrs>/i.exec(xml);
+        const scopesMatch = /<[^:]*:?Scopes>([^<]+)<\/[^:]*:?Scopes>/i.exec(xml);
+        let host = rinfo.address;
+        let httpPort;
+        if (xaddrsMatch?.[1]) {
+          const urls = xaddrsMatch[1].trim().split(/\s+/);
+          for (const url of urls) {
+            try {
+              const parsed = new URL(url);
+              if (parsed.hostname) {
+                host = parsed.hostname;
+                const p = Number.parseInt(parsed.port, 10);
+                if (p && p !== 80) httpPort = p;
+                break;
+              }
+            } catch {
+            }
+          }
+        }
+        if (discovered.has(host)) return;
+        let model;
+        let name;
+        let manufacturer;
+        if (scopesMatch?.[1]) {
+          const scopes = scopesMatch[1].trim().split(/\s+/);
+          for (const scope of scopes) {
+            const hwMatch = /\/hardware\/(.+)$/i.exec(scope);
+            if (hwMatch?.[1]) model = decodeURIComponent(hwMatch[1]);
+            const nameMatch = /\/name\/(.+)$/i.exec(scope);
+            if (nameMatch?.[1]) name = decodeURIComponent(nameMatch[1]);
+            const mfgMatch = /\/manufacturer\/(.+)$/i.exec(scope);
+            if (mfgMatch?.[1]) manufacturer = decodeURIComponent(mfgMatch[1]);
+          }
+        }
+        const allText = `${manufacturer ?? ""} ${model ?? ""} ${xaddrsMatch?.[1] ?? ""}`.toLowerCase();
+        const hasReolinkText = allText.includes("reolink");
+        const hasReolinkModel = /^(rlc|rln|rl[ncb]|e1|cw|cx|duo|trackmix|argus|lumus|go|video doorbell|reolink)/i.test(model ?? "");
+        const isReolink = hasReolinkText || hasReolinkModel;
+        if (!isReolink) {
+          logger?.debug?.(`[Discovery] ONVIF: skipping non-Reolink device at ${host} (${model ?? "unknown"}, manufacturer: ${manufacturer ?? "unknown"})`);
+          return;
+        }
+        logger?.log?.(`[Discovery] ONVIF: found Reolink device at ${host}${model ? ` (${model})` : ""}${name ? ` name="${name}"` : ""}`);
+        const device = {
+          host,
+          discoveryMethod: "onvif"
+        };
+        if (model) device.model = model;
+        if (name && name !== "IPC") {
+          device.name = name;
+        } else if (model) {
+          device.name = model;
+        }
+        if (httpPort) device.httpPort = httpPort;
+        discovered.set(host, device);
+      } catch {
+      }
+    });
+    socket.on("error", (err) => {
+      logger?.warn?.(`[Discovery] ONVIF socket error: ${err.message}`);
+    });
+    socket.bind(0, "0.0.0.0", () => {
+      const buf = Buffer.from(probeMessage, "utf8");
+      socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR, (err) => {
+        if (err) {
+          logger?.warn?.(`[Discovery] ONVIF: failed to send probe: ${err.message}`);
+        }
+      });
+      setTimeout(() => {
+        try {
+          socket.send(buf, 0, buf.length, MULTICAST_PORT, MULTICAST_ADDR);
+        } catch {
+        }
+      }, 500);
+      timeout = setTimeout(() => {
+        try {
+          socket.close();
+        } catch {
+        }
+        logger?.log?.(`[Discovery] ONVIF WS-Discovery complete. Found ${discovered.size} device(s).`);
+        resolve(Array.from(discovered.values()));
+      }, timeoutMs);
+    });
+    socket.on("close", () => {
+      if (timeout) clearTimeout(timeout);
+    });
+  });
+}
 async function discoverReolinkDevices(options = {}) {
   const logger = options.logger;
   logger?.log?.("[Discovery] Starting Reolink device discovery...");
@@ -28304,10 +28713,26 @@ async function discoverReolinkDevices(options = {}) {
       results.push(seenDevices.get(key));
     }
   };
-  const [httpDevices, udpDevices] = await Promise.all([
+  const [httpDevices, udpDevices, tcpDevices, arpDevices, dhcpDevices, onvifDevices] = await Promise.all([
     discoverViaHttpScan(options),
-    discoverViaUdpBroadcast(options)
+    discoverViaUdpBroadcast(options),
+    discoverViaTcpPortScan(options),
+    discoverViaArpTable(options),
+    discoverViaDhcpListener(options),
+    discoverViaOnvif(options)
   ]);
+  for (const device of dhcpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of arpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of tcpDevices) {
+    mergeDevice(device);
+  }
+  for (const device of onvifDevices) {
+    mergeDevice(device);
+  }
   for (const device of httpDevices) {
     mergeDevice(device);
   }
@@ -28325,51 +28750,18 @@ var AutodiscoveryClient = class {
   scanTimer = null;
   isRunning = false;
   currentScanPromise = null;
-  /**
-   * Costruttore del client di autodiscovery.
-   * 
-   * @param options - Opzioni di configurazione per il discovery
-   */
   constructor(options = {}) {
     this.options = {
-      scanIntervalMs: options.scanIntervalMs ?? 6e4,
-      // Default: 60 secondi
+      ...options,
+      scanIntervalMs: options.scanIntervalMs ?? 12e4,
       autoStart: options.autoStart ?? false
     };
-    if (options.networkCidr !== void 0) {
-      this.options.networkCidr = options.networkCidr;
-    }
-    if (options.username !== void 0) {
-      this.options.username = options.username;
-    }
-    if (options.password !== void 0) {
-      this.options.password = options.password;
-    }
-    if (options.httpProbeTimeoutMs !== void 0) {
-      this.options.httpProbeTimeoutMs = options.httpProbeTimeoutMs;
-    }
-    if (options.maxConcurrentProbes !== void 0) {
-      this.options.maxConcurrentProbes = options.maxConcurrentProbes;
-    }
-    if (options.logger !== void 0) {
-      this.options.logger = options.logger;
-    }
-    if (options.httpPorts !== void 0) {
-      this.options.httpPorts = options.httpPorts;
-    }
-    if (options.discoveryMethod !== void 0) {
-      this.options.discoveryMethod = options.discoveryMethod;
-    }
-    if (options.udpBroadcastTimeoutMs !== void 0) {
-      this.options.udpBroadcastTimeoutMs = options.udpBroadcastTimeoutMs;
-    }
     if (this.options.autoStart) {
       this.start();
     }
   }
   /**
-   * Avvia il discovery continuato.
-   * Se già in esecuzione, non fa nulla.
+   * Start continuous discovery. If already running, does nothing.
    */
   start() {
     if (this.isRunning) {
@@ -28384,8 +28776,7 @@ var AutodiscoveryClient = class {
     this.scheduleNextScan();
   }
   /**
-   * Ferma il discovery continuato.
-   * Se non è in esecuzione, non fa nulla.
+   * Stop continuous discovery. If not running, does nothing.
    */
   stop() {
     if (!this.isRunning) {
@@ -28400,50 +28791,41 @@ var AutodiscoveryClient = class {
     this.options.logger?.log?.("[Autodiscovery] Discovery stopped");
   }
   /**
-   * Restituisce la lista corrente delle telecamere discoverate.
-   * 
-   * @returns Array di dispositivi discoverati, ordinati per host
+   * Returns the current list of discovered devices, sorted by host IP.
    */
   getDiscoveredDevices() {
-    return Array.from(this.discoveredDevices.values()).sort((a, b) => {
-      return a.host.localeCompare(b.host);
-    });
+    return Array.from(this.discoveredDevices.values()).sort(
+      (a, b) => a.host.localeCompare(b.host)
+    );
   }
   /**
-   * Restituisce il numero di telecamere attualmente discoverate.
-   * 
-   * @returns Numero di dispositivi discoverati
+   * Returns the number of currently discovered devices.
    */
   getDeviceCount() {
     return this.discoveredDevices.size;
   }
   /**
-   * Verifica se il discovery è attualmente in esecuzione.
-   * 
-   * @returns `true` se il discovery è in esecuzione, `false` altrimenti
+   * Returns whether continuous discovery is currently running.
    */
   isActive() {
     return this.isRunning;
   }
   /**
-   * Forza un scan immediato (non aspetta l'intervallo programmato).
-   * Se uno scan è già in corso, attende il completamento prima di avviarne uno nuovo.
-   * 
-   * @returns Promise che si risolve quando lo scan è completato
+   * Force an immediate scan (doesn't wait for the scheduled interval).
+   * If a scan is already in progress, waits for it to complete.
    */
   async scanNow() {
     if (this.currentScanPromise) {
-      this.options.logger?.log?.("[Autodiscovery] Scan already in progress, waiting for completion...");
+      this.options.logger?.log?.(
+        "[Autodiscovery] Scan already in progress, waiting for completion..."
+      );
       await this.currentScanPromise;
       return;
     }
     await this.performScan();
   }
   /**
-   * Rimuove un dispositivo dalla lista (utile se si sa che non è più disponibile).
-   * 
-   * @param host - Indirizzo IP del dispositivo da rimuovere
-   * @returns `true` se il dispositivo è stato rimosso, `false` se non era presente
+   * Remove a device from the discovered list.
    */
   removeDevice(host) {
     const removed = this.discoveredDevices.delete(host);
@@ -28453,59 +28835,20 @@ var AutodiscoveryClient = class {
     return removed;
   }
   /**
-   * Pulisce tutte le telecamere discoverate dalla lista.
+   * Clear all discovered devices.
    */
   clearDevices() {
     const count = this.discoveredDevices.size;
     this.discoveredDevices.clear();
-    this.options.logger?.log?.(`[Autodiscovery] Removed ${count} device(s) from list`);
+    this.options.logger?.log?.(
+      `[Autodiscovery] Removed ${count} device(s) from list`
+    );
   }
-  /**
-   * Esegue un singolo scan della rete.
-   */
   async performScan() {
     const scanPromise = (async () => {
       try {
         this.options.logger?.log?.("[Autodiscovery] Starting scan...");
-        const discoveryMethod = this.options.discoveryMethod ?? "http";
-        const discoveryOptions = {
-          enableHttpScanning: discoveryMethod === "http" || discoveryMethod === "both",
-          enableUdpDiscovery: discoveryMethod === "udp" || discoveryMethod === "both"
-        };
-        if (this.options.networkCidr !== void 0) {
-          discoveryOptions.networkCidr = this.options.networkCidr;
-        }
-        if (this.options.username !== void 0) {
-          discoveryOptions.username = this.options.username;
-        }
-        if (this.options.password !== void 0) {
-          discoveryOptions.password = this.options.password;
-        }
-        if (this.options.httpProbeTimeoutMs !== void 0) {
-          discoveryOptions.httpProbeTimeoutMs = this.options.httpProbeTimeoutMs;
-        }
-        if (this.options.maxConcurrentProbes !== void 0) {
-          discoveryOptions.maxConcurrentProbes = this.options.maxConcurrentProbes;
-        }
-        if (this.options.logger !== void 0) {
-          discoveryOptions.logger = this.options.logger;
-        }
-        if (this.options.httpPorts !== void 0) {
-          discoveryOptions.httpPorts = this.options.httpPorts;
-        }
-        if (this.options.udpBroadcastTimeoutMs !== void 0) {
-          discoveryOptions.udpBroadcastTimeoutMs = this.options.udpBroadcastTimeoutMs;
-        }
-        let discovered = [];
-        if (discoveryMethod === "http" || discoveryMethod === "both") {
-          const httpDevices = await discoverViaHttpScan(discoveryOptions);
-          discovered.push(...httpDevices);
-        }
-        if (discoveryMethod === "udp" || discoveryMethod === "both") {
-          const udpDevices = await discoverViaUdpBroadcast(discoveryOptions);
-          discovered.push(...udpDevices);
-        }
-        const beforeCount = this.discoveredDevices.size;
+        const discovered = await discoverReolinkDevices(this.options);
         const newDevices = [];
         const updatedDevices = [];
         for (const device of discovered) {
@@ -28520,38 +28863,35 @@ var AutodiscoveryClient = class {
             newDevices.push(device);
           }
         }
-        const afterCount = this.discoveredDevices.size;
         this.options.logger?.log?.(
-          `[Autodiscovery] Scan completed: ${newDevices.length} new, ${updatedDevices.length} updated, total: ${afterCount}`
+          `[Autodiscovery] Scan completed: ${newDevices.length} new, ${updatedDevices.length} updated, total: ${this.discoveredDevices.size}`
         );
         for (const device of newDevices) {
-          const details = [];
-          if (device.model) details.push(`Model: ${device.model}`);
-          if (device.name) details.push(`Name: ${device.name}`);
-          if (device.uid) details.push(`UID: ${device.uid}`);
-          if (device.firmwareVersion) details.push(`Firmware: ${device.firmwareVersion}`);
-          if (device.httpPort) details.push(`HTTP Port: ${device.httpPort}`);
-          if (device.httpsPort) details.push(`HTTPS Port: ${device.httpsPort}`);
-          details.push(`Discovery Method: ${device.discoveryMethod}`);
-          if (device.supportsHttps !== void 0) details.push(`HTTPS: ${device.supportsHttps}`);
-          if (device.httpAccessible !== void 0) details.push(`HTTP Accessible: ${device.httpAccessible}`);
           this.options.logger?.log?.(
-            `[Autodiscovery] \u{1F195} NEW DEVICE DISCOVERED - Host: ${device.host}${details.length > 0 ? ` | ${details.join(" | ")}` : ""}`
+            `[Autodiscovery] NEW DEVICE - ${device.host} | ${device.model ?? "unknown"} | ${device.name ?? ""} | via ${device.discoveryMethod}`
           );
+          try {
+            this.options.onDeviceDiscovered?.(device);
+          } catch {
+          }
+        }
+        for (const device of updatedDevices) {
+          try {
+            this.options.onDeviceUpdated?.(device);
+          } catch {
+          }
         }
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
-        this.options.logger?.error?.(`[Autodiscovery] Error during scan: ${msg}`);
+        this.options.logger?.error?.(
+          `[Autodiscovery] Error during scan: ${msg}`
+        );
       }
     })();
     this.currentScanPromise = scanPromise;
     await scanPromise;
     this.currentScanPromise = null;
   }
-  /**
-   * Unisce le informazioni di un dispositivo esistente con quelle di un nuovo scan.
-   * Restituisce il dispositivo aggiornato se ci sono state modifiche, altrimenti `null`.
-   */
   mergeDeviceInfo(existing, updated) {
     let hasChanges = false;
     if (!existing.model && updated.model) {
@@ -28588,13 +28928,8 @@ var AutodiscoveryClient = class {
     }
     return hasChanges ? existing : null;
   }
-  /**
-   * Programma il prossimo scan.
-   */
   scheduleNextScan() {
-    if (!this.isRunning) {
-      return;
-    }
+    if (!this.isRunning) return;
     this.scanTimer = setTimeout(() => {
       this.scanTimer = null;
       if (this.isRunning) {
@@ -28633,7 +28968,7 @@ function decideVideoclipTranscodeMode(headers, forceMode) {
     };
   }
   const ua = (clientInfo.userAgent ?? "").toLowerCase();
-  const platform = (clientInfo.secChUaPlatform ?? "").toLowerCase().replace(/"/g, "");
+  const platform2 = (clientInfo.secChUaPlatform ?? "").toLowerCase().replace(/"/g, "");
   const isIos = /iphone|ipad|ipod/.test(ua);
   if (isIos) {
     return {
@@ -28650,7 +28985,7 @@ function decideVideoclipTranscodeMode(headers, forceMode) {
       clientInfo
     };
   }
-  const isAndroid = ua.includes("android") || platform === "android";
+  const isAndroid = ua.includes("android") || platform2 === "android";
   if (isAndroid) {
     return {
       mode: "transcode-h264",
@@ -28659,7 +28994,7 @@ function decideVideoclipTranscodeMode(headers, forceMode) {
     };
   }
   const isChromium = ua.includes("chrome") || ua.includes("edg");
-  const isMac = ua.includes("mac os") || platform === "macos";
+  const isMac = ua.includes("mac os") || platform2 === "macos";
   if (isChromium && !isMac) {
     return {
       mode: "transcode-h264",
@@ -28686,7 +29021,7 @@ init_recordingFileName();
 
 // src/reolink/baichuan/endpoints-server.ts
 var import_node_http = __toESM(require("http"), 1);
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 function parseIntParam(v, def) {
   if (v == null) return def;
   const n = Number.parseInt(v, 10);
@@ -28925,7 +29260,7 @@ function createBaichuanEndpointsServer(opts) {
             "Cache-Control": "no-cache",
             Connection: "close"
           });
-          const ff2 = (0, import_node_child_process4.spawn)("ffmpeg", [
+          const ff2 = (0, import_node_child_process5.spawn)("ffmpeg", [
             "-hide_banner",
             "-loglevel",
             "error",
@@ -28958,7 +29293,7 @@ function createBaichuanEndpointsServer(opts) {
         );
         res.setHeader("Cache-Control", "no-cache");
         res.setHeader("Connection", "close");
-        const ff = (0, import_node_child_process4.spawn)("ffmpeg", [
+        const ff = (0, import_node_child_process5.spawn)("ffmpeg", [
           "-hide_banner",
           "-loglevel",
           "error",
@@ -29069,7 +29404,7 @@ init_urls();
 
 // src/rtsp/server.ts
 var import_node_http2 = __toESM(require("http"), 1);
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 init_urls();
 function createRtspProxyServer(opts) {
   return import_node_http2.default.createServer((req, res) => {
@@ -29110,7 +29445,7 @@ function createRtspProxyServer(opts) {
       Connection: "close"
     });
     const rtspTransport = opts.rtspTransport ?? "tcp";
-    const ff = (0, import_node_child_process5.spawn)("ffmpeg", [
+    const ff = (0, import_node_child_process6.spawn)("ffmpeg", [
       "-hide_banner",
       "-loglevel",
       "error",
@@ -29140,7 +29475,7 @@ function createRtspProxyServer(opts) {
 }
 
 // src/rfc/rfc4571.ts
-var import_node_crypto3 = __toESM(require("crypto"), 1);
+var import_node_crypto4 = __toESM(require("crypto"), 1);
 function buildRfc4571Sdp(video, audio) {
   let out = "v=0\r\n";
   out += "o=- 0 0 IN IP4 0.0.0.0\r\n";
@@ -29413,12 +29748,12 @@ function parseAdtsHeader(adtsFrame) {
 var RtpWriter = class {
   constructor(payloadType) {
     this.payloadType = payloadType;
-    this.seq = import_node_crypto3.default.randomBytes(2).readUInt16BE(0);
-    this.timestamp = import_node_crypto3.default.randomBytes(4).readUInt32BE(0);
+    this.seq = import_node_crypto4.default.randomBytes(2).readUInt16BE(0);
+    this.timestamp = import_node_crypto4.default.randomBytes(4).readUInt32BE(0);
   }
   seq = 0;
   timestamp = 0;
-  ssrc = import_node_crypto3.default.randomBytes(4).readUInt32BE(0);
+  ssrc = import_node_crypto4.default.randomBytes(4).readUInt32BE(0);
   setTimestamp(ts) {
     this.timestamp = ts >>> 0;
   }
@@ -29982,8 +30317,8 @@ var import_node_net2 = __toESM(require("net"), 1);
 init_BaichuanVideoStream();
 
 // src/multifocal/compositeStream.ts
-var import_node_child_process6 = require("child_process");
-var import_node_crypto4 = require("crypto");
+var import_node_child_process7 = require("child_process");
+var import_node_crypto5 = require("crypto");
 var import_node_events5 = require("events");
 function calculateOverlayPosition(position, mainWidth, mainHeight, pipWidth, pipHeight, margin) {
   const pipW = Math.floor(pipWidth);
@@ -30094,7 +30429,7 @@ var CompositeStream = class extends import_node_events5.EventEmitter {
     if (!buf?.length) return;
     const head = buf.subarray(0, Math.min(12, buf.length)).toString("hex");
     const slice = buf.subarray(0, Math.min(256, buf.length));
-    const sha1 = (0, import_node_crypto4.createHash)("sha1").update(slice).digest("hex");
+    const sha1 = (0, import_node_crypto5.createHash)("sha1").update(slice).digest("hex");
     return { len: buf.length, headHex: head, sha1_256: sha1 };
   }
   async primeForFfmpeg(gen, timeoutMs, requireKeyframe) {
@@ -30323,7 +30658,7 @@ var CompositeStream = class extends import_node_events5.EventEmitter {
       "pipe:1"
     ];
     this.logger.log?.(`[CompositeStream] Starting ffmpeg (rtsp inputs): ${ffmpegArgs.join(" ")}`);
-    this.ffmpegProcess = (0, import_node_child_process6.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process7.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -30438,7 +30773,7 @@ var CompositeStream = class extends import_node_events5.EventEmitter {
     this.logger.log?.(
       `[CompositeStream] Starting ffmpeg: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process6.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process7.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -32167,7 +32502,7 @@ async function createRfc4571TcpServerForReplay(options) {
 
 // src/rfc/replay-http-server.ts
 var import_node_http3 = __toESM(require("http"), 1);
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_node_stream2 = require("stream");
 async function createReplayHttpServer(options) {
   const {
@@ -32321,7 +32656,7 @@ async function createReplayHttpServer(options) {
       "pipe:1"
     ];
     log(`spawning ffmpeg: ${ffmpegPath} ${ffmpegArgs.join(" ")}`);
-    ffmpegProcess = (0, import_node_child_process7.spawn)(ffmpegPath, ffmpegArgs, {
+    ffmpegProcess = (0, import_node_child_process8.spawn)(ffmpegPath, ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     ffmpegProcess.stdout?.pipe(outputStream).pipe(res);
@@ -32421,34 +32756,555 @@ 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 import_node_child_process8 = require("child_process");
-var http4 = __toESM(require("http"), 1);
-var NAL_START_CODE_4B4 = Buffer.from([0, 0, 0, 1]);
-var NAL_START_CODE_3B3 = Buffer.from([0, 0, 1]);
-function hasAnnexBStart(data) {
-  if (data.length < 4) return false;
-  return data.subarray(0, 4).equals(NAL_START_CODE_4B4) || data.subarray(0, 3).equals(NAL_START_CODE_3B3);
-}
-function splitAnnexBNals(annexB) {
-  const starts = [];
-  for (let i = 0; i < annexB.length - 3; i++) {
-    if (annexB[i] === 0 && annexB[i + 1] === 0) {
-      if (annexB[i + 2] === 1) {
-        starts.push({ idx: i, len: 3 });
-        i += 2;
-      } else if (annexB[i + 2] === 0 && annexB[i + 3] === 1) {
-        starts.push({ idx: i, len: 4 });
-        i += 3;
-      }
-    }
+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);
   }
-  if (starts.length === 0) return [];
-  const out = [];
-  for (let s = 0; s < starts.length; s++) {
-    const start = starts[s];
-    const payloadStart = start.idx + start.len;
+  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]);
+var NAL_START_CODE_3B3 = Buffer.from([0, 0, 1]);
+function hasAnnexBStart(data) {
+  if (data.length < 4) return false;
+  return data.subarray(0, 4).equals(NAL_START_CODE_4B4) || data.subarray(0, 3).equals(NAL_START_CODE_3B3);
+}
+function splitAnnexBNals(annexB) {
+  const starts = [];
+  for (let i = 0; i < annexB.length - 3; i++) {
+    if (annexB[i] === 0 && annexB[i + 1] === 0) {
+      if (annexB[i + 2] === 1) {
+        starts.push({ idx: i, len: 3 });
+        i += 2;
+      } else if (annexB[i + 2] === 0 && annexB[i + 3] === 1) {
+        starts.push({ idx: i, len: 4 });
+        i += 3;
+      }
+    }
+  }
+  if (starts.length === 0) return [];
+  const out = [];
+  for (let s = 0; s < starts.length; s++) {
+    const start = starts[s];
+    const payloadStart = start.idx + start.len;
     const next = starts[s + 1];
     const payloadEnd = next ? next.idx : annexB.length;
     if (payloadEnd > payloadStart) out.push(annexB.subarray(payloadStart, payloadEnd));
@@ -32469,7 +33325,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;
@@ -32533,7 +33389,7 @@ var BaichuanHttpStreamServer = class extends import_node_events6.EventEmitter {
       this.httpServer.on("error", reject);
     });
     this.logger.info(`[BaichuanHttpStreamServer] Starting ffmpeg for H.264 -> MPEG-TS conversion...`);
-    const ffmpeg = (0, import_node_child_process8.spawn)("ffmpeg", [
+    const ffmpeg = (0, import_node_child_process9.spawn)("ffmpeg", [
       "-hide_banner",
       // ffmpeg warnings often include non-fatal decode messages (e.g. decode_slice_header),
       // which we don't want to treat as application errors.
@@ -32736,15 +33592,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_child_process9 = require("child_process");
+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;
@@ -32802,7 +33658,7 @@ var MjpegTransformer = class extends import_node_events7.EventEmitter {
       "pipe:1"
     );
     this.log("debug", `Starting FFmpeg with args: ${args.join(" ")}`);
-    this.ffmpeg = (0, import_node_child_process9.spawn)("ffmpeg", args, {
+    this.ffmpeg = (0, import_node_child_process10.spawn)("ffmpeg", args, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpeg.stdout.on("data", (data) => {
@@ -32943,7 +33799,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;
@@ -33224,7 +34080,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) {
@@ -33261,7 +34117,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;
@@ -34163,12 +35019,12 @@ 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);
 var import_node_path3 = __toESM(require("path"), 1);
-var import_node_child_process10 = require("child_process");
+var import_node_child_process11 = require("child_process");
 init_BcMediaAnnexBDecoder();
 init_H264Converter();
 init_H265Converter();
@@ -34243,7 +35099,7 @@ function getNalTypes(codec, annexB) {
     }
   });
 }
-var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
+var BaichuanHlsServer = class extends import_node_events11.EventEmitter {
   api;
   channel;
   profile;
@@ -34638,7 +35494,7 @@ var BaichuanHlsServer = class extends import_node_events10.EventEmitter {
       this.segmentPattern,
       this.playlistPath
     );
-    const p = (0, import_node_child_process10.spawn)(this.ffmpegPath, args, {
+    const p = (0, import_node_child_process11.spawn)(this.ffmpegPath, args, {
       stdio: ["pipe", "ignore", "pipe"]
     });
     p.on("error", (err) => {
@@ -34736,8 +35592,8 @@ function isTcpFailureThatShouldFallbackToUdp(e) {
 async function pingHost(host, timeoutMs = 3e3) {
   return new Promise((resolve) => {
     const { exec } = require("child_process");
-    const platform = process.platform;
-    const pingCmd = platform === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform === "darwin" ? (
+    const platform2 = process.platform;
+    const pingCmd = platform2 === "win32" ? `ping -n 1 -w ${timeoutMs} ${host}` : platform2 === "darwin" ? (
       // macOS: -W is in milliseconds (Linux: seconds)
       `ping -c 1 -W ${timeoutMs} ${host}`
     ) : (
@@ -35244,10 +36100,10 @@ async function autoDetectDeviceType(inputs) {
 }
 
 // src/multifocal/compositeRtspServer.ts
-var import_node_events11 = require("events");
-var import_node_child_process11 = require("child_process");
-var net3 = __toESM(require("net"), 1);
-var CompositeRtspServer = class extends import_node_events11.EventEmitter {
+var import_node_events12 = require("events");
+var import_node_child_process12 = require("child_process");
+var net5 = __toESM(require("net"), 1);
+var CompositeRtspServer = class extends import_node_events12.EventEmitter {
   options;
   compositeStream = null;
   rtspServer = null;
@@ -35313,7 +36169,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 = net3.createServer((socket) => {
+    this.rtspServer = net5.createServer((socket) => {
       this.handleRtspConnection(socket);
     });
     await new Promise((resolve, reject) => {
@@ -35352,7 +36208,7 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
     this.logger.log?.(
       `[CompositeRtspServer] Starting ffmpeg RTSP server: ${ffmpegArgs.join(" ")}`
     );
-    this.ffmpegProcess = (0, import_node_child_process11.spawn)("ffmpeg", ffmpegArgs, {
+    this.ffmpegProcess = (0, import_node_child_process12.spawn)("ffmpeg", ffmpegArgs, {
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.ffmpegProcess.on("error", (error) => {
@@ -35589,6 +36445,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,
@@ -35656,7 +36513,11 @@ var CompositeRtspServer = class extends import_node_events11.EventEmitter {
   detectIosClient,
   detectVideoCodecFromNal,
   discoverReolinkDevices,
+  discoverViaArpTable,
+  discoverViaDhcpListener,
   discoverViaHttpScan,
+  discoverViaOnvif,
+  discoverViaTcpPortScan,
   discoverViaUdpBroadcast,
   discoverViaUdpDirect,
   encodeHeader,