@apocaliss92/nodelink-js 0.5.1 → 0.5.2

package/dist/cli/rtsp-server.cjs

@@ -11292,6 +11292,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 = [];
@@ -11373,6 +11510,16 @@ var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
 var BcUdpStream = class extends import_node_events3.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;
@@ -11416,6 +11563,17 @@ var BcUdpStream = class extends import_node_events3.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;
   }
@@ -11533,20 +11691,60 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
     this.remote = { host: connected.rhost, port: connected.rport };
   }
   async p2pUidLookup(sock, uid) {
+    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 P2P_RELAY_HOSTNAMES) {
+    for (const host of hostnamesToTry) {
       try {
         const answers = await import_promises.default.lookup(host, { family: 4, all: true });
+        let publicCount = 0;
+        let sinkCount = 0;
         for (const a of answers) {
           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);
+          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) {
@@ -11560,11 +11758,22 @@ var BcUdpStream = class extends import_node_events3.EventEmitter {
         "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,
@@ -11572,11 +11781,20 @@ var BcUdpStream = class extends import_node_events3.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) {
@@ -11915,13 +12133,23 @@ var BcUdpStream = class extends import_node_events3.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,
@@ -11932,6 +12160,9 @@ var BcUdpStream = class extends import_node_events3.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)`
@@ -12125,6 +12356,7 @@ var BcUdpStream = class extends import_node_events3.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 {
@@ -13703,6 +13935,7 @@ var BaichuanClient = class _BaichuanClient extends import_node_events4.EventEmit
     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";
@@ -31501,7 +31734,11 @@ 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) {
   if (!host || typeof host !== "string") return false;
@@ -31649,6 +31886,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(
@@ -31665,9 +31903,31 @@ async function autoDetectDeviceType(inputs) {
   const sleepMs3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
   const shouldRetryTcp = (e) => {
     const msg = fmtErr(e);
-    if (msg.includes("ECONNREFUSED")) return false;
+    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");
@@ -31820,6 +32080,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}...`);
@@ -31829,7 +32210,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 {
@@ -31941,7 +32322,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 || "",
@@ -31949,13 +32330,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 || "",
@@ -31963,10 +32344,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 || "",
@@ -31974,7 +32355,7 @@ async function autoDetectDeviceType(inputs) {
       // ...(hostNetworkInfo ? { hostNetworkInfo } : {}),
       channelNum: 1,
       api
-    };
+    });
   } catch (tcpError) {
     if (mode === "tcp") {
       throw tcpError;
@@ -31989,100 +32370,20 @@ async function autoDetectDeviceType(inputs) {
       throw tcpError;
     }
     logger?.log?.(`[AutoDetect] TCP failed, trying UDP...`);
-    let normalizedUid = await speculativeUidPromise;
-    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.`
-      );
-    } else if (effectiveUid === void 0) {
-      logger?.log?.(
-        `[AutoDetect] UID resolved via concurrent broadcast discovery: ${normalizedUid}`
+    if (!speculativeUdpRace) {
+      throw new Error(
+        `AutoDetect internal: speculative UDP race missing in mode=${mode}`
       );
     }
     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}`