@apocaliss92/nodelink-js 0.5.1-beta.9 → 0.5.2

package/dist/{chunk-27IU7NXS.js → chunk-7HSTETZR.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-VOPEOB4H.js";
+} from "./chunk-XDVBNZGR.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -178,7 +178,7 @@ import {
   splitAnnexBToNalPayloads2,
   talkTraceLog,
   traceLog
-} from "./chunk-GVWJGQPT.js";
+} from "./chunk-MZUSWKF3.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -292,6 +292,7 @@ var BCUDP_DEFAULT_MTU = 1350;
 var BCUDP_DATA_HEADER_SIZE = 20;
 var BCUDP_DISCOVERY_PORT_LOCAL_ANY = 2015;
 var BCUDP_DISCOVERY_PORT_LOCAL_UID = 2018;
+var BCUDP_DISCOVERY_PORT_P2P_SCAN = 9999;
 
 // src/bcudp/crc.ts
 var table;
@@ -618,6 +619,143 @@ function parseD2cHb(xml) {
   return { cid: Number(cid), did: Number(did) };
 }
 
+// src/cloud/server-binding.ts
+var REOLINK_API_V2_BASE = "https://apis.reolink.com/v2";
+var POSITIVE_TTL_MS = 24 * 60 * 60 * 1e3;
+var NEGATIVE_TTL_MS = 30 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function readCache(uid, now) {
+  const e = cache.get(uid);
+  if (!e) return void 0;
+  if (now >= e.expires) {
+    cache.delete(uid);
+    return void 0;
+  }
+  return e;
+}
+async function getServerBinding(uid, options = {}) {
+  if (!uid || typeof uid !== "string") return void 0;
+  const now = Date.now();
+  const cached = readCache(uid, now);
+  if (cached?.kind === "ok") return cached.response;
+  if (cached?.kind === "err") return void 0;
+  const language = options.language ?? "en";
+  const baseUrl = options.baseUrl ?? REOLINK_API_V2_BASE;
+  const timeoutMs = options.timeoutMs ?? 4e3;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const logger = options.logger;
+  if (typeof fetchImpl !== "function") {
+    logger?.debug?.(
+      `[server-binding] global fetch unavailable; skipping cloud lookup`
+    );
+    cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+    return void 0;
+  }
+  const url = `${baseUrl}/devices/${encodeURIComponent(uid)}/server-binding?language=${encodeURIComponent(language)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method: "GET",
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok) {
+      logger?.debug?.(
+        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText}`
+      );
+      cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+      return void 0;
+    }
+    const json = await res.json();
+    const parsed = parseServerBindingResponse(json);
+    if (!parsed) {
+      logger?.debug?.(
+        `[server-binding] ${uid}: response shape did not match expectations`
+      );
+      cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+      return void 0;
+    }
+    cache.set(uid, {
+      kind: "ok",
+      response: parsed,
+      expires: now + POSITIVE_TTL_MS
+    });
+    const pick = parsed.availableZones.find(
+      (z) => z.status === "active" && z.services.p2p?.server
+    );
+    const hint = pick?.services.p2p?.server ?? parsed.availableZones[0]?.services.p2p?.server;
+    logger?.log?.(
+      `[server-binding] ${uid}: ${parsed.availableZones.length} zone(s)${hint ? `, p2p hint=${hint}` : ""}`
+    );
+    return parsed;
+  } catch (e) {
+    logger?.debug?.(
+      `[server-binding] ${uid}: ${e?.message ?? String(e)}`
+    );
+    cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function pickP2pHostFromBinding(response) {
+  if (!response) return void 0;
+  const zones = response.availableZones;
+  if (!zones || zones.length === 0) return void 0;
+  const active = zones.find(
+    (z) => z.status === "active" && z.services.p2p?.server
+  );
+  if (active?.services.p2p?.server) return active.services.p2p.server;
+  const def = zones.find(
+    (z) => z.status === "default" && z.services.p2p?.server
+  );
+  if (def?.services.p2p?.server) return def.services.p2p.server;
+  const any = zones.find((z) => z.services.p2p?.server);
+  return any?.services.p2p?.server;
+}
+function isString(v) {
+  return typeof v === "string";
+}
+function parseServerBindingResponse(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const rawZones = raw.availableZones;
+  if (!Array.isArray(rawZones)) return void 0;
+  const zones = [];
+  for (const r of rawZones) {
+    if (!r || typeof r !== "object") continue;
+    const rec = r;
+    const id = rec.id;
+    const name = rec.name;
+    const status = rec.status;
+    if (!isString(id) || !isString(name) || !isString(status)) continue;
+    const servicesRaw = rec.services;
+    const services = {};
+    if (servicesRaw && typeof servicesRaw === "object") {
+      const s = servicesRaw;
+      for (const key of ["p2p", "cloud", "roms_ota", "alarm_push"]) {
+        const v = s[key];
+        if (v && typeof v === "object") {
+          const server = v.server;
+          if (isString(server) && server.length > 0) {
+            services[key] = { server };
+          }
+        }
+      }
+    }
+    const locationsRaw = rec.locations;
+    const locations = Array.isArray(locationsRaw) && locationsRaw.every(isString) ? locationsRaw : void 0;
+    zones.push({
+      id,
+      name,
+      status,
+      services,
+      ...locations ? { locations } : {}
+    });
+  }
+  return { availableZones: zones };
+}
+
 // src/bcudp/BcUdpStream.ts
 var AckLatency = class {
   currentValues = [];
@@ -656,6 +794,10 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 var P2P_RELAY_HOSTNAMES = [
+  // Master anycast routers — try first.
+  "p2pm-abr.reolink.com",
+  "p2pm-ali.reolink.com",
+  // Numbered regional relays.
   "p2p.reolink.com",
   "p2p1.reolink.com",
   "p2p2.reolink.com",
@@ -667,13 +809,44 @@ var P2P_RELAY_HOSTNAMES = [
   "p2p8.reolink.com",
   "p2p9.reolink.com",
   "p2p10.reolink.com",
-  "p2p11.reolink.com"
+  "p2p11.reolink.com",
+  // China-region fallbacks (intentionally last).
+  "p2p.reolink.com.cn",
+  "p2p1.reolink.com.cn",
+  "p2p2.reolink.com.cn",
+  "p2p3.reolink.com.cn",
+  "p2p4.reolink.com.cn",
+  "p2p5.reolink.com.cn",
+  "p2p6.reolink.com.cn",
+  "p2p7.reolink.com.cn",
+  "p2p8.reolink.com.cn",
+  "p2p9.reolink.com.cn"
 ];
+function isUnroutableForP2P(ip) {
+  if (!ip) return true;
+  if (ip === "0.0.0.0") return true;
+  if (ip.startsWith("127.")) return true;
+  if (ip.startsWith("10.")) return true;
+  if (ip.startsWith("192.168.")) return true;
+  if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip)) return true;
+  if (/^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./.test(ip)) return true;
+  return false;
+}
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
 var BcUdpStream = class extends EventEmitter {
   opts;
+  /**
+   * Optional info-level logger for diagnostic milestones — set via
+   * {@link BcUdpStream.setLogger} by `BaichuanClient` so the lib's
+   * standard logger sink sees BCUDP / P2P progress (DNS resolutions,
+   * outgoing UDP probes, timeouts with elapsed times) without the user
+   * having to opt into the per-packet `debug` event firehose. Kept
+   * separate from `emit('debug', ...)` because that channel is intended
+   * for the per-packet debug trace and is gated by debugOptions.
+   */
+  discoveryLogger;
   sock;
   remote;
   mtu;
@@ -717,6 +890,17 @@ var BcUdpStream = class extends EventEmitter {
     this.mtu = BCUDP_DEFAULT_MTU;
   }
   /** True if the underlying UDP socket is open and the remote peer is known. */
+  /**
+   * Attach an info-level logger for high-signal diagnostic milestones
+   * (DNS resolution, outgoing UDP probe sends, P2P UID lookup wins/losses,
+   * BCUDP local discovery timeouts). The lib's `BaichuanClient` calls
+   * this immediately after constructing the stream so consumers get
+   * actionable progress logs without enabling the per-packet debug trace.
+   * Safe to call repeatedly; only the most recent logger is used.
+   */
+  setLogger(logger) {
+    this.discoveryLogger = logger;
+  }
   isConnected() {
     return !!this.sock && !!this.remote && this.cameraId != null;
   }
@@ -834,27 +1018,89 @@ var BcUdpStream = class extends EventEmitter {
     this.remote = { host: connected.rhost, port: connected.rport };
   }
   async p2pUidLookup(sock, uid) {
-    const resolved = [];
+    const log = (msg) => this.discoveryLogger?.log?.(`[P2P] ${msg}`);
+    const shortUid = uid.length > 7 ? `${uid.slice(0, 5)}\u2026${uid.slice(-2)}` : uid;
+    const t0 = Date.now();
+    const hostnamesToTry = [];
+    const binding = await getServerBinding(uid, {
+      ...this.discoveryLogger ? { logger: this.discoveryLogger } : {}
+    }).catch(() => void 0);
+    const hintedHost = pickP2pHostFromBinding(binding);
+    if (hintedHost) {
+      hostnamesToTry.push(hintedHost);
+      log(
+        `UID=${shortUid} cloud server-binding \u2192 hint=${hintedHost} (will try first)`
+      );
+    } else {
+      log(
+        `UID=${shortUid} cloud server-binding \u2192 no hint (apis.reolink.com unreachable / no zone match) \u2192 sweeping ${P2P_RELAY_HOSTNAMES.length} fallback hostnames`
+      );
+    }
     for (const host of P2P_RELAY_HOSTNAMES) {
+      if (!hostnamesToTry.includes(host)) hostnamesToTry.push(host);
+    }
+    const resolved = [];
+    const sinkholed = [];
+    for (const host of hostnamesToTry) {
       try {
         const answers = await dns.lookup(host, { family: 4, all: true });
+        let publicCount = 0;
+        let sinkCount = 0;
         for (const a of answers) {
-          if (a.address && !resolved.includes(a.address))
+          if (!a.address) continue;
+          if (isUnroutableForP2P(a.address)) {
+            sinkholed.push({ host, ip: a.address });
+            sinkCount++;
+            continue;
+          }
+          if (!resolved.includes(a.address)) {
             resolved.push(a.address);
+            publicCount++;
+          }
         }
-      } catch {
+        if (sinkCount > 0 && publicCount === 0) {
+          log(
+            `DNS ${host} \u2192 sinkhole (${sinkholed[sinkholed.length - 1]?.ip}) \u2014 DNS filter / /etc/hosts override`
+          );
+        } else if (publicCount > 0) {
+          if (host === hintedHost) {
+            log(`DNS ${host} \u2192 ${answers.find((a) => !isUnroutableForP2P(a.address))?.address} \u2713`);
+          }
+        }
+      } catch (e) {
+        log(`DNS ${host} \u2192 ENOTFOUND/timeout (${e?.code ?? "?"})`);
+      }
+      if (hintedHost && host === hintedHost && resolved.length > 0 && sinkholed.length === 0) {
+        break;
       }
     }
     if (resolved.length === 0) {
+      if (sinkholed.length > 0) {
+        const samples = sinkholed.slice(0, 3).map((s) => `${s.host} \u2192 ${s.ip}`).join(", ");
+        throw new Error(
+          `P2P UID lookup failed: DNS resolves Reolink P2P hostnames to non-routable IPs (${samples}). This is almost certainly an /etc/hosts rewrite or a DNS filter (Pi-hole, AdGuard, NextDNS) blocking *.reolink.com. Battery cameras cannot connect without P2P \u2014 whitelist *.reolink.com (at least p2p*.reolink.com on UDP/9999) or remove the override. Verify with \`getent hosts p2p.reolink.com\` inside your container \u2014 if it differs from \`nslookup p2p.reolink.com\`, the offender is /etc/hosts.`
+        );
+      }
       throw new Error(
-        "P2P UID lookup failed: no p2p.reolink.com addresses resolved"
+        "P2P UID lookup failed: no p2p.reolink.com addresses resolved (DNS failure)"
       );
     }
+    log(
+      `Resolved ${resolved.length} P2P relay IP(s) (${resolved.slice(0, 3).join(", ")}${resolved.length > 3 ? "\u2026" : ""}). Sending C2M_Q probes (3s budget each, ${P2P_MAX_WAIT_MS}ms total)`
+    );
     const start = Date.now();
     let lastErr;
+    let attemptsMade = 0;
     for (const ip of resolved) {
       const remaining = P2P_MAX_WAIT_MS - (Date.now() - start);
-      if (remaining <= 0) break;
+      if (remaining <= 0) {
+        log(
+          `Aborting after ${attemptsMade} attempt(s) \u2014 total budget ${P2P_MAX_WAIT_MS}ms exhausted`
+        );
+        break;
+      }
+      attemptsMade++;
+      const probeStart = Date.now();
       try {
         const res = await this.p2pUidLookupOne(
           sock,
@@ -862,11 +1108,20 @@ var BcUdpStream = class extends EventEmitter {
           { host: ip, port: P2P_LOOKUP_PORT },
           Math.min(remaining, 3e3)
         );
+        log(
+          `${ip}:${P2P_LOOKUP_PORT} replied in ${Date.now() - probeStart}ms \u2713 (total ${Date.now() - t0}ms)`
+        );
         return res;
       } catch (e) {
+        const ms = Date.now() - probeStart;
+        const msg = e?.message ?? String(e);
+        log(`${ip}:${P2P_LOOKUP_PORT} no reply after ${ms}ms (${msg})`);
         lastErr = e instanceof Error ? e : new Error(String(e));
       }
     }
+    log(
+      `Exhausted all ${attemptsMade} relay candidate(s) after ${Date.now() - t0}ms \u2014 UID lookup failed`
+    );
     throw lastErr ?? new Error("P2P UID lookup failed");
   }
   async p2pUidLookupOne(sock, uid, dest, timeoutMs) {
@@ -1181,7 +1436,8 @@ var BcUdpStream = class extends EventEmitter {
       throw new Error("Internal: discoveryUidLocal called for non-uid mode");
     const ports = [
       BCUDP_DISCOVERY_PORT_LOCAL_ANY,
-      BCUDP_DISCOVERY_PORT_LOCAL_UID
+      BCUDP_DISCOVERY_PORT_LOCAL_UID,
+      BCUDP_DISCOVERY_PORT_P2P_SCAN
     ];
     const broadcastHosts = ["255.255.255.255"];
     const ifaces = networkInterfaces();
@@ -1204,13 +1460,23 @@ var BcUdpStream = class extends EventEmitter {
     const directHost = (this.opts.directHost ?? "").trim();
     const localMode = opts?.localMode ?? "local-broadcast";
     const directFirstWindowMs = localMode === "local-direct" && directHost ? 3e3 : 0;
-    const discoveryTimeout = 3e4;
+    const discoveryTimeout = typeof this.opts.localDiscoveryTimeoutMs === "number" && this.opts.localDiscoveryTimeoutMs > 0 ? this.opts.localDiscoveryTimeoutMs : 15e3;
     const retryInterval = 500;
     const startMs = Date.now();
     sock.setBroadcast(true);
     const addr = sock.address();
     const localPort = typeof addr === "string" ? 0 : addr.port;
     const cid = Math.floor(Math.random() * 2147483647) | 0 || 82e3;
+    const log = (msg) => this.discoveryLogger?.log?.(`[BCUDP] ${msg}`);
+    const shortUid = this.opts.uid.length > 7 ? `${this.opts.uid.slice(0, 5)}\u2026${this.opts.uid.slice(-2)}` : this.opts.uid;
+    log(
+      `local discovery: mode=${localMode} uid=${shortUid} ports=[${ports.join(", ")}] broadcasts=[${broadcastHosts.join(", ")}]${directHost ? ` direct=${directHost}` : ""} localBindPort=${localPort} timeout=${discoveryTimeout}ms`
+    );
+    let bytesSent = 0;
+    let pktsRecv = 0;
+    sock.on("message", () => {
+      pktsRecv++;
+    });
     const xml = buildC2dC({
       uid: this.opts.uid,
       clientPort: localPort,
@@ -1221,6 +1487,9 @@ var BcUdpStream = class extends EventEmitter {
       const timeout = setTimeout(() => {
         if (retryTimer) clearInterval(retryTimer);
         sock.off("message", onMsg);
+        log(
+          `local discovery timeout after ${discoveryTimeout}ms \u2014 sent=${bytesSent}B replies=${pktsRecv} (camera likely sleeping / off-LAN / firewall dropping replies)`
+        );
         reject(
           new Error(
             `BCUDP discovery timeout after ${discoveryTimeout}ms (camera may be sleeping or unreachable)`
@@ -1414,6 +1683,7 @@ var BcUdpStream = class extends EventEmitter {
           for (const port of ports) {
             try {
               sock.send(packet, port, host);
+              bytesSent += packet.length;
               retryCount++;
               this.emit("debug", "discovery_send", { retryCount, host, port });
             } catch {
@@ -2950,6 +3220,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
     sock.on("debug", (event, data) => {
       this.logDebug(`udp_${event}`, data);
     });
+    sock.setLogger(this.logger);
     await sock.connect();
     const shortUid = this.opts.uid ? this.opts.uid.substring(0, 5) : "";
     const udpDiscoveryMethod = this.opts.udpDiscoveryMethod ?? "local-direct";
@@ -13466,7 +13737,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       return;
     }
     entry.startInFlight = (async () => {
-      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-NTIGPHYJ.js");
+      const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-OCLOM452.js");
       const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
       const dedicated = await this.createDedicatedSession(sessionKey);
       const stream = new BaichuanVideoStream2({
@@ -20196,7 +20467,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-7BIWJDZS.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-K4MF2VXZ.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -20212,7 +20483,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-7BIWJDZS.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-K4MF2VXZ.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -23478,7 +23749,11 @@ async function discoverViaUdpDirect(host, options) {
     });
     socket.bind(() => {
       const localPort = socket.address().port;
-      const discoveryPorts = [BCUDP_DISCOVERY_PORT_LOCAL_ANY, BCUDP_DISCOVERY_PORT_LOCAL_UID];
+      const discoveryPorts = [
+        BCUDP_DISCOVERY_PORT_LOCAL_ANY,
+        BCUDP_DISCOVERY_PORT_LOCAL_UID,
+        BCUDP_DISCOVERY_PORT_P2P_SCAN
+      ];
       for (const port of discoveryPorts) {
         try {
           const tid = Math.floor(Math.random() * 255) || 1;
@@ -23767,7 +24042,11 @@ async function discoverViaUdpBroadcast(options) {
     socket.bind(() => {
       socket.setBroadcast(true);
       const localPort = socket.address().port;
-      const discoveryPorts = [BCUDP_DISCOVERY_PORT_LOCAL_ANY, BCUDP_DISCOVERY_PORT_LOCAL_UID];
+      const discoveryPorts = [
+        BCUDP_DISCOVERY_PORT_LOCAL_ANY,
+        BCUDP_DISCOVERY_PORT_LOCAL_UID,
+        BCUDP_DISCOVERY_PORT_P2P_SCAN
+      ];
       for (const port of discoveryPorts) {
         try {
           const tid = Math.floor(Math.random() * 255) || 1;
@@ -24259,22 +24538,102 @@ async function discoverUidForHost(host, logger) {
 function isTcpFailureThatShouldFallbackToUdp(e) {
   const message = e?.message || e?.toString?.() || "";
   if (typeof message !== "string") return false;
-  return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("socket hang up") || message.includes("TCP connection timeout") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
+  return message.includes("ECONNREFUSED") || message.includes("ETIMEDOUT") || message.includes("EHOSTDOWN") || message.includes("EHOSTUNREACH") || message.includes("ENETUNREACH") || message.includes("ENETDOWN") || message.includes("socket hang up") || message.includes("TCP connection timeout") || // Autodetect's own hard deadline on the TCP login attempt — see
+  // `withTcpDeadline` in `autoDetectDeviceType`. Without this entry the
+  // catch block would rethrow the deadline error instead of awaiting
+  // the speculative UDP race.
+  message.includes("TCP login deadline exceeded") || message.includes("Baichuan socket closed") || message.includes("timeout waiting for nonce") || message.includes("expected encryption info") || message.includes("ECONNRESET") || message.includes("EPIPE");
 }
 async function pingHost(host, timeoutMs = 3e3) {
-  const { exec } = await import("child_process");
+  if (!host || typeof host !== "string") return false;
   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}`
-  ) : (
-    // Linux/BSD-ish: -W is in seconds on most distros
-    `ping -c 1 -W ${Math.max(1, Math.floor(timeoutMs / 1e3))} ${host}`
-  );
+  const pingCandidates = platform2 === "win32" ? ["ping"] : platform2 === "darwin" ? ["/sbin/ping", "/usr/sbin/ping", "ping"] : ["/bin/ping", "/usr/bin/ping", "ping"];
+  const pingArgs = (bin) => {
+    void bin;
+    if (platform2 === "win32") {
+      return ["-n", "1", "-w", String(timeoutMs), host];
+    }
+    if (platform2 === "darwin") {
+      return ["-c", "1", "-W", String(timeoutMs), host];
+    }
+    return ["-c", "1", "-W", String(Math.max(1, Math.floor(timeoutMs / 1e3))), host];
+  };
+  const { spawn: spawn3 } = await import("child_process");
+  for (const bin of pingCandidates) {
+    const ranOk = await new Promise((resolve) => {
+      let settled = false;
+      let child;
+      try {
+        child = spawn3(bin, pingArgs(bin), { stdio: "ignore" });
+      } catch {
+        resolve("spawn-failed");
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try {
+          child?.kill("SIGKILL");
+        } catch {
+        }
+        resolve(false);
+      }, timeoutMs + 500);
+      child.on("error", () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve("spawn-failed");
+      });
+      child.on("exit", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve(code === 0);
+      });
+    });
+    if (ranOk === true) return true;
+    if (ranOk === "spawn-failed") continue;
+    break;
+  }
+  for (const port of [9e3, 443, 80]) {
+    if (await tcpReachabilityProbe(host, port, 800)) return true;
+  }
+  return false;
+}
+async function tcpReachabilityProbe(host, port, timeoutMs) {
+  const net4 = await import("net");
   return new Promise((resolve) => {
-    exec(pingCmd, (error) => {
-      resolve(!error);
+    let settled = false;
+    const socket = new net4.Socket();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(false);
+    }, timeoutMs);
+    const finish = (reachable) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        socket.destroy();
+      } catch {
+      }
+      resolve(reachable);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", (err) => {
+      if (err?.code === "ECONNREFUSED") finish(true);
+      else finish(false);
     });
+    try {
+      socket.connect(port, host);
+    } catch {
+      finish(false);
+    }
   });
 }
 function createBaichuanApi(inputs, transport) {
@@ -24331,6 +24690,7 @@ function attachErrorHandler(api, transport, inputs) {
 }
 async function autoDetectDeviceType(inputs) {
   const { host, uid, logger } = inputs;
+  const autodetectStartedAt = Date.now();
   const mode = inputs.mode ?? "auto";
   const maxRetriesRaw = inputs.maxRetries;
   const maxRetries = Math.max(
@@ -24347,8 +24707,31 @@ async function autoDetectDeviceType(inputs) {
   const sleepMs2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
   const shouldRetryTcp = (e) => {
     const msg = fmtErr(e);
+    if (msg.includes("ECONNREFUSED") || msg.includes("EHOSTDOWN") || msg.includes("EHOSTUNREACH") || msg.includes("ENETUNREACH") || msg.includes("ENETDOWN")) {
+      return false;
+    }
     return isTcpFailureThatShouldFallbackToUdp(e) || msg.includes("timeout waiting for nonce") || msg.includes("expected encryption info") || msg.includes("Baichuan socket closed") || msg.includes("ECONNRESET") || msg.includes("EPIPE");
   };
+  const tcpDeadlineMs = typeof inputs.tcpConnectTimeoutMs === "number" && Number.isFinite(inputs.tcpConnectTimeoutMs) && inputs.tcpConnectTimeoutMs > 0 ? inputs.tcpConnectTimeoutMs : 8e3;
+  const withTcpDeadline = async (op) => {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new Error(
+            `TCP login deadline exceeded (${tcpDeadlineMs}ms) \u2014 host unreachable`
+          )
+        ),
+        tcpDeadlineMs
+      );
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([op, deadline]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  };
   const shouldRetryUdp = (e) => {
     const msg = fmtErr(e);
     return msg.includes("Not running") || msg.includes("Baichuan UDP stream closed") || msg.includes("Baichuan socket closed") || msg.includes("ETIMEDOUT") || msg.toLowerCase().includes("timeout");
@@ -24401,6 +24784,11 @@ async function autoDetectDeviceType(inputs) {
     }
   };
   const effectiveUid = normalizeUid(uid);
+  const speculativeUidPromise = effectiveUid !== void 0 ? Promise.resolve(effectiveUid) : mode === "tcp" ? Promise.resolve(void 0) : discoverUidForHost(host, logger).then((d) => normalizeUid(d) ?? void 0).catch(() => void 0);
+  speculativeUidPromise.then(
+    () => void 0,
+    () => void 0
+  );
   logger?.log?.(`[AutoDetect] Pinging ${host}...`);
   const isReachable = await pingHost(host);
   if (!isReachable) {
@@ -24414,19 +24802,11 @@ async function autoDetectDeviceType(inputs) {
     logger?.log?.(
       `[AutoDetect] Forced mode=udp, skipping TCP and starting UDP discovery/login...`
     );
-    let normalizedUid = effectiveUid;
+    let normalizedUid = await speculativeUidPromise;
     if (!normalizedUid) {
-      logger?.log?.(
-        `[AutoDetect] UID not provided; attempting UDP discovery for UID...`
+      throw new Error(
+        `Forced UDP autodetect requires UID (or successful UDP UID discovery), but none was provided/discovered (ip=${host}).`
       );
-      const discovered = await discoverUidForHost(host, logger);
-      const normalizedDiscovered = normalizeUid(discovered);
-      if (!normalizedDiscovered) {
-        throw new Error(
-          `Forced UDP autodetect requires UID (or successful UDP UID discovery), but none was provided/discovered (ip=${host}).`
-        );
-      }
-      normalizedUid = normalizedDiscovered;
     }
     const methodsToTry = inputs.udpDiscoveryMethod ? [inputs.udpDiscoveryMethod] : ["local-direct", "local-broadcast", "remote", "relay", "map"];
     return await runUdpMethodsParallel(
@@ -24504,6 +24884,127 @@ async function autoDetectDeviceType(inputs) {
       "Forced UDP autodetect failed for all methods."
     );
   }
+  const detectOverUdpApi = async (udpApi, udpDiscoveryMethod, resolvedUid) => {
+    const [deviceInfo, capabilities, hostNetworkInfo] = await Promise.all([
+      udpApi.getInfo(),
+      udpApi.getDeviceCapabilities(),
+      udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0)
+    ]);
+    const channelNum = capabilities?.support?.channelNum ?? 1;
+    const model = deviceInfo.type?.trim();
+    const normalizedModel = model ? model.trim() : void 0;
+    const isMultifocalByModel = normalizedModel ? isDualLenseModel(normalizedModel) : false;
+    const channelNumValue = typeof channelNum === "string" ? Number.parseInt(channelNum, 10) : channelNum;
+    const hasDualLensChannelCount = (channelNumValue === 2 || channelNumValue === 3) && Number.isFinite(channelNumValue);
+    const isMultifocal = isMultifocalByModel || hasDualLensChannelCount;
+    const hasBattery = capabilities?.capabilities?.hasBattery === true;
+    udpApi.setIdleDisconnect(hasBattery);
+    if (isMultifocal) {
+      const detectionMethod = isMultifocalByModel ? "model match" : "channelNum fallback";
+      logger?.log?.(
+        `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}, hasBattery=${hasBattery}).`
+      );
+      return {
+        type: "multifocal",
+        transport: "udp",
+        uid: resolvedUid,
+        udpDiscoveryMethod,
+        deviceInfo,
+        ...hostNetworkInfo ? { hostNetworkInfo } : {},
+        channelNum,
+        hasBattery,
+        api: udpApi
+      };
+    }
+    const deviceType = hasBattery ? "battery-cam" : "udp-camera";
+    logger?.log?.(
+      `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected ${deviceType} (hasBattery=${hasBattery}, model=${normalizedModel ?? "unknown"}).`
+    );
+    return {
+      type: deviceType,
+      transport: "udp",
+      uid: resolvedUid,
+      udpDiscoveryMethod,
+      deviceInfo,
+      ...hostNetworkInfo ? { hostNetworkInfo } : {},
+      channelNum: 1,
+      hasBattery,
+      api: udpApi
+    };
+  };
+  const udpRaceAbort = new AbortController();
+  const speculativeUdpRace = mode === "auto" ? (async () => {
+    const resolvedUid = await speculativeUidPromise;
+    const viableMethods = selectViableUdpMethods(Boolean(resolvedUid));
+    return await runUdpMethodsParallel(
+      viableMethods,
+      async (m, isInnerAborted) => {
+        const isAborted = () => udpRaceAbort.signal.aborted || isInnerAborted();
+        if (isAborted()) {
+          throw new Error(
+            `UDP(${m}) speculative race aborted before start`
+          );
+        }
+        logger?.log?.(
+          `[AutoDetect] (race) Trying UDP discovery method: ${m}...`
+        );
+        const udpApi = await withRetries(
+          `UDP(${m})`,
+          maxRetries,
+          async (attempt) => {
+            const apiInputs = {
+              ...inputs,
+              udpDiscoveryMethod: m
+            };
+            if (resolvedUid) apiInputs.uid = resolvedUid;
+            const api = createBaichuanApi(apiInputs, "udp");
+            try {
+              await api.login();
+              return api;
+            } catch (e) {
+              try {
+                await api.close({
+                  reason: `autodetect:udp_failed:${m}:attempt_${attempt}`
+                });
+              } catch {
+              }
+              throw e;
+            }
+          },
+          shouldRetryUdp,
+          isAborted
+        );
+        if (isAborted()) {
+          try {
+            await udpApi.close({
+              reason: "autodetect:udp_aborted_after_tcp_won"
+            });
+          } catch {
+          }
+          throw new Error(
+            `UDP(${m}) speculative race aborted after login`
+          );
+        }
+        return detectOverUdpApi(udpApi, m, resolvedUid ?? "");
+      },
+      "Speculative UDP race failed for all methods."
+    );
+  })() : void 0;
+  speculativeUdpRace?.then(
+    (udpResult) => {
+      if (udpRaceAbort.signal.aborted && udpResult?.api) {
+        udpResult.api.close({ reason: "autodetect:tcp_won_race" }).catch(() => void 0);
+      }
+    },
+    () => void 0
+  );
+  const _tcpWin = (result) => {
+    udpRaceAbort.abort();
+    logger?.log?.(
+      `[AutoDetect] DONE in ${Date.now() - autodetectStartedAt}ms via TCP \u2014 type=${result.type} model=${result.deviceInfo?.type ?? "?"} channels=${result.channelNum}`
+    );
+    return result;
+  };
   let tcpApi;
   try {
     logger?.log?.(`[AutoDetect] Trying TCP connection to ${host}...`);
@@ -24513,7 +25014,7 @@ async function autoDetectDeviceType(inputs) {
       async (attempt) => {
         const api2 = createBaichuanApi(inputs, "tcp");
         try {
-          await api2.login();
+          await withTcpDeadline(api2.login());
           return api2;
         } catch (e) {
           try {
@@ -24625,7 +25126,7 @@ async function autoDetectDeviceType(inputs) {
       logger?.log?.(
         `[AutoDetect] Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum})`
       );
-      return {
+      return _tcpWin({
         type: "multifocal",
         transport: "tcp",
         uid: effectiveUid || uid || "",
@@ -24633,13 +25134,13 @@ async function autoDetectDeviceType(inputs) {
         // ...(hostNetworkInfo ? { hostNetworkInfo } : {}),
         channelNum: effectiveChannelNum,
         api
-      };
+      });
     }
     if (effectiveChannelNum > 1) {
       logger?.log?.(
         `[AutoDetect] Detected NVR (${effectiveChannelNum} channels)`
       );
-      return {
+      return _tcpWin({
         type: "nvr",
         transport: "tcp",
         uid: effectiveUid || uid || "",
@@ -24647,10 +25148,10 @@ async function autoDetectDeviceType(inputs) {
         // ...(hostNetworkInfo ? { hostNetworkInfo } : {}),
         channelNum: effectiveChannelNum,
         api
-      };
+      });
     }
     logger?.log?.(`[AutoDetect] Detected regular camera (single channel)`);
-    return {
+    return _tcpWin({
       type: "camera",
       transport: "tcp",
       uid: effectiveUid || uid || "",
@@ -24658,7 +25159,7 @@ async function autoDetectDeviceType(inputs) {
       // ...(hostNetworkInfo ? { hostNetworkInfo } : {}),
       channelNum: 1,
       api
-    };
+    });
   } catch (tcpError) {
     if (mode === "tcp") {
       throw tcpError;
@@ -24673,111 +25174,20 @@ async function autoDetectDeviceType(inputs) {
       throw tcpError;
     }
     logger?.log?.(`[AutoDetect] TCP failed, trying UDP...`);
-    let normalizedUid = effectiveUid;
-    if (!normalizedUid) {
-      logger?.log?.(
-        `[AutoDetect] UID not provided; attempting UDP broadcast discovery for UID...`
+    if (!speculativeUdpRace) {
+      throw new Error(
+        `AutoDetect internal: speculative UDP race missing in mode=${mode}`
       );
-      const discovered = await discoverUidForHost(host, logger);
-      if (discovered) {
-        const normalizedDiscovered = normalizeUid(discovered);
-        if (normalizedDiscovered) {
-          normalizedUid = normalizedDiscovered;
-          logger?.log?.(
-            `[AutoDetect] UID discovered via broadcast: ${normalizedUid}`
-          );
-        }
-      }
-      if (!normalizedUid) {
-        logger?.log?.(
-          `[AutoDetect] UID discovery failed; only local-direct can run without a UID. If the camera is sleeping or on a different subnet, supply its UID to enable BCUDP P2P fallback (remote/relay/map) which can wake it via Reolink's servers.`
-        );
-      }
     }
     try {
-      const detectOverUdpApi = async (udpApi, udpDiscoveryMethod) => {
-        const [deviceInfo, capabilities, hostNetworkInfo] = await Promise.all([
-          udpApi.getInfo(),
-          udpApi.getDeviceCapabilities(),
-          udpApi.getNetworkInfo(void 0, { timeoutMs: 1200 }).catch(() => void 0)
-        ]);
-        const channelNum = capabilities?.support?.channelNum ?? 1;
-        const model = deviceInfo.type?.trim();
-        const normalizedModel = model ? model.trim() : void 0;
-        const isMultifocalByModel = normalizedModel ? isDualLenseModel(normalizedModel) : false;
-        const channelNumValue = typeof channelNum === "string" ? Number.parseInt(channelNum, 10) : channelNum;
-        const hasDualLensChannelCount = (channelNumValue === 2 || channelNumValue === 3) && Number.isFinite(channelNumValue);
-        const isMultifocal = isMultifocalByModel || hasDualLensChannelCount;
-        const hasBattery = capabilities?.capabilities?.hasBattery === true;
-        udpApi.setIdleDisconnect(hasBattery);
-        if (isMultifocal) {
-          const detectionMethod = isMultifocalByModel ? "model match" : "channelNum fallback";
-          logger?.log?.(
-            `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected multi-focal device (${detectionMethod}: model=${normalizedModel ?? "unknown"}, channelNum=${channelNum}, hasBattery=${hasBattery}).`
-          );
-          return {
-            type: "multifocal",
-            transport: "udp",
-            uid: normalizedUid ?? "",
-            udpDiscoveryMethod,
-            deviceInfo,
-            ...hostNetworkInfo ? { hostNetworkInfo } : {},
-            channelNum,
-            hasBattery,
-            api: udpApi
-          };
-        }
-        const deviceType = hasBattery ? "battery-cam" : "udp-camera";
-        logger?.log?.(
-          `[AutoDetect] UDP (${udpDiscoveryMethod}) connection successful. Detected ${deviceType} (hasBattery=${hasBattery}, model=${normalizedModel ?? "unknown"}).`
-        );
-        return {
-          type: deviceType,
-          transport: "udp",
-          uid: normalizedUid ?? "",
-          udpDiscoveryMethod,
-          deviceInfo,
-          ...hostNetworkInfo ? { hostNetworkInfo } : {},
-          channelNum: 1,
-          hasBattery,
-          api: udpApi
-        };
-      };
-      const viableMethods = selectViableUdpMethods(Boolean(normalizedUid));
-      return await runUdpMethodsParallel(
-        viableMethods,
-        async (m, isAborted) => {
-          logger?.log?.(`[AutoDetect] Trying UDP discovery method: ${m}...`);
-          const udpApi = await withRetries(
-            `UDP(${m})`,
-            maxRetries,
-            async (attempt) => {
-              const apiInputs = { ...inputs, udpDiscoveryMethod: m };
-              if (normalizedUid) apiInputs.uid = normalizedUid;
-              const api = createBaichuanApi(apiInputs, "udp");
-              try {
-                await api.login();
-                return api;
-              } catch (e) {
-                try {
-                  await api.close({
-                    reason: `autodetect:udp_failed:${m}:attempt_${attempt}`
-                  });
-                } catch {
-                }
-                throw e;
-              }
-            },
-            shouldRetryUdp,
-            isAborted
-          );
-          return detectOverUdpApi(udpApi, m);
-        },
-        "UDP discovery failed for all methods."
+      const udpResult = await speculativeUdpRace;
+      logger?.log?.(
+        `[AutoDetect] DONE in ${Date.now() - autodetectStartedAt}ms via UDP \u2014 type=${udpResult.type} method=${udpResult.udpDiscoveryMethod ?? "n/a"} model=${udpResult.deviceInfo?.type ?? "?"} channels=${udpResult.channelNum}`
       );
+      return udpResult;
     } catch (udpError) {
       logger?.log?.(
-        `[AutoDetect] Both TCP and UDP failed. TCP error: ${tcpError}, UDP error: ${udpError}`
+        `[AutoDetect] FAILED after ${Date.now() - autodetectStartedAt}ms \u2014 neither TCP nor UDP could reach the camera. TCP: ${tcpError?.message ?? tcpError}. UDP: ${udpError?.message ?? udpError}`
       );
       throw new Error(
         `Failed to connect via both TCP and UDP. TCP: ${tcpError?.message || tcpError}, UDP: ${udpError?.message || udpError}`
@@ -24790,6 +25200,7 @@ export {
   encodeHeader,
   decodeHeader,
   BaichuanFrameParser,
+  isUnroutableForP2P,
   BcUdpStream,
   asLogger,
   createNullLogger,
@@ -24854,6 +25265,7 @@ export {
   normalizeUid,
   maskUid,
   isTcpFailureThatShouldFallbackToUdp,
+  tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-27IU7NXS.js.map
+//# sourceMappingURL=chunk-7HSTETZR.js.map