@camstack/addon-provider-reolink 1.2.124 → 1.2.126

package/dist/addon.js

@@ -25,7 +25,7 @@ let fs_promises = require("fs/promises");
 fs_promises = require_chunk.__toESM(fs_promises, 1);
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
-//#region ../types/dist/event-category-ZyX6jcse.mjs
+//#region ../types/dist/event-category-BVDXG4tB.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -642,6 +642,20 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* pull-reconcile from the provider's `getStatus` on reconnect. */
 	EventCategory["MeshNetworkChanged"] = "network.mesh.changed";
 	EventCategory["BackupCompleted"] = "backup.completed";
+	/**
+	* A whole backup RUN finished — every destination attempted, win or lose.
+	*
+	* `backup.completed` fires once per DESTINATION, which is the right grain for
+	* a progress UI and the wrong one for a notification: an operator with three
+	* destinations would be told three times. And a run where two of three
+	* destinations succeeded is not a clean success — a single "backup
+	* completed" that hid the failed one would be a lie, so the count of each is
+	* carried here and the message says both.
+	*
+	* Emitted by the backup orchestrator only after the destination loop, so a
+	* run that dies during the BUILD phase produces no completion at all.
+	*/
+	EventCategory["BackupRunCompleted"] = "backup.run-completed";
 	EventCategory["BackupRestored"] = "backup.restored";
 	EventCategory["NotificationDispatched"] = "notification.dispatched";
 	EventCategory["NotificationFailed"] = "notification.failed";
@@ -5372,7 +5386,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DBKu2-U5.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).
@@ -12060,6 +12074,72 @@ method(ListInputSchema, array(BrokerInfoSchema$1)), method(GetInputSchema, Broke
 	auth: "admin"
 }), method(GetStateInputSchema, unknown().nullable()), method(_void(), RegistryStatusSchema);
 DeviceType.Camera;
