@apocaliss92/nodelink-js 0.6.1 → 0.6.3

package/dist/{chunk-EAHRVNEX.js → chunk-Q4AXRV2G.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-XDVBNZGR.js";
+} from "./chunk-IQVVVSXO.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -232,35 +232,88 @@ function decodeHeader(buf) {
   return { header, headerLen, messageKey };
 }
 var BaichuanFrameParser = class {
+  /** Retained-but-unconsumed contiguous bytes from previous push() calls. */
   buffer = Buffer.alloc(0);
+  /** Chunks received since the last materialization, not yet concatenated. */
+  pending = [];
+  /** Total bytes held in `pending` (kept in sync to avoid re-summing). */
+  pendingLen = 0;
+  /**
+   * Total contiguous bytes (`buffer` + `pending`) required before the next
+   * parse attempt can make progress. While buffered bytes stay below this,
+   * incoming chunks are merely stashed in `pending` with no copy. This is
+   * the mechanism that turns the worst case (a large frame fragmented over
+   * many small TCP chunks) from O(n²) into O(n): we concatenate once, when
+   * enough bytes have arrived, instead of on every chunk.
+   *
+   * Starts at 4 — the minimum needed to inspect the magic header.
+   */
+  needed = 4;
+  /**
+   * Collapse `this.buffer` + all `pending` chunks into a single contiguous
+   * buffer. The retained leftover is copied at most once per materialize(),
+   * and materialize() only runs when `needed` bytes are available — so a
+   * fragmented frame is assembled with a single concat, not one per chunk.
+   */
+  materialize() {
+    if (this.pendingLen === 0) return;
+    if (this.buffer.length === 0 && this.pending.length === 1) {
+      this.buffer = this.pending[0];
+    } else {
+      const parts = this.buffer.length === 0 ? this.pending : [this.buffer, ...this.pending];
+      this.buffer = Buffer.concat(parts);
+    }
+    this.pending = [];
+    this.pendingLen = 0;
+  }
+  /** Total buffered bytes, whether materialized or still pending. */
+  get available() {
+    return this.buffer.length + this.pendingLen;
+  }
   push(chunk) {
     if (chunk.length === 0) return [];
-    const c = chunk;
-    this.buffer = this.buffer.length === 0 ? c : Buffer.concat([this.buffer, c]);
+    this.pending.push(chunk);
+    this.pendingLen += chunk.length;
+    if (this.available < this.needed) return [];
+    this.materialize();
     const out = [];
     while (true) {
-      if (this.buffer.length < 4) break;
+      if (this.buffer.length < 4) {
+        this.needed = 4;
+        break;
+      }
       if (!this.buffer.subarray(0, 4).equals(BC_MAGIC) && !this.buffer.subarray(0, 4).equals(BC_MAGIC_REV)) {
         const idx = this.buffer.indexOf(BC_MAGIC);
         const idxRev = this.buffer.indexOf(BC_MAGIC_REV);
         const next = idx === -1 ? idxRev : idxRev === -1 ? idx : Math.min(idx, idxRev);
         if (next === -1) {
           this.buffer = this.buffer.subarray(Math.max(0, this.buffer.length - 3));
+          this.needed = 4;
           break;
         }
         this.buffer = this.buffer.subarray(next);
-        if (this.buffer.length < 20) break;
+        if (this.buffer.length < 20) {
+          this.needed = 20;
+          break;
+        }
+      }
+      if (this.buffer.length < 20) {
+        this.needed = 20;
+        break;
       }
-      if (this.buffer.length < 20) break;
       let headerInfo;
       try {
         headerInfo = decodeHeader(this.buffer);
       } catch {
+        this.needed = 24;
         break;
       }
       const { header, headerLen, messageKey } = headerInfo;
       const frameLen = headerLen + header.bodyLen;
-      if (this.buffer.length < frameLen) break;
+      if (this.buffer.length < frameLen) {
+        this.needed = frameLen;
+        break;
+      }
       const raw = this.buffer.subarray(0, frameLen);
       const body = raw.subarray(headerLen);
       let extLen = 0;
@@ -272,6 +325,7 @@ var BaichuanFrameParser = class {
       const payload = body.subarray(extLen);
       out.push({ header, body, extension, payload, messageKey, raw });
       this.buffer = this.buffer.subarray(frameLen);
+      this.needed = 4;
     }
     return out;
   }
@@ -677,8 +731,14 @@ async function getServerBinding(uid, options = {}) {
       headers: { Accept: "application/json" }
     });
     if (!res.ok) {
+      let bodyPreview;
+      try {
+        const text = await res.text();
+        bodyPreview = text.slice(0, 512).replace(/\s+/g, " ").trim();
+      } catch {
+      }
       logger?.log?.(
-        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}`
+        `[server-binding] ${uid}: HTTP ${res.status} ${res.statusText} from ${url}` + (bodyPreview ? ` \u2014 body=${bodyPreview}` : "")
       );
       cache.set(uid, { kind: "err", expires: now + NEGATIVE_TTL_MS });
       return void 0;
@@ -794,6 +854,68 @@ function parseServerBindingResponse(raw) {
 }
 
 // src/bcudp/BcUdpStream.ts
+async function probeEgressForHost(destHost, destPort) {
+  return await new Promise((resolve, reject) => {
+    const probe = dgram.createSocket("udp4");
+    let settled = false;
+    const finish = (err, out) => {
+      if (settled) return;
+      settled = true;
+      try {
+        probe.close();
+      } catch {
+      }
+      if (err || !out) reject(err ?? new Error("egress probe failed"));
+      else resolve(out);
+    };
+    probe.on("error", (e) => finish(e));
+    try {
+      probe.connect(destPort, destHost, () => {
+        try {
+          const a = probe.address();
+          if (typeof a === "string") return finish(new Error("probe address is string"));
+          finish(void 0, {
+            localAddress: a.address,
+            localPort: a.port
+          });
+        } catch (e) {
+          finish(e);
+        }
+      });
+    } catch (e) {
+      finish(e);
+    }
+  });
+}
+function isSameSubnetAsAnyLocalIface(destHost, srcInfo) {
+  if (!/^\d+\.\d+\.\d+\.\d+$/.test(destHost)) return "unknown";
+  const dest = destHost.split(".").map((s) => Number(s));
+  if (dest.some((n) => !Number.isFinite(n) || n < 0 || n > 255))
+    return "unknown";
+  const ifaces = networkInterfaces();
+  let ownerSubnet;
+  for (const name of Object.keys(ifaces)) {
+    const entries = ifaces[name];
+    if (!entries) continue;
+    for (const e of entries) {
+      if (e.family !== "IPv4" || e.internal) continue;
+      if (e.address !== srcInfo.localAddress) continue;
+      const addr = e.address.split(".").map((s) => Number(s));
+      const mask = e.netmask.split(".").map((s) => Number(s));
+      if (addr.length !== 4 || mask.length !== 4 || addr.some((n) => !Number.isFinite(n)) || mask.some((n) => !Number.isFinite(n)))
+        continue;
+      ownerSubnet = { addr, mask };
+      break;
+    }
+    if (ownerSubnet) break;
+  }
+  if (!ownerSubnet) return "unknown";
+  for (let i = 0; i < 4; i++) {
+    if ((ownerSubnet.addr[i] & ownerSubnet.mask[i]) !== (dest[i] & ownerSubnet.mask[i]))
+      return "mismatch";
+  }
+  return "same";
+}
 var AckLatency = class {
   currentValues = [];
   lastReceiveTime = null;
@@ -872,6 +994,16 @@ function isUnroutableForP2P(ip) {
 var P2P_LOOKUP_PORT = 9999;
 var P2P_MAX_WAIT_MS = 15e3;
 var P2P_RESEND_WAIT_MS = 500;
+var inflightP2pLookups = /* @__PURE__ */ new Map();
+var cachedP2pLookups = /* @__PURE__ */ new Map();
+var negCachedP2pLookups = /* @__PURE__ */ new Map();
+var P2P_LOOKUP_CACHE_TTL_MS = 3e4;
+var P2P_LOOKUP_NEG_CACHE_TTL_MS = 15e3;
+function _clearP2pLookupDedupForTests() {
+  inflightP2pLookups.clear();
+  cachedP2pLookups.clear();
+  negCachedP2pLookups.clear();
+}
 var BcUdpStream = class extends EventEmitter {
   opts;
   /**
@@ -960,31 +1092,14 @@ var BcUdpStream = class extends EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    const portRange = Array.from({ length: 500 }, (_, i) => 53500 + i);
-    for (let i = portRange.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [portRange[i], portRange[j]] = [portRange[j], portRange[i]];
-    }
-    let bound = false;
-    for (const port of portRange) {
-      try {
-        await new Promise((resolve, reject) => {
-          sock.once("error", reject);
-          sock.bind(port, "0.0.0.0", () => {
-            sock.removeListener("error", reject);
-            resolve();
-          });
-        });
-        bound = true;
-        break;
-      } catch {
-      }
-    }
-    if (!bound) {
-      await new Promise(
-        (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
-      );
-    }
+    await new Promise((resolve, reject) => {
+      const onErr = (e) => reject(e);
+      sock.once("error", onErr);
+      sock.bind(0, "0.0.0.0", () => {
+        sock.removeListener("error", onErr);
+        resolve();
+      });
+    });
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -1055,6 +1170,49 @@ var BcUdpStream = class extends 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 cached = cachedP2pLookups.get(uid);
+    if (cached && cached.expires > Date.now()) {
+      log(
+        `UID=${shortUid} cached lookup hit (relay=${cached.result.relay.ip}:${cached.result.relay.port})`
+      );
+      return cached.result;
+    }
+    const negCached = negCachedP2pLookups.get(uid);
+    if (negCached && negCached.expires > Date.now()) {
+      const remaining = negCached.expires - Date.now();
+      log(
+        `UID=${shortUid} negative-cache hit (fail-fast, retry in ${Math.ceil(remaining / 1e3)}s)`
+      );
+      throw negCached.error;
+    }
+    const inflight = inflightP2pLookups.get(uid);
+    if (inflight) {
+      log(`UID=${shortUid} sharing in-flight lookup with concurrent race lane`);
+      return await inflight;
+    }
+    const work = this._doP2pUidLookupWork(sock, uid);
+    inflightP2pLookups.set(uid, work);
+    try {
+      const result = await work;
+      cachedP2pLookups.set(uid, {
+        result,
+        expires: Date.now() + P2P_LOOKUP_CACHE_TTL_MS
+      });
+      return result;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      negCachedP2pLookups.set(uid, {
+        error: err,
+        expires: Date.now() + P2P_LOOKUP_NEG_CACHE_TTL_MS
+      });
+      throw err;
+    } finally {
+      inflightP2pLookups.delete(uid);
+    }
+  }
+  async _doP2pUidLookupWork(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();
@@ -1522,6 +1680,23 @@ var BcUdpStream = class extends EventEmitter {
     log(
       `local discovery: mode=${localMode} uid=${shortUid} ports=[${ports.join(", ")}] broadcasts=[${broadcastHosts.join(", ")}]${directHost ? ` direct=${directHost}` : ""} localBindPort=${localPort} timeout=${discoveryTimeout}ms`
     );
+    if (directHost && localMode === "local-direct") {
+      try {
+        const egress = await probeEgressForHost(directHost, ports[0] ?? 2015);
+        const sameSubnet = isSameSubnetAsAnyLocalIface(directHost, egress);
+        if (sameSubnet === "mismatch") {
+          log(
+            `WARN: kernel-chosen source IP ${egress.localAddress} is NOT in the same subnet as ${directHost}. Some Reolink battery cams silently drop discovery packets with off-subnet source IPs. If discovery fails, check your routing table \u2014 likely a Tailscale / VPN / secondary NIC stealing the default route.`
+          );
+        } else {
+          log(
+            `egress for ${directHost} \u2192 src=${egress.localAddress}` + (sameSubnet === "same" ? ` (same subnet \u2713)` : ` (subnet relationship unknown)`)
+          );
+        }
+      } catch (e) {
+        this.emit("debug", "egress_probe_failed", e);
+      }
+    }
     let bytesSent = 0;
     let pktsRecv = 0;
     sock.on("message", () => {
@@ -20517,7 +20692,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-K4MF2VXZ.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-QJ3CRYGA.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -20533,7 +20708,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-K4MF2VXZ.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-QJ3CRYGA.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -25250,7 +25425,10 @@ export {
   encodeHeader,
   decodeHeader,
   BaichuanFrameParser,
+  probeEgressForHost,
+  isSameSubnetAsAnyLocalIface,
   isUnroutableForP2P,
+  _clearP2pLookupDedupForTests,
   BcUdpStream,
   asLogger,
   createNullLogger,
@@ -25318,4 +25496,4 @@ export {
   tcpReachabilityProbe,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-EAHRVNEX.js.map
+//# sourceMappingURL=chunk-Q4AXRV2G.js.map