@apocaliss92/nodelink-js 0.4.4 → 0.4.6

package/README.md

@@ -93,6 +93,8 @@ Devices with captured fixtures (verified API compatibility):
 | --- | --- | --- |
 | E1 Outdoor PoE | Wired camera | v3.1.0.5223 |
 | E1 Zoom | Wired camera (H.265, PTZ) | v3.2.0.4741 |
+| RLC-810A | Wired camera (8MP) | v3.1.0.1162 |
+| B400 | Wired camera (4MP) | v3.0.0.183 |
 | Argus 3E | Battery camera (via Home Hub) | v3.0.0.3623 |
 | Argus PT Ultra | Battery camera with PTZ (via Home Hub) | v3.0.0.3911 |
 | Reolink Home Hub | NVR / Hub | v3.3.0.456 |

package/dist/{DiagnosticsTools-55PR4WFD.js → DiagnosticsTools-UMN4C7SY.js}

@@ -12,7 +12,7 @@ import {
   sampleStreams,
   sanitizeFixtureData,
   testChannelStreams
-} from "./chunk-DEOMUWBN.js";
+} from "./chunk-TR3V5FTO.js";
 export {
   captureModelFixtures,
   collectCgiDiagnostics,
@@ -28,4 +28,4 @@ export {
   sanitizeFixtureData,
   testChannelStreams
 };
-//# sourceMappingURL=DiagnosticsTools-55PR4WFD.js.map
+//# sourceMappingURL=DiagnosticsTools-UMN4C7SY.js.map

package/dist/{chunk-UHFJPQA4.js → chunk-F2Y5U3YP.js}

@@ -144,7 +144,7 @@ import {
   talkTraceLog,
   traceLog,
   xmlEscape
-} from "./chunk-DEOMUWBN.js";
+} from "./chunk-TR3V5FTO.js";
 
 // src/protocol/framing.ts
 function encodeHeader(h) {
@@ -654,6 +654,9 @@ var BcUdpStream = class extends EventEmitter {
   resendTimer;
   hbTimer;
   discoveryTid;
+  // Track discovery-phase timers so close() can cancel them even if
+  // discovery is still in progress (prevents ERR_SOCKET_DGRAM_NOT_RUNNING).
+  discoveryTimers = [];
   acceptSent = false;
   lastAcceptAtMs;
   ackScheduled = false;
@@ -702,9 +705,31 @@ var BcUdpStream = class extends EventEmitter {
     });
     sock.on("error", (e) => this.emit("error", e));
     sock.on("close", () => this.emit("close"));
-    await new Promise(
-      (resolve) => sock.bind(0, "0.0.0.0", () => resolve())
-    );
+    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())
+      );
+    }
     if (this.opts.mode === "direct") {
       this.remote = { host: this.opts.host, port: this.opts.port };
       this.clientId = this.opts.clientId;
@@ -1124,7 +1149,24 @@ var BcUdpStream = class extends EventEmitter {
       BCUDP_DISCOVERY_PORT_LOCAL_ANY,
       BCUDP_DISCOVERY_PORT_LOCAL_UID
     ];
-    const broadcastHost = "255.255.255.255";
+    const broadcastHosts = ["255.255.255.255"];
+    const ifaces = networkInterfaces();
+    for (const name of Object.keys(ifaces)) {
+      const entries = ifaces[name];
+      if (!entries) continue;
+      for (const addr2 of entries) {
+        if (addr2.family === "IPv4" && !addr2.internal && addr2.cidr) {
+          const ipParts = addr2.address.split(".").map(Number);
+          const maskParts = addr2.netmask.split(".").map(Number);
+          if (ipParts.length === 4 && maskParts.length === 4) {
+            const bcast = ipParts.map((octet, i) => octet | ~maskParts[i] & 255).join(".");
+            if (!broadcastHosts.includes(bcast)) {
+              broadcastHosts.push(bcast);
+            }
+          }
+        }
+      }
+    }
     const directHost = (this.opts.directHost ?? "").trim();
     const localMode = opts?.localMode ?? "local-broadcast";
     const directFirstWindowMs = localMode === "local-direct" && directHost ? 3e3 : 0;
@@ -1151,6 +1193,7 @@ var BcUdpStream = class extends EventEmitter {
           )
         );
       }, discoveryTimeout);
+      this.discoveryTimers.push(timeout);
       let retryTimer;
       let retryCount = 0;
       let discoveredSid;
@@ -1327,11 +1370,11 @@ var BcUdpStream = class extends EventEmitter {
             if (directHost) {
               if (directFirstWindowMs > 0 && elapsedMs < directFirstWindowMs)
                 return [directHost];
-              return [directHost, broadcastHost];
+              return [directHost, ...broadcastHosts];
             }
-            return [broadcastHost];
+            return broadcastHosts;
           }