+/**
+* The signals a device can emit to WAKE its own stream.
+*
+* A camera whose stream is built on demand sleeps until something asks for it,
+* and "something" cannot be a consumer that is merely attached — a Frigate-style
+* puller holds a session open for ever, and treating that as demand would keep
+* a battery camera awake for ever, which is the whole thing the battery is for
+* (D173). So the wake has to come from the CAMERA: an event it noticed by
+* itself, with no stream running.
+*
+* ## The vocabulary is the PROVIDER'S, not ours
+*
+* Like `consumables`, this cap declares no vocabulary of its own. A provider
+* names each signal with a `code` it chooses and a `label` an operator reads.
+* Reolink offers motion and camera-native detection; another provider may offer
+* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
+* yet. A fixed enum here would mean every new signal is a framework release.
+*
+* It is deliberately NOT derived from the caps a device already binds. Whether
+* a camera CAN push firmware motion is expressed by `motionSources` containing
+* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
+* binding — but both answer "what drives the detection pipeline", which is a
+* different question from "what may wake a sleeping stream". A camera can do
+* the first and not be trusted with the second, and the operator picks per
+* camera. Two questions, two authorities.
+*
+* ## Availability is not permission
+*
+* `listSignals` says what the device CAN emit. Whether a given signal actually
+* wakes the stream is the operator's per-camera choice, held by the broker
+* alongside the cooldown — see the stream-broker cap's wake settings. A
+* provider declaring a signal is not a provider enabling it.
+*/
+/** One signal a device can emit. */
+var StreamSignalSchema = object({
+	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+	code: string().min(1),
+	/** What an operator reads in the picker. The provider's own wording. */
+	label: string().min(1),
+	/**
+	* Whether the provider recommends this signal ON when a camera is first set
+	* up. A provider knows which of its signals are cheap and reliable; an
+	* operator should not have to discover that by trial. Reolink recommends
+	* both of its own.
+	*/
+	recommended: boolean()
+});
+var StreamSignalsStatusSchema = object({
+	signals: array(StreamSignalSchema),
+	lastFetchedAt: number()
+});
+var streamSignalsCapability = {
+	name: "stream-signals",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: Object.values(DeviceType),
+	runtimeState: StreamSignalsStatusSchema,
+	methods: { 
+	/**
+	* What this device can emit. Empty is a valid and common answer — most
+	* cameras have nothing to offer here, and an empty list is what makes the
+	* broker's picker show nothing rather than a false choice.
+	*/
+listSignals: method(_void(), array(StreamSignalSchema).readonly()) }
+};
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = _enum([
 	"webrtc",
@@ -12456,6 +12536,22 @@ var EgressTranscodeSchema = object({
 	camStreamId: string().nullable()
 });
 method(object({
+	deviceId: number().int().nonnegative(),
+	/** The provider's signal code. */
+	code: string().min(1),
+	/** Ms epoch. Absent ⇒ now. */
+	at: number().optional()
+}), object({
+	/** Whether the broker acted on it, and if not, why. */
+	accepted: boolean(),
+	reason: _enum([
+		"woke",
+		"hold-extended",
+		"not-enabled",
+		"no-consumer",
+		"unknown-code"
+	])
+}), { kind: "mutation" }), method(object({
 	deviceId: number().int().nonnegative(),
 	camStreamId: string().min(1),
 	kind: CamStreamKindSchema,
@@ -12710,6 +12806,16 @@ var PickStreamRequirementsSchema = object({
 	acceptCodecs: array(StreamCodecSchema).readonly().optional(),
 	/** Minimum vertical resolution. Streams shorter than this are dropped. */
 	minHeight: number().int().positive().optional(),
+	/**
+	* Maximum vertical resolution. Streams TALLER than this are dropped.
+	*
+	* A consumer can have a ceiling as real as its floor: Alexa documents
+	* 480p to 1080p, and a 4K stream is as unusable to an Echo as a 360p one.
+	* Without this the ceiling had to be re-implemented by every caller — and
+	* one caller implementing it privately is how a second scoring authority
+	* gets born.
+	*/
+	maxHeight: number().int().positive().optional(),
 	/** Minimum horizontal resolution. */
 	minWidth: number().int().positive().optional(),
 	/**
@@ -12726,7 +12832,22 @@ var PickStreamRequirementsSchema = object({
 	* transcoded" guard: if the device is already serving the consumer's
 	* codec end-to-end, there's nothing to optimise.
 	*/
-	requireSiblingCodec: array(StreamCodecSchema).readonly().optional()
+	requireSiblingCodec: array(StreamCodecSchema).readonly().optional(),
+	/**
+	* Whether a stream the consumer CANNOT decode may still be picked, on the
+	* understanding that it will be transcoded.
+	*
+	* Default `false` — today's behaviour, and the right one for a bypass
+	* question ("is there a stream I can forward untouched?"). Set `true` to
+	* ask the larger question: "what is the best stream for me, transcoding if
+	* I must?" A stream that satisfies `acceptCodecs` always outranks one that
+	* does not, so a passthrough is never lost to a transcode; the answer says
+	* which it is in {@link PickedCamStreamSchema.transcodes}.
+	*
+	* This is what lets one picker serve both the bypass and the full source
+	* choice, instead of a consumer scoring privately when the bypass misses.
+	*/
+	allowTranscode: boolean().optional()
 }).readonly();
 var PickStreamPreferencesSchema = object({
 	/**
@@ -12740,12 +12861,32 @@ var PickStreamPreferencesSchema = object({
 	* picks the tallest stream; `'lowest'` picks the shortest (used by
 	* memory-constrained consumers / Apple Home guest sessions).
 	*/
-	resolutionPreference: _enum(["highest", "lowest"]).optional()
+	resolutionPreference: _enum(["highest", "lowest"]).optional(),
+	/**
+	* The height the consumer actually wants to DELIVER.
+	*
+	* Not a constraint — an ordering. With it set, the SMALLEST stream at or
+	* above the target wins, and only if nothing reaches it does the tallest
+	* take over. Pulling 1296 lines to draw 720 on a 1280x800 Echo panel costs
+	* a decode and buys nothing, and `resolutionPreference: 'highest'` cannot
+	* express that: it says "as big as possible", which is a different wish.
+	*
+	* Ignored when absent, so every existing caller keeps its ordering.
+	*/
+	targetHeight: number().int().positive().optional()
 }).readonly();
 var PickedCamStreamSchema = object({
 	camStreamId: string(),
 	codec: string().optional(),
 	resolution: CamStreamResolutionSchema.optional(),
+	/**
+	* Whether serving this stream requires a decode + re-encode.
+	*
+	* `false` is a stream the consumer can take as it stands. Only ever `true`
+	* when the caller asked for it with `allowTranscode`, so a caller that did
+	* not ask cannot be handed a cost it never agreed to pay.
+	*/
+	transcodes: boolean(),
 	/** One-line explanation of why this stream won — for logs / debug UI. */
 	reason: string()
 });
@@ -17336,6 +17477,8 @@ var NcSystemEventKindSchema = _enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -17354,6 +17497,7 @@ var NcSystemEventKindSchema = _enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -24739,10 +24883,28 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 }), boolean()), method(object({
 	deviceId: number().int().nonnegative(),
 	sessionId: string()
-}), object({ pendingRenegotiation: object({
-	target: WebrtcStreamTargetSchema,
-	epoch: number()
-}).nullable() }));
+}), object({
+	pendingRenegotiation: object({
+		target: WebrtcStreamTargetSchema,
+		epoch: number()
+	}).nullable(),
+	/**
+	* Whether the session still EXISTS.
+	*
+	* A consumer that holds a resource for the life of a session needs to
+	* be able to ask, because a session does not always end the way it
+	* began. Measured on this hub 2026-09-13: an Echo that got stuck never
+	* sent `SessionDisconnected`, so the Alexa exporter's
+	* `releaseEgressTranscode` never ran, and a 2304x1296 HEVC to 720p
+	* H.264 transcode kept running for NOBODY for more than twenty
+	* minutes. The WebRTC session had logged `WebRTC session closed`
+	* minutes earlier — the broker knew; the holder had no way to ask.
+	*
+	* `false` for a session id the provider has never heard of, which is
+	* the same answer as "it ended": either way nothing is holding it up.
+	*/
+	alive: boolean()
+}));
 object({
 	/** All accessory children of the parent. */
 	childDeviceIds: array(number()).readonly(),
@@ -29181,11 +29343,39 @@ 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.
+	*
+	* 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.
 	*/
 	enabled: boolean()
 });
