@camstack/addon-provider-reolink 1.2.125 → 1.2.127

package/dist/addon.js

@@ -5386,7 +5386,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DEuj7E3j.mjs
+//#region ../types/dist/sleep-BEyvfshj.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -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(),
@@ -29343,11 +29380,46 @@ var NativeObjectDetectionStatusSchema = object({
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
-	* Default FALSE (opt-in, cold-start) — onboard AI pushes are noisy/sparse and
-	* churn the tracker, so forwarding stays off until the operator enables it.
+	*
+	* 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()
 });
+/**
+* WHEN a camera's onboard detections carry geometry.
+*
+* - `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
+* 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",
+	"while-streaming",
+	"flag-only"
+]);
+var NativeObjectDetectionOptionsSchema = object({
+	/** Classes this firmware can detect — the same list the status reports. */
+	supportedClasses: array(NativeObjectClassEnum).readonly(),
+	/** What a detection from this camera carries. */
+	geometry: NativeObjectGeometryEnum
+});
+var NativeObjectDetectionSettingsPatchSchema = object({ enabled: boolean().optional() });
 var NativeObjectDetectionRuntimeStateSchema = NativeObjectDetectionStatusSchema.extend({ 
 /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
 lastFetchedAt: number() });
@@ -29357,13 +29429,23 @@ var nativeObjectDetectionCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	methods: { setEnabled: method(object({
-		deviceId: number(),
-		enabled: boolean()
-	}), _void(), {
-		kind: "mutation",
-		auth: "admin"
-	}) },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: NativeObjectDetectionSettingsPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setEnabled: method(object({
+			deviceId: number(),
+			enabled: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
 	events: { onDetected: { data: object({
 		deviceId: number(),
 		detection: NativeDetectionSchema
@@ -39216,12 +39298,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.getOptions": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"nativeObjectDetection.setEnabled": {
 		capName: "native-object-detection",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.setSettings": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"navigation.getFeatures": {
 		capName: "navigation",
 		capScope: "device",
@@ -43448,11 +43542,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"nativeObjectDetection.setEnabled": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"navigation.getFeatures": [{
 		name: "deviceId",
 		form: "single",
@@ -147632,10 +147736,22 @@ var REOLINK_ADDON_ID = "provider-reolink";
 * CameraNativeDetection class strings the rest of camstack consumes.
 * Keeping the loose-string contract — face/package etc are valid.
 */
+/**
+* Baichuan AI class name → the cap's `NativeObjectClass`.
+*
+* TWO vocabularies arrive here and both must be keyed. The simple-event push
+* (cmd 33 `<AItype>`) says `animal`; the capability probe (cmd 299
+* `getAiDetectTypes`) says `dog_cat` for the same class. Keying only the first
+* made `buildSupportedClasses` drop it, so camera 618 reported
+* `supportedClasses: ["person","vehicle"]` while its own `lastByClass` held a
+* live `animal` detection — the camera detected a class the system said it
+* could not. The two key-spaces do not collide, so one map serves both.
+*/
 var AI_CLASS_MAP = {
 	people: "person",
 	vehicle: "vehicle",
 	animal: "animal",
+	dog_cat: "animal",
 	face: "face",
 	package: "package"
 };
@@ -148476,6 +148592,30 @@ function mapDetectionEvent(event, cameraId, nowMs) {
 function isNativeObjectForwardingEnabled(capState) {
 	return capState?.enabled === true;
 }
+/**
+* The classes this firmware can detect, from the cmd-299 probe
+* (`deviceCache.aiDetectTypes`), mapped through {@link AI_CLASS_MAP}.
+*
+* Module-level and exported because the version of this that lived as a
+* closure inside `registerNativeObjectDetectionCap` had a test that
+* RE-IMPLEMENTED it — and the copy encoded the `dog_cat` gap as intent
+* ("skips unknown Baichuan type names"), so the suite stayed green while
+* camera 618 reported it could not detect a class it was detecting. One
+* function, one test, no copy.
+*
+* An absent probe is not an empty answer: it means nobody has asked the camera
+* yet, and the honest fallback is the full mapped value-set rather than "this
+* camera detects nothing".
+*/
+function buildSupportedNativeClasses(aiDetectTypes, isSupportedClass) {
+	if (!aiDetectTypes || aiDetectTypes.length === 0) return [...new Set(Object.values(AI_CLASS_MAP))].filter(isSupportedClass);
+	const classes = [];
+	for (const libName of aiDetectTypes) {
+		const mapped = AI_CLASS_MAP[libName];
+		if (mapped !== void 0 && isSupportedClass(mapped) && !classes.includes(mapped)) classes.push(mapped);
+	}
+	return classes;
+}
 function formatUserLevel(level) {
 	if (level === void 0 || level === null) return "user";
 	if (typeof level === "string" && level.length > 0) return level;
@@ -149161,6 +149301,13 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	loginPromise = null;
 	/** True once we've discovered (via getBatteryInfo) that this is a battery cam. */
 	isBattery = false;
+	/**
+	* When each AI class last had its suppression reported, so the gate's drop is
+	* on the record without one line per push. Per class because the vocabulary
+	* is five values and the finding is WHICH class the camera is pushing that
+	* nothing downstream receives.
+	*/
+	nativeDetectionSuppressedAt = /* @__PURE__ */ new Map();
 	/** Reconnect attempt counter — drives exponential backoff. */
 	reconnectAttempts = 0;
 	/** Pending reconnect timer; cleared on successful reconnect or removeDevice. */
@@ -152373,50 +152520,78 @@ 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 `true` — detections
-	*    flow unconditionally before a value is saved, preserving the existing
-	*    behaviour.
+	*  - `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
 	* slice.
 	*/
+	/**
+	* Report — once a minute per class — that the forwarding gate dropped an
+	* onboard AI detection. A branch that drops work names it (D391): without
+	* this the toggle being off looks exactly like a camera that pushes nothing,
+	* and the operator's only symptom is silence.
+	*/
+	noteNativeDetectionSuppressed(aiClass) {
+		const now = Date.now();
+		if (now - (this.nativeDetectionSuppressedAt.get(aiClass) ?? 0) < 6e4) return;
+		this.nativeDetectionSuppressedAt.set(aiClass, now);
+		this.ctx.logger.info("Reolink onboard AI detection dropped — forwarding is off for this camera", {
+			tags: { deviceId: this.id },
+			meta: {
+				class: aiClass,
+				battery: this.isBattery
+			}
+		});
+	}
 	registerNativeObjectDetectionCap() {
 		const CAP_NAME = "native-object-detection";
-		const buildSupportedClasses = () => {
-			const cached = this.config.get("deviceCache")?.aiDetectTypes;
-			if (!cached || cached.length === 0) return Object.values(AI_CLASS_MAP).filter(isNativeObjectClass);
-			const classes = [];
-			for (const libName of cached) {
-				const mapped = AI_CLASS_MAP[libName];
-				if (mapped !== void 0 && isNativeObjectClass(mapped)) classes.push(mapped);
-			}
-			return classes;
-		};
+		const buildSupportedClasses = () => buildSupportedNativeClasses(this.config.get("deviceCache")?.aiDetectTypes, isNativeObjectClass).filter(isNativeObjectClass);
 		const buildEmptyState = () => ({
 			enabled: false,
 			lastByClass: {},
 			supportedClasses: buildSupportedClasses(),
 			lastFetchedAt: 0
 		});
+		const bridge = createRuntimeStateBridge({
+			runtimeState: this.runtimeState,
+			cap: nativeObjectDetectionCapability,
+			ownDeviceId: this.id,
+			refresh: async () => {},
+			staleMs: Infinity,
+			empty: buildEmptyState
+		});
+		/** Shared by `setEnabled` and the derived form's `setSettings`. */
+		const applyEnabled = async (enabled) => {
+			await this.runtimeState.patchCapState(CAP_NAME, { enabled });
+			const api = this.api;
+			if (!api) return;
+			if (enabled) await this.resubscribeObjectDetections(api, "cap-enabled").catch((err) => {
+				this.ctx.logger.debug("Reolink objectDetections re-arm on enable failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			});
+			else await this.unsubscribeObjectDetections(api);
+		};
 		const provider = {
-			getStatus: createRuntimeStateBridge({
-				runtimeState: this.runtimeState,
-				cap: nativeObjectDetectionCapability,
-				ownDeviceId: this.id,
-				refresh: async () => {},
-				staleMs: Infinity,
-				empty: buildEmptyState
-			}).getStatus,
+			getStatus: bridge.getStatus,
+			getOptions: async ({ deviceId }) => {
+				if (deviceId !== this.id) return {
+					supportedClasses: [],
+					geometry: "flag-only"
+				};
+				return {
+					supportedClasses: buildSupportedClasses(),
+					geometry: this.isBattery ? "while-streaming" : "boxed"
+				};
+			},
+			setSettings: async ({ deviceId, settings }) => {
+				if (deviceId !== this.id) return;
+				if (settings.enabled === void 0) return;
+				await applyEnabled(settings.enabled);
+			},
 			setEnabled: async ({ deviceId, enabled }) => {
 				if (deviceId !== this.id) return;
-				await this.runtimeState.patchCapState(CAP_NAME, { enabled });
-				const api = this.api;
-				if (!api) return;
-				if (enabled) await this.resubscribeObjectDetections(api, "cap-enabled").catch((err) => {
-					this.ctx.logger.debug("Reolink objectDetections re-arm on enable failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-				});
-				else await this.unsubscribeObjectDetections(api);
+				await applyEnabled(enabled);
 			}
 		};
 		this.ctx.registerNativeCap(nativeObjectDetectionCapability, provider);
@@ -154047,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,
@@ -154080,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(),
@@ -154109,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);
@@ -155796,7 +155985,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						timestamp: now
 					}]
 				}));
-			}
+			} else this.noteNativeDetectionSuppressed(aiClass);
 			this.ctx.eventBus.emit(createEvent(EventCategory.MotionOnMotionChanged, eventSource, {
 				deviceId: this.id,
 				detected: true,

package/dist/addon.mjs

@@ -5381,7 +5381,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DEuj7E3j.mjs
+//#region ../types/dist/sleep-BEyvfshj.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -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(),
@@ -29338,11 +29375,46 @@ var NativeObjectDetectionStatusSchema = object({
 	supportedClasses: array(NativeObjectClassEnum).readonly(),
 	/**
 	* Whether forwarding of onboard AI detections is enabled for this device.
-	* Default FALSE (opt-in, cold-start) — onboard AI pushes are noisy/sparse and
-	* churn the tracker, so forwarding stays off until the operator enables it.
+	*
+	* 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()
 });
+/**
+* WHEN a camera's onboard detections carry geometry.
+*
+* - `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
+* 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",
+	"while-streaming",
+	"flag-only"
+]);
+var NativeObjectDetectionOptionsSchema = object({
+	/** Classes this firmware can detect — the same list the status reports. */
+	supportedClasses: array(NativeObjectClassEnum).readonly(),
+	/** What a detection from this camera carries. */
+	geometry: NativeObjectGeometryEnum
+});
+var NativeObjectDetectionSettingsPatchSchema = object({ enabled: boolean().optional() });
 var NativeObjectDetectionRuntimeStateSchema = NativeObjectDetectionStatusSchema.extend({ 
 /** Required by createRuntimeStateBridge — epoch ms of last refresh. */
 lastFetchedAt: number() });
@@ -29352,13 +29424,23 @@ var nativeObjectDetectionCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	methods: { setEnabled: method(object({
-		deviceId: number(),
-		enabled: boolean()
-	}), _void(), {
-		kind: "mutation",
-		auth: "admin"
-	}) },
+	methods: {
+		getOptions: method(object({ deviceId: number() }), NativeObjectDetectionOptionsSchema),
+		setSettings: method(object({
+			deviceId: number(),
+			settings: NativeObjectDetectionSettingsPatchSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setEnabled: method(object({
+			deviceId: number(),
+			enabled: boolean()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
 	events: { onDetected: { data: object({
 		deviceId: number(),
 		detection: NativeDetectionSchema
@@ -39211,12 +39293,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.getOptions": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"nativeObjectDetection.setEnabled": {
 		capName: "native-object-detection",
 		capScope: "device",
 		addonId: null,
 		access: "create"
 	},
+	"nativeObjectDetection.setSettings": {
+		capName: "native-object-detection",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"navigation.getFeatures": {
 		capName: "navigation",
 		capScope: "device",
@@ -43443,11 +43537,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"nativeObjectDetection.setEnabled": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"nativeObjectDetection.setSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"navigation.getFeatures": [{
 		name: "deviceId",
 		form: "single",
@@ -147627,10 +147731,22 @@ var REOLINK_ADDON_ID = "provider-reolink";
 * CameraNativeDetection class strings the rest of camstack consumes.
 * Keeping the loose-string contract — face/package etc are valid.
 */
+/**
+* Baichuan AI class name → the cap's `NativeObjectClass`.
+*
+* TWO vocabularies arrive here and both must be keyed. The simple-event push
+* (cmd 33 `<AItype>`) says `animal`; the capability probe (cmd 299
+* `getAiDetectTypes`) says `dog_cat` for the same class. Keying only the first
+* made `buildSupportedClasses` drop it, so camera 618 reported
+* `supportedClasses: ["person","vehicle"]` while its own `lastByClass` held a
+* live `animal` detection — the camera detected a class the system said it
+* could not. The two key-spaces do not collide, so one map serves both.
+*/
 var AI_CLASS_MAP = {
 	people: "person",
 	vehicle: "vehicle",
 	animal: "animal",
+	dog_cat: "animal",
 	face: "face",
 	package: "package"
 };
@@ -148471,6 +148587,30 @@ function mapDetectionEvent(event, cameraId, nowMs) {
 function isNativeObjectForwardingEnabled(capState) {
 	return capState?.enabled === true;
 }
+/**
+* The classes this firmware can detect, from the cmd-299 probe
+* (`deviceCache.aiDetectTypes`), mapped through {@link AI_CLASS_MAP}.
+*
+* Module-level and exported because the version of this that lived as a
+* closure inside `registerNativeObjectDetectionCap` had a test that
+* RE-IMPLEMENTED it — and the copy encoded the `dog_cat` gap as intent
+* ("skips unknown Baichuan type names"), so the suite stayed green while
+* camera 618 reported it could not detect a class it was detecting. One
+* function, one test, no copy.
+*
+* An absent probe is not an empty answer: it means nobody has asked the camera
+* yet, and the honest fallback is the full mapped value-set rather than "this
+* camera detects nothing".
+*/
+function buildSupportedNativeClasses(aiDetectTypes, isSupportedClass) {
+	if (!aiDetectTypes || aiDetectTypes.length === 0) return [...new Set(Object.values(AI_CLASS_MAP))].filter(isSupportedClass);
+	const classes = [];
+	for (const libName of aiDetectTypes) {
+		const mapped = AI_CLASS_MAP[libName];
+		if (mapped !== void 0 && isSupportedClass(mapped) && !classes.includes(mapped)) classes.push(mapped);
+	}
+	return classes;
+}
 function formatUserLevel(level) {
 	if (level === void 0 || level === null) return "user";
 	if (typeof level === "string" && level.length > 0) return level;
@@ -149156,6 +149296,13 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	loginPromise = null;
 	/** True once we've discovered (via getBatteryInfo) that this is a battery cam. */
 	isBattery = false;
+	/**
+	* When each AI class last had its suppression reported, so the gate's drop is
+	* on the record without one line per push. Per class because the vocabulary
+	* is five values and the finding is WHICH class the camera is pushing that
+	* nothing downstream receives.
+	*/
+	nativeDetectionSuppressedAt = /* @__PURE__ */ new Map();
 	/** Reconnect attempt counter — drives exponential backoff. */
 	reconnectAttempts = 0;
 	/** Pending reconnect timer; cleared on successful reconnect or removeDevice. */
@@ -152368,50 +152515,78 @@ 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 `true` — detections
-	*    flow unconditionally before a value is saved, preserving the existing
-	*    behaviour.
+	*  - `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
 	* slice.
 	*/
+	/**
+	* Report — once a minute per class — that the forwarding gate dropped an
+	* onboard AI detection. A branch that drops work names it (D391): without
+	* this the toggle being off looks exactly like a camera that pushes nothing,
+	* and the operator's only symptom is silence.
+	*/
+	noteNativeDetectionSuppressed(aiClass) {
+		const now = Date.now();
+		if (now - (this.nativeDetectionSuppressedAt.get(aiClass) ?? 0) < 6e4) return;
+		this.nativeDetectionSuppressedAt.set(aiClass, now);
+		this.ctx.logger.info("Reolink onboard AI detection dropped — forwarding is off for this camera", {
+			tags: { deviceId: this.id },
+			meta: {
+				class: aiClass,
+				battery: this.isBattery
+			}
+		});
+	}
 	registerNativeObjectDetectionCap() {
 		const CAP_NAME = "native-object-detection";
-		const buildSupportedClasses = () => {
-			const cached = this.config.get("deviceCache")?.aiDetectTypes;
-			if (!cached || cached.length === 0) return Object.values(AI_CLASS_MAP).filter(isNativeObjectClass);
-			const classes = [];
-			for (const libName of cached) {
-				const mapped = AI_CLASS_MAP[libName];
-				if (mapped !== void 0 && isNativeObjectClass(mapped)) classes.push(mapped);
-			}
-			return classes;
-		};
+		const buildSupportedClasses = () => buildSupportedNativeClasses(this.config.get("deviceCache")?.aiDetectTypes, isNativeObjectClass).filter(isNativeObjectClass);
 		const buildEmptyState = () => ({
 			enabled: false,
 			lastByClass: {},
 			supportedClasses: buildSupportedClasses(),
 			lastFetchedAt: 0
 		});
+		const bridge = createRuntimeStateBridge({
+			runtimeState: this.runtimeState,
+			cap: nativeObjectDetectionCapability,
+			ownDeviceId: this.id,
+			refresh: async () => {},
+			staleMs: Infinity,
+			empty: buildEmptyState
+		});
+		/** Shared by `setEnabled` and the derived form's `setSettings`. */
+		const applyEnabled = async (enabled) => {
+			await this.runtimeState.patchCapState(CAP_NAME, { enabled });
+			const api = this.api;
+			if (!api) return;
+			if (enabled) await this.resubscribeObjectDetections(api, "cap-enabled").catch((err) => {
+				this.ctx.logger.debug("Reolink objectDetections re-arm on enable failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			});
+			else await this.unsubscribeObjectDetections(api);
+		};
 		const provider = {
-			getStatus: createRuntimeStateBridge({
-				runtimeState: this.runtimeState,
-				cap: nativeObjectDetectionCapability,
-				ownDeviceId: this.id,
-				refresh: async () => {},
-				staleMs: Infinity,
-				empty: buildEmptyState
-			}).getStatus,
+			getStatus: bridge.getStatus,
+			getOptions: async ({ deviceId }) => {
+				if (deviceId !== this.id) return {
+					supportedClasses: [],
+					geometry: "flag-only"
+				};
+				return {
+					supportedClasses: buildSupportedClasses(),
+					geometry: this.isBattery ? "while-streaming" : "boxed"
+				};
+			},
+			setSettings: async ({ deviceId, settings }) => {
+				if (deviceId !== this.id) return;
+				if (settings.enabled === void 0) return;
+				await applyEnabled(settings.enabled);
+			},
 			setEnabled: async ({ deviceId, enabled }) => {
 				if (deviceId !== this.id) return;
-				await this.runtimeState.patchCapState(CAP_NAME, { enabled });
-				const api = this.api;
-				if (!api) return;
-				if (enabled) await this.resubscribeObjectDetections(api, "cap-enabled").catch((err) => {
-					this.ctx.logger.debug("Reolink objectDetections re-arm on enable failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-				});
-				else await this.unsubscribeObjectDetections(api);
+				await applyEnabled(enabled);
 			}
 		};
 		this.ctx.registerNativeCap(nativeObjectDetectionCapability, provider);
@@ -154042,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,
@@ -154075,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(),
@@ -154104,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);
@@ -155791,7 +155980,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						timestamp: now
 					}]
 				}));
-			}
+			} else this.noteNativeDetectionSuppressed(aiClass);
 			this.ctx.eventBus.emit(createEvent(EventCategory.MotionOnMotionChanged, eventSource, {
 				deviceId: this.id,
 				detected: true,

package/package.json

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