@apocaliss92/nodelink-js 0.4.14 → 0.4.16

package/dist/{chunk-WKETZFBI.js → chunk-65HTCC62.js}

@@ -11285,14 +11285,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 +12761,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 +12892,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 +13354,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();
@@ -19793,6 +19838,7 @@ ${xml}`
   async setAutoFocus(channel, disable, options) {
     const ch = this.normalizeChannel(channel);
     const disableVal = disable ? 1 : 0;
+    const extensionXml = buildChannelExtensionXml(ch);
     const payloadXml = `<?xml version="1.0" encoding="UTF-8" ?>
 <body>
 <AutoFocus version="1.1">
@@ -19803,6 +19849,7 @@ ${xml}`
     await this.sendXml({
       cmdId: BC_CMD_ID_SET_AUTO_FOCUS,
       channel: ch,
+      extensionXml,
       payloadXml,
       ...options?.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}
     });
@@ -23880,4 +23927,4 @@ export {
   isTcpFailureThatShouldFallbackToUdp,
   autoDetectDeviceType
 };
-//# sourceMappingURL=chunk-WKETZFBI.js.map
+//# sourceMappingURL=chunk-65HTCC62.js.map