@camstack/addon-provider-reolink 1.2.126 → 1.2.127

package/dist/addon.js

@@ -22078,6 +22078,14 @@ var MotionSourceEnum = _enum([
 */
 var MotionSourcesSchema = array(MotionSourceEnum);
 /**
+* Which root detectors a camera runs. Deliberately the SAME vocabulary
+* post-analysis already tags every detection with (`DetectionSource`) rather
+* than a second spelling of the same two ideas — the value an operator picks
+* here is the value that comes back on the track, the overlay and the debug
+* row.
+*/
+var DetectionSourcesSchema = array(DetectionSourceSchema);
+/**
 * Input shape for `pipeline-runner.reportMotion` cap method. Exported
 * so cap-side consumers (the orchestrator forward, the runner addon's
 * cap implementation, tests) can reuse the type instead of redeclaring
@@ -22228,6 +22236,35 @@ var RunnerCameraConfigSchema = object({
 	*   events; the orchestrator forwards to `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
+	/**
+	* WHICH root detector runs for this camera. The detection counterpart of
+	* {@link motionSources}, same shape and same discipline: a per-camera list
+	* of sources the system understands, vendor-agnostic, owned here.
+	*
+	* - `pipeline` — this runner's own root step on decoded pixels (`steps`).
+	* - `onboard` — the CAMERA's own detector, admitted only when it is named
+	*   here. Its boxes reach post-analysis on the same
+	*   `PipelineInferenceResult` payload as the pipeline's, so an onboard-born
+	*   track gets the same tracker, the same overlay and the same detail
+	*   subtree (face / plate / embedding).
+	*
+	* `['onboard']` alone is the REPLACEMENT: this runner's root step does not
+	* run, and that is where a camera with a usable onboard detector buys back
+	* its share of the accelerator. It saves the root inference, not the decode
+	* — the detail subtree still needs pixels to cut crops from.
+	*
+	* A camera whose onboard detections carry no geometry cannot serve as a root
+	* step at all (there is nothing to track), and the cap that knows this says
+	* so on `native-object-detection.getOptions().geometry`. On Reolink that is
+	* every battery camera: the boxes ride a sub-stream a battery camera never
+	* attaches, so such a camera stays on `['pipeline']` and its onboard AI is
+	* worth exactly what it already is — a wake signal with a class.
+	*
+	* Defaults to `['pipeline']`, which is byte-for-byte today's behaviour: a
+	* vendor never turns a detector on for the operator, and neither does a
+	* default.
+	*/
+	detectionSources: DetectionSourcesSchema.default(["pipeline"]),
 	pipelineEnabled: boolean().default(true),
 	/** Ordered tree of video steps. Absent → runner skips video detection. */
 	steps: array(PipelineStepInputSchema).readonly().optional(),
@@ -29344,31 +29381,38 @@ var NativeObjectDetectionStatusSchema = object({
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
 	*
-	* The COLD-START default is the provider's, and it is not one value for
-	* every camera: a mains camera carries the boxed side-channel and its
-	* detections are usable subjects, so it defaults ON; a battery camera never
-	* attaches that channel, so the same toggle would buy it nothing but a write
-	* — it defaults OFF and an operator who wants it turns it on knowing what it
-	* costs. {@link NativeObjectDetectionOptionsSchema.geometry} is how the UI
-	* says which of the two a camera is.
+	* Cold-start OFF on every camera. A vendor does not decide which detector a
+	* camera runs — that is the operator's choice, and it is made where every
+	* other detection choice is made. `geometry` on
+	* {@link NativeObjectDetectionOptionsSchema} is how the form says what the
+	* choice would buy this particular camera.
 	*/
 	enabled: boolean()
 });
 /**
-* What a camera's onboard detections actually CARRY.
+* WHEN a camera's onboard detections carry geometry.
 *
-* `boxed` — the firmware ships a bounding box with the class, so a detection is
-* a subject the pipeline can track, crop and score.
-* `flag-only` — the firmware ships the class and nothing else. The pipeline
-* needs geometry to make a subject out of it, so such a push reaches the
-* tracker as motion and no further. On Reolink this is every battery camera:
-* the boxes ride the BcMedia sub-stream, which a battery camera never attaches.
+* - `boxed` — always. The provider holds a standing channel for the boxes, so
+*   a detection is a trackable subject whenever the camera sees one.
+* - `while-streaming` — only while some stream of this camera is already open.
+*   The boxes ride the video's own side-channel rather than a feed of their
+*   own, so they cost nothing and they exist only when something is pulling.
+*   On Reolink this is every BATTERY camera: a persistent second feed is real
+*   radio drain, but a camera that is awake is awake precisely because
+*   something is in front of it, and its stream is already being pulled.
+* - `flag-only` — never. The firmware ships the class and nothing else; the
+*   pipeline needs geometry to make a subject, so such a push reaches the
+*   tracker as motion and no further.
 *
 * Reported and not inferred, because the operator's question in front of the
-* toggle is "what do I get", and "a class with no box" and "a subject" are
-* different answers (D14: the derived form is only as honest as `getOptions`).
+* picker is "what do I get", and these are three different answers (D14: the
+* derived form is only as honest as `getOptions`).
 */
-var NativeObjectGeometryEnum = _enum(["boxed", "flag-only"]);
+var NativeObjectGeometryEnum = _enum([
+	"boxed",
+	"while-streaming",
+	"flag-only"
+]);
 var NativeObjectDetectionOptionsSchema = object({
 	/** Classes this firmware can detect — the same list the status reports. */
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
@@ -29385,11 +29429,6 @@ var nativeObjectDetectionCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "derived-form",
-		builderId: "native-object-detection",
-		tab: "motion"
-	} },
 	methods: {
 		getOptions: method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema),
 		setSettings: method(object({
@@ -152481,10 +152520,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*    yet (e.g. fresh device, no config cached).
 	*  - `lastByClass`: updated in `handleSimpleEvent` every time an AI-class
 	*    event fires, regardless of the `enabled` flag.
-	*  - `enabled`: operator toggle. Cold-start default is the camera's power
-	*    source — ON for a mains camera (its detections carry boxes and become
-	*    subjects), OFF for a battery one (no boxed side-channel, so the toggle
-	*    would buy it nothing). See `buildEmptyState`.
+	*  - `enabled`: operator toggle, cold-start OFF on every camera. A vendor
+	*    never turns a detector on for the operator; see `buildEmptyState`.
 	*
 	* Follows the trampoline pattern from `registerStreamParamsCap` — no
 	* parallel private fields; all state lives in the kernel runtimeState
@@ -152512,7 +152549,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		const CAP_NAME = "native-object-detection";
 		const buildSupportedClasses = () => buildSupportedNativeClasses(this.config.get("deviceCache")?.aiDetectTypes, isNativeObjectClass).filter(isNativeObjectClass);
 		const buildEmptyState = () => ({
-			enabled: !this.isBattery,
+			enabled: false,
 			lastByClass: {},
 			supportedClasses: buildSupportedClasses(),
 			lastFetchedAt: 0
@@ -152544,7 +152581,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				};
 				return {
 					supportedClasses: buildSupportedClasses(),
-					geometry: this.isBattery ? "flag-only" : "boxed"
+					geometry: this.isBattery ? "while-streaming" : "boxed"
 				};
 			},
 			setSettings: async ({ deviceId, settings }) => {
@@ -154185,14 +154222,22 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			});
 		} catch {}
 		this.objectDetectionsSubscribed = false;
-		if (this.isBattery) {
-			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — battery cam", { meta: { reason } });
-			return;
-		}
 		if (!isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) {
 			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — cap disabled", { meta: { reason } });
 			return;
 		}
+		if (this.isBattery) {
+			api.onDetection(this.handleObjectDetectionsBound);
+			this.objectDetectionsSubscribed = true;
+			this.ctx.logger.info("Reolink onboard boxes ride the open stream (battery cam)", {
+				tags: { deviceId: this.id },
+				meta: {
+					reason,
+					channel
+				}
+			});
+			return;
+		}
 		if (!api.client.isSocketConnected() || !api.client.loggedIn) {
 			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — socket not ready", { meta: {
 				reason,
@@ -154218,6 +154263,11 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	async unsubscribeObjectDetections(api) {
 		if (!this.objectDetectionsSubscribed) return;
+		if (this.isBattery) {
+			api.offDetection(this.handleObjectDetectionsBound);
+			this.objectDetectionsSubscribed = false;
+			return;
+		}
 		try {
 			await api.offObjectDetections(this.handleObjectDetectionsBound, {
 				channel: this.getChannel(),
@@ -154247,6 +154297,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	handleObjectDetections(event) {
 		if (!isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) return;
+		if (event.channel !== this.getChannel()) return;
 		if (event.boxes.length === 0) return;
 		const now = Date.now();
 		const payload = mapDetectionEvent(event, this.id, now);

package/dist/addon.mjs

@@ -22073,6 +22073,14 @@ var MotionSourceEnum = _enum([
 */
 var MotionSourcesSchema = array(MotionSourceEnum);
 /**
+* Which root detectors a camera runs. Deliberately the SAME vocabulary
+* post-analysis already tags every detection with (`DetectionSource`) rather
+* than a second spelling of the same two ideas — the value an operator picks
+* here is the value that comes back on the track, the overlay and the debug
+* row.
+*/
+var DetectionSourcesSchema = array(DetectionSourceSchema);
+/**
 * Input shape for `pipeline-runner.reportMotion` cap method. Exported
 * so cap-side consumers (the orchestrator forward, the runner addon's
 * cap implementation, tests) can reuse the type instead of redeclaring
@@ -22223,6 +22231,35 @@ var RunnerCameraConfigSchema = object({
 	*   events; the orchestrator forwards to `reportMotion`.
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
+	/**
+	* WHICH root detector runs for this camera. The detection counterpart of
+	* {@link motionSources}, same shape and same discipline: a per-camera list
+	* of sources the system understands, vendor-agnostic, owned here.
+	*
+	* - `pipeline` — this runner's own root step on decoded pixels (`steps`).
+	* - `onboard` — the CAMERA's own detector, admitted only when it is named
+	*   here. Its boxes reach post-analysis on the same
+	*   `PipelineInferenceResult` payload as the pipeline's, so an onboard-born
+	*   track gets the same tracker, the same overlay and the same detail
+	*   subtree (face / plate / embedding).
+	*
+	* `['onboard']` alone is the REPLACEMENT: this runner's root step does not
+	* run, and that is where a camera with a usable onboard detector buys back
+	* its share of the accelerator. It saves the root inference, not the decode
+	* — the detail subtree still needs pixels to cut crops from.
+	*
+	* A camera whose onboard detections carry no geometry cannot serve as a root
+	* step at all (there is nothing to track), and the cap that knows this says
+	* so on `native-object-detection.getOptions().geometry`. On Reolink that is
+	* every battery camera: the boxes ride a sub-stream a battery camera never
+	* attaches, so such a camera stays on `['pipeline']` and its onboard AI is
+	* worth exactly what it already is — a wake signal with a class.
+	*
+	* Defaults to `['pipeline']`, which is byte-for-byte today's behaviour: a
+	* vendor never turns a detector on for the operator, and neither does a
+	* default.
+	*/
+	detectionSources: DetectionSourcesSchema.default(["pipeline"]),
 	pipelineEnabled: boolean().default(true),
 	/** Ordered tree of video steps. Absent → runner skips video detection. */
 	steps: array(PipelineStepInputSchema).readonly().optional(),
@@ -29339,31 +29376,38 @@ var NativeObjectDetectionStatusSchema = object({
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
 	*
-	* The COLD-START default is the provider's, and it is not one value for
-	* every camera: a mains camera carries the boxed side-channel and its
-	* detections are usable subjects, so it defaults ON; a battery camera never
-	* attaches that channel, so the same toggle would buy it nothing but a write
-	* — it defaults OFF and an operator who wants it turns it on knowing what it
-	* costs. {@link NativeObjectDetectionOptionsSchema.geometry} is how the UI
-	* says which of the two a camera is.
+	* Cold-start OFF on every camera. A vendor does not decide which detector a
+	* camera runs — that is the operator's choice, and it is made where every
+	* other detection choice is made. `geometry` on
+	* {@link NativeObjectDetectionOptionsSchema} is how the form says what the
+	* choice would buy this particular camera.
 	*/
 	enabled: boolean()
 });
 /**
-* What a camera's onboard detections actually CARRY.
+* WHEN a camera's onboard detections carry geometry.
 *
-* `boxed` — the firmware ships a bounding box with the class, so a detection is
-* a subject the pipeline can track, crop and score.
-* `flag-only` — the firmware ships the class and nothing else. The pipeline
-* needs geometry to make a subject out of it, so such a push reaches the
-* tracker as motion and no further. On Reolink this is every battery camera:
-* the boxes ride the BcMedia sub-stream, which a battery camera never attaches.
+* - `boxed` — always. The provider holds a standing channel for the boxes, so
+*   a detection is a trackable subject whenever the camera sees one.
+* - `while-streaming` — only while some stream of this camera is already open.
+*   The boxes ride the video's own side-channel rather than a feed of their
+*   own, so they cost nothing and they exist only when something is pulling.
+*   On Reolink this is every BATTERY camera: a persistent second feed is real
+*   radio drain, but a camera that is awake is awake precisely because
+*   something is in front of it, and its stream is already being pulled.
+* - `flag-only` — never. The firmware ships the class and nothing else; the
+*   pipeline needs geometry to make a subject, so such a push reaches the
+*   tracker as motion and no further.
 *
 * Reported and not inferred, because the operator's question in front of the
-* toggle is "what do I get", and "a class with no box" and "a subject" are
-* different answers (D14: the derived form is only as honest as `getOptions`).
+* picker is "what do I get", and these are three different answers (D14: the
+* derived form is only as honest as `getOptions`).
 */
-var NativeObjectGeometryEnum = _enum(["boxed", "flag-only"]);
+var NativeObjectGeometryEnum = _enum([
+	"boxed",
+	"while-streaming",
+	"flag-only"
+]);
 var NativeObjectDetectionOptionsSchema = object({
 	/** Classes this firmware can detect — the same list the status reports. */
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
@@ -29380,11 +29424,6 @@ var nativeObjectDetectionCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "derived-form",
-		builderId: "native-object-detection",
-		tab: "motion"
-	} },
 	methods: {
 		getOptions: method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema),
 		setSettings: method(object({
@@ -152476,10 +152515,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*    yet (e.g. fresh device, no config cached).
 	*  - `lastByClass`: updated in `handleSimpleEvent` every time an AI-class
 	*    event fires, regardless of the `enabled` flag.
-	*  - `enabled`: operator toggle. Cold-start default is the camera's power
-	*    source — ON for a mains camera (its detections carry boxes and become
-	*    subjects), OFF for a battery one (no boxed side-channel, so the toggle
-	*    would buy it nothing). See `buildEmptyState`.
+	*  - `enabled`: operator toggle, cold-start OFF on every camera. A vendor
+	*    never turns a detector on for the operator; see `buildEmptyState`.
 	*
 	* Follows the trampoline pattern from `registerStreamParamsCap` — no
 	* parallel private fields; all state lives in the kernel runtimeState
@@ -152507,7 +152544,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		const CAP_NAME = "native-object-detection";
 		const buildSupportedClasses = () => buildSupportedNativeClasses(this.config.get("deviceCache")?.aiDetectTypes, isNativeObjectClass).filter(isNativeObjectClass);
 		const buildEmptyState = () => ({
-			enabled: !this.isBattery,
+			enabled: false,
 			lastByClass: {},
 			supportedClasses: buildSupportedClasses(),
 			lastFetchedAt: 0
@@ -152539,7 +152576,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				};
 				return {
 					supportedClasses: buildSupportedClasses(),
-					geometry: this.isBattery ? "flag-only" : "boxed"
+					geometry: this.isBattery ? "while-streaming" : "boxed"
 				};
 			},
 			setSettings: async ({ deviceId, settings }) => {
@@ -154180,14 +154217,22 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			});
 		} catch {}
 		this.objectDetectionsSubscribed = false;
-		if (this.isBattery) {
-			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — battery cam", { meta: { reason } });
-			return;
-		}
 		if (!isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) {
 			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — cap disabled", { meta: { reason } });
 			return;
 		}
+		if (this.isBattery) {
+			api.onDetection(this.handleObjectDetectionsBound);
+			this.objectDetectionsSubscribed = true;
+			this.ctx.logger.info("Reolink onboard boxes ride the open stream (battery cam)", {
+				tags: { deviceId: this.id },
+				meta: {
+					reason,
+					channel
+				}
+			});
+			return;
+		}
 		if (!api.client.isSocketConnected() || !api.client.loggedIn) {
 			this.ctx.logger.debug("Reolink objectDetections subscribe skipped — socket not ready", { meta: {
 				reason,
@@ -154213,6 +154258,11 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	async unsubscribeObjectDetections(api) {
 		if (!this.objectDetectionsSubscribed) return;
+		if (this.isBattery) {
+			api.offDetection(this.handleObjectDetectionsBound);
+			this.objectDetectionsSubscribed = false;
+			return;
+		}
 		try {
 			await api.offObjectDetections(this.handleObjectDetectionsBound, {
 				channel: this.getChannel(),
@@ -154242,6 +154292,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	handleObjectDetections(event) {
 		if (!isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) return;
+		if (event.channel !== this.getChannel()) return;
 		if (event.boxes.length === 0) return;
 		const now = Date.now();
 		const payload = mapDetectionEvent(event, this.id, now);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-provider-reolink",
-  "version": "1.2.126",
+  "version": "1.2.127",
   "description": "Reolink camera device provider addon for CamStack — native Baichuan protocol",
   "keywords": [
     "camstack",