-          return [broadcastHost];
+          return broadcastHosts;
         })();
         for (const host of Array.from(new Set(hosts))) {
           for (const port of ports) {
@@ -1339,8 +1382,7 @@ var BcUdpStream = class extends EventEmitter {
               sock.send(packet, port, host);
               retryCount++;
               this.emit("debug", "discovery_send", { retryCount, host, port });
-            } catch (e) {
-              this.emit("error", e instanceof Error ? e : new Error(String(e)));
+            } catch {
             }
           }
         }
@@ -1349,6 +1391,7 @@ var BcUdpStream = class extends EventEmitter {
       retryTimer = setIntervalNode(() => {
         sendDiscovery();
       }, retryInterval);
+      this.discoveryTimers.push(retryTimer);
     });
     this.clientId = reply.cid;
     this.cameraId = reply.did;
@@ -1665,6 +1708,10 @@ var BcUdpStream = class extends EventEmitter {
     this.ackTimer = void 0;
     this.resendTimer = void 0;
     this.hbTimer = void 0;
+    for (const t of this.discoveryTimers) {
+      clearInterval(t);
+    }
+    this.discoveryTimers = [];
     const s = this.sock;
     this.sock = void 0;
     if (!s) return;
@@ -1806,6 +1853,14 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
    *   even if the current client instance is idle/disconnected.
    */
   static streamingRegistry = /* @__PURE__ */ new Map();
+  /**
+   * Per-host D2C_DISC backoff state that persists across client instance recreation.
+   *
+   * Why: when a D2C_DISC kills a client, the socket pool destroys the old instance
+   * and creates a new one. Instance-level backoff variables would reset to zero,
+   * allowing immediate reconnection and perpetuating the storm.
+   */
+  static d2cDiscBackoff = /* @__PURE__ */ new Map();
   /**
    * Global (process-wide) CoverPreview serialization.
    *
@@ -2501,7 +2556,12 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
   }
   async waitForUdpReconnectCooldown() {
     const now = Date.now();
-    const waitMs = this.udpReconnectCooldownUntilMs - now;
+    const staticEntry = _BaichuanClient.d2cDiscBackoff.get(this.opts.host);
+    const effectiveCooldownUntil = Math.max(
+      this.udpReconnectCooldownUntilMs,
+      staticEntry?.cooldownUntilMs ?? 0
+    );
+    const waitMs = effectiveCooldownUntil - now;
     if (waitMs <= 0) return;
     const sid = this.socketSessionId;
     const shortUid = this.opts.uid ? this.opts.uid.substring(0, 5) : void 0;
@@ -2510,7 +2570,8 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       host: this.opts.host,
       sid,
       uid: shortUid,
-      waitMs
+      waitMs,
+      persistent: staticEntry != null
     });
     await new Promise((resolve) => setTimeout(resolve, waitMs));
   }
@@ -2753,21 +2814,30 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
           uid: shortUid2,
           message: err.message
         });
-        const withinWindow = now - this.udpReconnectLastD2cDiscAtMs < 6e4;
+        const hostKey = this.opts.host;
+        const prev = _BaichuanClient.d2cDiscBackoff.get(hostKey);
+        const withinWindow = prev != null && now - prev.lastAtMs < 6e4;
         const baseMs = 2e3;
         const maxMs = 3e4;
         const nextBackoffMs = withinWindow ? Math.min(
           maxMs,
           Math.max(
             baseMs,
-            this.udpReconnectBackoffMs > 0 ? this.udpReconnectBackoffMs * 2 : baseMs
+            prev.backoffMs > 0 ? prev.backoffMs * 2 : baseMs
           )
         ) : baseMs;
-        this.udpReconnectLastD2cDiscAtMs = now;
-        this.udpReconnectBackoffMs = nextBackoffMs;
+        const cooldownUntilMs = Math.max(
+          prev?.cooldownUntilMs ?? 0,
+          now + nextBackoffMs
+        );
+        _BaichuanClient.d2cDiscBackoff.set(hostKey, {
+          backoffMs: nextBackoffMs,
+          lastAtMs: now,
+          cooldownUntilMs
+        });
         this.udpReconnectCooldownUntilMs = Math.max(
           this.udpReconnectCooldownUntilMs,
-          now + nextBackoffMs
+          cooldownUntilMs
         );
         this.logDebug("d2c_disc_backoff", {
           transport: "udp",
@@ -2775,7 +2845,8 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
           sid: sid2,
           uid: shortUid2,
           backoffMs: nextBackoffMs,
-          cooldownUntilMs: this.udpReconnectCooldownUntilMs
+          cooldownUntilMs,
+          persistent: true
         });
         this.stopKeepAlive();
         this.loggedIn = false;
@@ -2784,6 +2855,7 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
           this.videoSubscriptions.clear();
           this.recomputeGlobalStreamingContribution();
         }
+        this.emit("d2c_disc", { host: this.opts.host, atMs: now });
       }
       this.emit("error", err);
     });
@@ -3082,6 +3154,13 @@ var BaichuanClient = class _BaichuanClient extends EventEmitter2 {
       }
     }
     this.emit("push", frame);
+    if (frame.header.cmdId === 252 && frame.body.length > 0) {
+      try {
+        this.emit("batteryPush", frame);
+      } catch (error) {
+        this.logDebug("battery_push_error", error);
+      }
+    }
     if (frame.header.cmdId === 33) {
       try {
         const sid = this.socketSessionId;
@@ -10149,6 +10228,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       }
     }
     const newClient = new BaichuanClient(this.clientOptions);
+    this.attachD2cDiscListener(newClient);
     this.socketPool.set("general", {
       client: newClient,
       refCount: 1,
@@ -10194,6 +10274,31 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       if (!mapped) return;
       this.dispatchSimpleEvent(mapped);
     });
+    client.on("batteryPush", (frame) => {
+      try {
+        const xml = this.client.tryDecryptXml(
+          frame.body,
+          frame.header.channelId,
+          this.client.enc
+        );
+        if (!xml) return;
+        const channel = frame.header.channelId;
+        const battery = this.parseBatteryInfoXml(xml, channel);
+        if (battery.batteryPercent !== void 0 || battery.chargeStatus !== void 0 || battery.adapterStatus !== void 0) {
+          this.dispatchSimpleEvent({
+            type: "battery",
+            channel,
+            timestamp: Date.now(),
+            battery
+          });
+        }
+      } catch (e) {
+        this.logger.debug?.(
+          "[ReolinkBaichuanApi] Error parsing battery push",
+          formatErrorForLog(e)
+        );
+      }
+    });
     client.on("channelInfo", (xml) => {
       try {
         this.parseAndStoreChannelInfo(xml);
@@ -10329,6 +10434,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   rtspServers = /* @__PURE__ */ new Set();
   // Track all RTSP servers for cleanup
   activeVideoMsgNums = /* @__PURE__ */ new Map();
+  // ─── D2C_DISC cooldown & storm detection ────────────────────────────────────
+  // Tracked on the API instance (survives BaichuanClient recreation).
+  /** Timestamp of the most recent D2C_DISC from any client for this device. */
+  lastD2cDiscAtMs = 0;
+  /** Sliding window of recent D2C_DISC timestamps for storm detection. */
+  d2cDiscTimestamps = [];
+  /** Immediate cooldown (ms) applied to socket pool on every D2C_DISC.
+   *  Prevents reconnect attempts while the camera is transitioning to sleep. */
+  static D2C_DISC_IMMEDIATE_COOLDOWN_MS = 1e4;
+  /** Number of D2C_DISCs within the storm window to trigger extended cooldown. */
+  static D2C_DISC_STORM_THRESHOLD = 3;
+  /** Sliding window size (ms) for storm detection. */
+  static D2C_DISC_STORM_WINDOW_MS = 6e4;
+  /** Extended cooldown (ms) applied to socket pool when a D2C_DISC storm is detected. */
+  static D2C_DISC_STORM_COOLDOWN_MS = 12e4;
   nvrChannelsSummaryCache = /* @__PURE__ */ new Map();
   /**
    * Cached device capabilities per channel.
@@ -10653,6 +10773,20 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     const prefix = basename.substring(0, 10).toUpperCase();
     return prefix.includes("S") ? "subStream" : "mainStream";
   }
+  /**
+   * Stream profiles that the device explicitly rejected (response_code 400).
+   * Keyed by `"ch:profile"` (e.g. `"0:ext"`). Once a profile is in this set
+   * it is excluded from `buildVideoStreamOptions()` results and no further
+   * start attempts are made until the API instance is recreated.
+   */
+  _rejectedStreamProfiles = /* @__PURE__ */ new Set();
+  /**
+   * Check whether a stream profile was rejected by the device at runtime
+   * (e.g. ext returned response_code 400).
+   */
+  isStreamProfileRejected(channel, profile) {
+    return this._rejectedStreamProfiles.has(`${channel}:${profile}`);
+  }
   /**
    * Cache for buildVideoStreamOptions.
    *
@@ -10742,6 +10876,14 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     }
     return "general";
   }
+  /**
+   * Attach a D2C_DISC listener to a BaichuanClient so that the API-level
+   * grace period and storm detection are updated regardless of which
+   * pool socket receives the disconnect.
+   */
+  attachD2cDiscListener(client) {
+    client.on("d2c_disc", () => this.notifyD2cDisc());
+  }
   /**
    * Acquire a socket from the pool by tag.
    * Creates a new socket if needed, or reuses an existing one.
@@ -10762,10 +10904,12 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
         );
       } else if (now < cooldownEntry.cooldownUntil) {
         const remainingMs = cooldownEntry.cooldownUntil - now;
+        const isD2cDisc = this.lastD2cDiscAtMs > 0 && now - this.lastD2cDiscAtMs < 12e4;
+        const reason = isD2cDisc ? "D2C_DISC (camera sleeping)" : "repeated login failures";
         const error = new Error(
-          `[SocketPool] Host ${this.host} is in cooldown for ${Math.ceil(remainingMs / 1e3)}s due to repeated login failures. tag=${tag}`
+          `[SocketPool] Host ${this.host} is in cooldown for ${Math.ceil(remainingMs / 1e3)}s due to ${reason}. tag=${tag}`
         );
-        log?.warn?.(error.message);
+        log?.debug?.(error.message);
         throw error;
       }
     }
@@ -10856,12 +11000,21 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       try {
         const clientOpts = log ? { ...this.clientOptions, logger: log } : this.clientOptions;
         const newClient = new BaichuanClient(clientOpts);
+        this.attachD2cDiscListener(newClient);
         await newClient.login();
-        if (this.socketPoolCooldowns.has(this.host)) {
-          log?.debug?.(
-            `[SocketPool] Clearing cooldown for host=${this.host} after successful login`
-          );
-          this.socketPoolCooldowns.delete(this.host);
+        const existingCooldown = this.socketPoolCooldowns.get(this.host);
+        if (existingCooldown) {
+          const isStormCooldown = existingCooldown.failureCount >= _ReolinkBaichuanApi.D2C_DISC_STORM_THRESHOLD;
+          if (!isStormCooldown) {
+            log?.debug?.(
+              `[SocketPool] Clearing cooldown for host=${this.host} after successful login`
+            );
+            this.socketPoolCooldowns.delete(this.host);
+          } else {
+            log?.debug?.(
+              `[SocketPool] Preserving D2C_DISC storm cooldown for host=${this.host} (expires in ${Math.ceil((existingCooldown.cooldownUntil - Date.now()) / 1e3)}s)`
+            );
+          }
         }
         entry.client = newClient;
         entry.refCount = 1;
@@ -11163,6 +11316,7 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       ...opts.channel !== void 0 ? { channel: opts.channel } : {}
     };
     const generalClient = new BaichuanClient(opts);
+    this.attachD2cDiscListener(generalClient);
     this.socketPool.set("general", {
       client: generalClient,
       refCount: 1,
@@ -15757,6 +15911,16 @@ ${stderr}`)
         }
         if (!frame) frame = await targetClient.sendFrame(baseParams);
         if (frame.header.responseCode !== 200) {
+          if (frame.header.responseCode === 400) {
+            const rejKey = `${ch}:${profile}`;
+            if (!this._rejectedStreamProfiles.has(rejKey)) {
+              this._rejectedStreamProfiles.add(rejKey);
+              this.videoStreamOptionsCache.clear();
+              this.logger?.warn?.(
+                `[ReolinkBaichuanApi] Stream profile rejected by device: channel=${ch} profile=${profile} (response_code 400). This profile will be excluded from available streams. The camera may not support this stream profile with the current firmware.`
+              );
+            }
+          }
           throw new Error(
             `Video stream request rejected (response_code ${frame.header.responseCode}). Expected response_code 200, camera returned ${frame.header.responseCode}`
           );
@@ -16227,6 +16391,49 @@ ${stderr}`)
     if (batteryVersion !== void 0) out.batteryVersion = batteryVersion;
     return out;
   }
+  /**
+   * Called when any BaichuanClient for this device receives a D2C_DISC.
+   *
+   * Two-tier response:
+   *  1. **Immediate**: every D2C_DISC applies a short socket pool cooldown
+   *     (10 s) to prevent reconnect attempts while the camera transitions to sleep.
+   *  2. **Storm**: ≥3 D2C_DISCs within 60 s triggers extended cooldown (120 s).
+   */
+  notifyD2cDisc() {
+    const now = Date.now();
+    this.lastD2cDiscAtMs = now;
+    const immediateCooldownUntil = now + _ReolinkBaichuanApi.D2C_DISC_IMMEDIATE_COOLDOWN_MS;
+    const existing = this.socketPoolCooldowns.get(this.host);
+    if (!existing || existing.cooldownUntil < immediateCooldownUntil) {
+      this.socketPoolCooldowns.set(this.host, {
+        failureCount: existing?.failureCount ?? 1,
+        lastFailureAt: now,
+        cooldownUntil: immediateCooldownUntil
+      });
+      this.logger?.log?.(
+        `[D2C_DISC] Immediate cooldown: socket pool blocked for ${_ReolinkBaichuanApi.D2C_DISC_IMMEDIATE_COOLDOWN_MS / 1e3}s`
+      );
+    }
+    this.d2cDiscTimestamps.push(now);
+    const cutoff = now - _ReolinkBaichuanApi.D2C_DISC_STORM_WINDOW_MS;
+    while (this.d2cDiscTimestamps.length > 0 && this.d2cDiscTimestamps[0] < cutoff) {
+      this.d2cDiscTimestamps.shift();
+    }
+    if (this.d2cDiscTimestamps.length >= _ReolinkBaichuanApi.D2C_DISC_STORM_THRESHOLD) {
+      const stormCooldownUntil = now + _ReolinkBaichuanApi.D2C_DISC_STORM_COOLDOWN_MS;
+      const currentEntry = this.socketPoolCooldowns.get(this.host);
+      if (!currentEntry || currentEntry.cooldownUntil < stormCooldownUntil) {
+        this.socketPoolCooldowns.set(this.host, {
+          failureCount: this.d2cDiscTimestamps.length,
+          lastFailureAt: now,
+          cooldownUntil: stormCooldownUntil
+        });
+        this.logger?.warn?.(
+          `[D2C_DISC] Storm detected: ${this.d2cDiscTimestamps.length} disconnects in ${_ReolinkBaichuanApi.D2C_DISC_STORM_WINDOW_MS / 1e3}s \u2192 socket pool cooldown ${_ReolinkBaichuanApi.D2C_DISC_STORM_COOLDOWN_MS / 1e3}s`
+        );
+      }
+    }
+  }
   /**
    * Best-effort sleeping inference for battery/BCUDP cameras.
    *
@@ -16257,6 +16464,8 @@ ${stderr}`)
     const socketConnected = this.client.isSocketConnected?.() ?? false;
     const now = Date.now();
     const cutoff = now - windowMs;
+    const msSinceD2cDisc = now - this.lastD2cDiscAtMs;
+    const recentD2cDisc = this.lastD2cDiscAtMs > 0 && msSinceD2cDisc < 3e4;
     const rx = (this.client.getRxHistory?.() ?? []).filter(
       (h) => h.atMs >= cutoff
     );
@@ -16264,6 +16473,12 @@ ${stderr}`)
       (h) => h.atMs >= cutoff
     );
     if (rx.length === 0 && tx.length === 0) {
+      if (recentD2cDisc) {
+        return {
+          state: "sleeping",
+          reason: `D2C_DISC ${Math.round(msSinceD2cDisc / 1e3)}s ago, camera terminated session`
+        };
+      }
       return {
         state: "sleeping",
         reason: `no rx/tx activity in last ${windowMs}ms${socketConnected ? "" : " (socket disconnected)"}`,
@@ -16287,6 +16502,12 @@ ${stderr}`)
         idleMs: now - firstWakingTx.atMs
       };
     }
+    if (recentD2cDisc) {
+      return {
+        state: "sleeping",
+        reason: `only non-waking cmdIds + D2C_DISC ${Math.round(msSinceD2cDisc / 1e3)}s ago, camera terminated session`
+      };
+    }
     return {
       state: "sleeping",
       reason: `only non-waking cmdIds observed in last ${windowMs}ms (non-waking: ${Array.from(nonWakingCmdIds).join(",")})`,
@@ -17721,6 +17942,8 @@ ${xml}`
       for (const metadata of params.metadatas) {
         const profile = metadata.profile;
         if (isMultiFocal && profile === "ext") continue;
+        if (this._rejectedStreamProfiles.has(`${params.channel}:${profile}`))
+          continue;
         if (params.includeRtsp && profile !== "ext") {
           const streamName = profile === "main" ? "main" : "sub";
           pushRtsp({
@@ -17882,7 +18105,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-55PR4WFD.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-UMN4C7SY.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -17898,7 +18121,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-55PR4WFD.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-UMN4C7SY.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -21580,4 +21803,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-UHFJPQA4.js.map
+//# sourceMappingURL=chunk-F2Y5U3YP.js.map