@apocaliss92/nodelink-js 0.4.15 → 0.4.17

package/dist/{DiagnosticsTools-BQOWJ23L.js → DiagnosticsTools-HO3VI6D5.js}

@@ -12,7 +12,7 @@ import {
   sampleStreams,
   sanitizeFixtureData,
   testChannelStreams
-} from "./chunk-2JNXKT3C.js";
+} from "./chunk-S2UTGNFN.js";
 import "./chunk-C57QV7IL.js";
 export {
   captureModelFixtures,
@@ -29,4 +29,4 @@ export {
   sanitizeFixtureData,
   testChannelStreams
 };
-//# sourceMappingURL=DiagnosticsTools-BQOWJ23L.js.map
+//# sourceMappingURL=DiagnosticsTools-HO3VI6D5.js.map

package/dist/{chunk-6KYLA4YI.js → chunk-EF6BCSCZ.js}

@@ -30,7 +30,7 @@ import {
   runAllDiagnosticsConsecutively,
   runMultifocalDiagnosticsConsecutively,
   xmlEscape
-} from "./chunk-2JNXKT3C.js";
+} from "./chunk-S2UTGNFN.js";
 import {
   BC_CLASS_FILE_DOWNLOAD,
   BC_CLASS_LEGACY,
@@ -10919,7 +10919,15 @@ var applyFloodlightSettingsToXml = (xml, settings) => {
 // src/reolink/baichuan/ReolinkBaichuanApi.ts
 var DUAL_LENS_DUAL_MOTION_MODELS = /* @__PURE__ */ new Set([
   "Reolink Duo PoE",
-  "Reolink Duo WiFi"
+  "Reolink Duo WiFi",
+  // Duo 2 family
+  "Reolink Duo 2 PoE",
+  "Reolink Duo 2 WiFi",
+  // Duo 3 family — physically dual-sensor, marketed as a stitched 16MP feed
+  // (the firmware exposes a single logical channel, so callers should still
+  // check `getDualLensChannelInfo` for the actual channel topology).
+  "Reolink Duo 3 PoE",
+  "Reolink Duo 3 WiFi"
 ]);
 var DUAL_LENS_SINGLE_MOTION_MODELS = /* @__PURE__ */ new Set([
   "Reolink TrackMix",
@@ -10934,7 +10942,10 @@ var DUAL_LENS_MODELS = /* @__PURE__ */ new Set([
 ]);
 var isDualLenseModel = (model) => {
   const lower = model.toLowerCase();
-  return Array.from(DUAL_LENS_MODELS).some((m) => m.toLowerCase() === lower) || lower.includes("trackmix") || lower.includes("trackflex");
+  if (Array.from(DUAL_LENS_MODELS).some((m) => m.toLowerCase() === lower)) {
+    return true;
+  }
+  return lower.includes("trackmix") || lower.includes("trackflex") || /\bduo\b/.test(lower);
 };
 var NVR_HUB_EXACT_TYPES = ["NVR", "WIFI_NVR", "HOMEHUB"];
 var NVR_HUB_MODEL_PATTERNS = [
@@ -11285,14 +11296,15 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
   // _registerVideoStreamForDetection (called from BaichuanVideoStream.start).
   detectionEventListeners = /* @__PURE__ */ new Set();
   detectionEventStreamHooks = /* @__PURE__ */ new Map();
-  // Auto-managed substream for `onObjectDetections` listeners. Reference-counted
-  // by the listener set: the substream is opened on the first listener and torn
-  // down with the last one. Mirrors `onSimpleEvent`'s subscribe/unsubscribe
-  // lifecycle so a caller never has to manage a video stream just to read AI
-  // detections.
-  objectDetectionListeners = /* @__PURE__ */ new Set();
-  objectDetectionStream;
-  objectDetectionStreamStartInFlight;
+  // Auto-managed substreams for `onObjectDetections` listeners. One entry per
+  // `(channel, profile)` tuple — required for NVR/Hub setups where AI boxes
+  // live on a specific channel, and for callers that need detections off a
+  // profile other than the default `sub`. The substream is opened on the first
+  // listener of a tuple and torn down when the last one for that tuple leaves.
+  objectDetectionSubs = /* @__PURE__ */ new Map();
+  // Single bridge installed into `detectionEventListeners` while at least one
+  // object-detection subscription is active. It routes events to the correct
+  // tuple's listener set based on `event.channel` / `event.profile`.
   objectDetectionInternalListener;
   simpleEventSubscribeInFlight;
   simpleEventUnsubscribeInFlight;
@@ -12760,87 +12772,129 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
    * Subscribe to AI object detections (people / vehicle / animal / face boxes
    * with class label and confidence) without managing a video stream yourself.
    *
-   * Mirrors {@link onSimpleEvent} end-to-end: the API opens a dedicated
-   * substream behind the scenes on the first listener, forwards every box-bearing
-   * `additionalHeader` to your callback, and tears the stream down when the last
-   * listener unsubscribes. The substream is the lightest profile (typically
-   * 640×360) so the additional bandwidth/CPU overhead is minimal.
+   * Mirrors {@link onSimpleEvent} end-to-end: on the first listener for a given
+   * `(channel, profile)` tuple the API ensures the corresponding video stream
+   * is running (the pool socket may already be shared with a regular consumer),
+   * forwards every box-bearing `additionalHeader` to your callback, and tears
+   * the stream down when the last listener for that tuple unsubscribes.
+   *
+   * Defaults — `channel: 0`, `profile: "sub"` — match a single-lens standalone
+   * camera. **For NVR/Hub child cameras you must pass the channel explicitly**,
+   * otherwise the substream opens on channel 0 and never sees the AI boxes for
+   * the other channels. The `sub` profile is recommended (lighter bandwidth)
+   * but `main` / `ext` are accepted if you specifically need detections off a
+   * different feed.
    *
    * Each event carries normalized `[0, 1]` box coordinates, a class label, and
    * a confidence score — render-ready without further conversion.
    */
-  async onObjectDetections(callback) {
-    this.objectDetectionListeners.add(callback);
+  async onObjectDetections(callback, options) {
+    const channel = options?.channel ?? 0;
+    const profile = options?.profile ?? "sub";
+    const key = this.objectDetectionKey(channel, profile);
+    let entry = this.objectDetectionSubs.get(key);
+    if (!entry) {
+      entry = { channel, profile, listeners: /* @__PURE__ */ new Set() };
+      this.objectDetectionSubs.set(key, entry);
+    }
+    entry.listeners.add(callback);
     this.logger.debug?.(
-      `[ReolinkBaichuanApi] onObjectDetections: registering listener (total=${this.objectDetectionListeners.size})`
+      `[ReolinkBaichuanApi] onObjectDetections: registering listener for ch${channel}/${profile} (total=${entry.listeners.size})`
     );
-    await this.ensureObjectDetectionStream();
+    await this.ensureObjectDetectionStream(key);
   }
   /**
-   * Remove one detection callback, or all of them if `callback` is omitted.
-   * When the last listener is removed the auto-managed substream is closed.
+   * Remove a detection callback for a given `(channel, profile)` tuple — or,
+   * if `options` is omitted, remove the callback from every active tuple. When
+   * `callback` is also omitted, every listener on the targeted tuples is
+   * cleared. The auto-managed substream of a tuple is closed when its last
+   * listener is removed.
    */
-  async offObjectDetections(callback) {
-    if (callback) {
-      this.objectDetectionListeners.delete(callback);
-    } else {
-      this.objectDetectionListeners.clear();
-    }
-    if (this.objectDetectionListeners.size === 0) {
-      await this.tearDownObjectDetectionStream();
+  async offObjectDetections(callback, options) {
+    const targetKeys = options ? [
+      this.objectDetectionKey(
+        options.channel ?? 0,
+        options.profile ?? "sub"
+      )
+    ] : [...this.objectDetectionSubs.keys()];
+    for (const key of targetKeys) {
+      const entry = this.objectDetectionSubs.get(key);
+      if (!entry) continue;
+      if (callback) {
+        entry.listeners.delete(callback);
+      } else {
+        entry.listeners.clear();
+      }
+      if (entry.listeners.size === 0) {
+        await this.tearDownObjectDetectionStream(key);
+      }
     }
   }
-  async ensureObjectDetectionStream() {
-    if (this.objectDetectionStream) return;
-    if (this.objectDetectionStreamStartInFlight) {
-      await this.objectDetectionStreamStartInFlight;
+  objectDetectionKey(channel, profile) {
+    return `${channel}:${profile}`;
+  }
+  ensureObjectDetectionInternalListener() {
+    if (this.objectDetectionInternalListener) return;
+    const internal = (event) => {
+      const key = this.objectDetectionKey(event.channel, event.profile);
+      const entry = this.objectDetectionSubs.get(key);
+      if (!entry || entry.listeners.size === 0) return;
+      for (const cb of entry.listeners) {
+        try {
+          void Promise.resolve(cb(event)).catch((e) => {
+            (this.logger.warn ?? this.logger.error).call(
+              this.logger,
+              "[ReolinkBaichuanApi] onObjectDetections handler error",
+              formatErrorForLog(e)
+            );
+          });
+        } catch (e) {
+          (this.logger.warn ?? this.logger.error).call(
+            this.logger,
+            "[ReolinkBaichuanApi] onObjectDetections handler error",
+            formatErrorForLog(e)
+          );
+        }
+      }
+    };
+    this.objectDetectionInternalListener = internal;
+    this.detectionEventListeners.add(internal);
+  }
+  maybeDropObjectDetectionInternalListener() {
+    if (this.objectDetectionSubs.size > 0) return;
+    if (!this.objectDetectionInternalListener) return;
+    this.detectionEventListeners.delete(this.objectDetectionInternalListener);
+    this.objectDetectionInternalListener = void 0;
+  }
+  async ensureObjectDetectionStream(key) {
+    const entry = this.objectDetectionSubs.get(key);
+    if (!entry) return;
+    if (entry.stream) return;
+    if (entry.startInFlight) {
+      await entry.startInFlight;
       return;
     }
-    this.objectDetectionStreamStartInFlight = (async () => {
+    entry.startInFlight = (async () => {
       const { BaichuanVideoStream: BaichuanVideoStream2 } = await import("./BaichuanVideoStream-HGPU2MZ3.js");
-      const sessionKey = `live:object-detections:ch0:sub`;
+      const sessionKey = `live:object-detections:ch${entry.channel}:${entry.profile}`;
       const dedicated = await this.createDedicatedSession(sessionKey);
       const stream = new BaichuanVideoStream2({
         client: dedicated.client,
         api: this,
-        channel: 0,
-        profile: "sub",
+        channel: entry.channel,
+        profile: entry.profile,
         logger: this.logger
       });
-      this.objectDetectionInternalListener = (event) => {
-        for (const cb of this.objectDetectionListeners) {
-          try {
-            void Promise.resolve(cb(event)).catch((e) => {
-              (this.logger.warn ?? this.logger.error).call(
-                this.logger,
-                "[ReolinkBaichuanApi] onObjectDetections handler error",
-                formatErrorForLog(e)
-              );
-            });
-          } catch (e) {
-            (this.logger.warn ?? this.logger.error).call(
-              this.logger,
-              "[ReolinkBaichuanApi] onObjectDetections handler error",
-              formatErrorForLog(e)
-            );
-          }
-        }
-      };
-      this.detectionEventListeners.add(this.objectDetectionInternalListener);
+      this.ensureObjectDetectionInternalListener();
       try {
         await stream.start();
       } catch (e) {
-        if (this.objectDetectionInternalListener) {
-          this.detectionEventListeners.delete(
-            this.objectDetectionInternalListener
-          );
-          this.objectDetectionInternalListener = void 0;
-        }
         await dedicated.release().catch(() => {
         });
+        this.maybeDropObjectDetectionInternalListener();
         throw e;
       }
-      this.objectDetectionStream = {
+      entry.stream = {
         stop: () => stream.stop(),
         release: () => dedicated.release()
       };
@@ -12849,35 +12903,36 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
       );
     })();
     try {
-      await this.objectDetectionStreamStartInFlight;
+      await entry.startInFlight;
     } finally {
-      this.objectDetectionStreamStartInFlight = void 0;
+      delete entry.startInFlight;
     }
   }
-  async tearDownObjectDetectionStream() {
-    const handle = this.objectDetectionStream;
-    this.objectDetectionStream = void 0;
-    if (this.objectDetectionInternalListener) {
-      this.detectionEventListeners.delete(this.objectDetectionInternalListener);
-      this.objectDetectionInternalListener = void 0;
-    }
-    if (!handle) return;
-    try {
-      await handle.stop();
-    } catch (e) {
-      this.logger.debug?.(
-        `[ReolinkBaichuanApi] onObjectDetections: stream stop error: ${formatErrorForLog(e)}`
-      );
-    }
-    try {
-      await handle.release();
-    } catch (e) {
-      this.logger.debug?.(
-        `[ReolinkBaichuanApi] onObjectDetections: session release error: ${formatErrorForLog(e)}`
-      );
+  async tearDownObjectDetectionStream(key) {
+    const entry = this.objectDetectionSubs.get(key);
+    if (!entry) return;
+    const handle = entry.stream;
+    delete entry.stream;
+    this.objectDetectionSubs.delete(key);
+    if (handle) {
+      try {
+        await handle.stop();
+      } catch (e) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] onObjectDetections: stream stop error (key=${key}): ${formatErrorForLog(e)}`
+        );
+      }
+      try {
+        await handle.release();
+      } catch (e) {
+        this.logger.debug?.(
+          `[ReolinkBaichuanApi] onObjectDetections: session release error (key=${key}): ${formatErrorForLog(e)}`
+        );
+      }
     }
+    this.maybeDropObjectDetectionInternalListener();
     this.logger.debug?.(
-      `[ReolinkBaichuanApi] onObjectDetections: substream torn down`
+      `[ReolinkBaichuanApi] onObjectDetections: substream torn down (key=${key})`
     );
   }
   /**
@@ -13310,9 +13365,10 @@ var ReolinkBaichuanApi = class _ReolinkBaichuanApi {
     this.stopUdpSleepInference();
     this.stopSimpleEventWatchdog();
     this.stopSimpleEventResubscribeTimer();
-    this.objectDetectionListeners.clear();
-    await this.tearDownObjectDetectionStream().catch(() => {
-    });
+    for (const key of [...this.objectDetectionSubs.keys()]) {
+      await this.tearDownObjectDetectionStream(key).catch(() => {
+      });
+    }
     await this.cleanup();
     await this.stopAllActiveStreams();
     await this.cleanupSocketPool();
@@ -18688,6 +18744,13 @@ ${xml}`
       model = deviceInfo.type?.trim();
     } catch {
     }
+    if (!model) {
+      try {
+        const deviceInfoBase = await this.getInfo(void 0, { tags: ["type"] });
+        model = deviceInfoBase.type?.trim();
+      } catch {
+      }
+    }
     try {
       const capabilities = await this.getDeviceCapabilities(channel);
       channelNum = capabilities.support?.channelNum;
@@ -19393,7 +19456,7 @@ ${xml}`
    * @returns Test results for all stream types and profiles
    */
   async testChannelStreams(channel, logger) {
-    const { testChannelStreams } = await import("./DiagnosticsTools-BQOWJ23L.js");
+    const { testChannelStreams } = await import("./DiagnosticsTools-HO3VI6D5.js");
     return await testChannelStreams({
       api: this,
       channel: this.normalizeChannel(channel),
@@ -19409,7 +19472,7 @@ ${xml}`
    * @returns Complete diagnostics for all channels and streams
    */
   async collectMultifocalDiagnostics(logger) {
-    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-BQOWJ23L.js");
+    const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-HO3VI6D5.js");
     return await collectMultifocalDiagnostics({
       api: this,
       logger
@@ -23882,4 +23945,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-6KYLA4YI.js.map
+//# sourceMappingURL=chunk-EF6BCSCZ.js.map