+/**
+* What a camera's onboard detections actually CARRY.
+*
+* `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.
+*
+* 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`).
+*/
+var NativeObjectGeometryEnum = _enum(["boxed", "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() });
@@ -29195,13 +29385,28 @@ var nativeObjectDetectionCapability = {
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	methods: { setEnabled: method(object({
-		deviceId: number(),
-		enabled: boolean()
-	}), _void(), {
-		kind: "mutation",
-		auth: "admin"
-	}) },
+	deviceConfig: { ui: {
+		kind: "derived-form",
+		builderId: "native-object-detection",
+		tab: "motion"
+	} },
+	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
@@ -34981,6 +35186,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	smoke: smokeCapability,
 	streamCatalog: streamCatalogCapability,
 	streamParams: streamParamsCapability,
+	streamSignals: streamSignalsCapability,
 	switch: switchCapability,
 	tamper: tamperCapability,
 	temperatureSensor: temperatureSensorCapability,
@@ -39053,12 +39259,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",
@@ -41717,6 +41935,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.reportStreamSignal": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.restartProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -41801,6 +42025,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -43273,11 +43503,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",
@@ -44173,6 +44413,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -147452,10 +147697,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"
 };
@@ -148296,6 +148553,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;
@@ -148981,6 +149262,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. */
@@ -152126,6 +152414,63 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.ctx.logger.info("Reolink image-settings cap registered", { tags: { deviceId: this.id } });
 	}
 	/**
+	* Tell the broker one of our declared signals just fired.
+	*
+	* Never awaited by the push path: a camera event must not wait on a stream
+	* decision, and the broker's own answer (`woke` / `hold-extended` /
+	* `no-consumer` / `not-enabled`) is the interesting part only when something
+	* is actually watching. Logged at debug so a quiet camera does not fill the
+	* log with refusals nobody asked about — the broker logs the wakes it acts
+	* on, with `tags: { deviceId }`, and that is the operator-facing line.
+	*/
+	async reportWakeSignal(code) {
+		try {
+			const result = await this.ctx.api.streamBroker.reportStreamSignal.mutate({
+				deviceId: this.id,
+				code
+			});
+			if (result.accepted) this.ctx.logger.info("wake signal accepted by the broker", {
+				tags: { deviceId: this.id },
+				meta: {
+					code,
+					reason: result.reason
+				}
+			});
+		} catch (err) {
+			this.ctx.logger.debug("wake signal not delivered", {
+				tags: { deviceId: this.id },
+				meta: {
+					code,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		}
+	}
+	/**
+	* Declare the signals THIS camera can emit to wake its own stream.
+	*
+	* Two, and both recommended: a Reolink pushes firmware motion over Baichuan
+	* and camera-native AI detections, both without a stream running, which is
+	* exactly the property the wake needs — our own detections come from decoded
+	* frames and would depend on the stream they are meant to justify.
+	*
+	* Declaring is not enabling: the operator picks per camera, and the broker
+	* holds that choice alongside the cooldown. `recommended` only says which
+	* ones this provider is confident in.
+	*/
+	registerStreamSignalsCap() {
+		const signals = [{
+			code: "motion",
+			label: "Motion (camera)",
+			recommended: true
+		}, {
+			code: "detection",
+			label: "Object detected (camera)",
+			recommended: true
+		}];
+		this.ctx.registerNativeCap(streamSignalsCapability, { listSignals: async () => signals });
+	}
+	/**
 	* Register the `native-object-detection` cap.
 	*
 	* The runtimeState holds three fields:
@@ -152136,53 +152481,84 @@ 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 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`.
 	*
 	* 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,
+			enabled: !this.isBattery,
 			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 ? "flag-only" : "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);
+		this.registerStreamSignalsCap();
 		if (this.runtimeState.getCapState(CAP_NAME) === void 0) this.runtimeState.setCapState(CAP_NAME, {
 			...buildEmptyState(),
 			lastFetchedAt: Date.now()
@@ -155537,6 +155913,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				timestamp: now,
 				source: "onboard"
 			}));
+			this.reportWakeSignal("motion");
 			return;
 		}
 		const aiClass = AI_CLASS_MAP[event.type];
@@ -155547,14 +155924,17 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				timestamp: now,
 				confidence: void 0
 			} } });
-			if (isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) this.ctx.eventBus.emit(createEvent(EventCategory.DetectionCameraNative, eventSource, {
-				cameraId: this.id,
-				source: "onboard",
-				detections: [{
-					class: aiClass,
-					timestamp: now
-				}]
-			}));
+			if (isNativeObjectForwardingEnabled(this.runtimeState.getCapState("native-object-detection"))) {
+				this.reportWakeSignal("detection");
+				this.ctx.eventBus.emit(createEvent(EventCategory.DetectionCameraNative, eventSource, {
+					cameraId: this.id,
+					source: "onboard",
+					detections: [{
+						class: aiClass,
+						timestamp: now
+					}]
+				}));
+			} else this.noteNativeDetectionSuppressed(aiClass);
 			this.ctx.eventBus.emit(createEvent(EventCategory.MotionOnMotionChanged, eventSource, {
 				deviceId: this.id,
 				detected: true,