@camstack/addon-provider-reolink 1.2.38 → 1.2.40

package/dist/addon.js

@@ -19789,7 +19789,14 @@ targets: array(object({
 				"sleeping",
 				"unreachable",
 				"waking"
-			]).nullable()
+			]).nullable(),
+			/** A battery camera (whatever its current state). An AWAKE battery
+			*  camera is deliberately NOT recaptured on the poll cadence — every
+			*  capture is a camera hit that would keep it out of sleep — so its
+			*  cached frame legitimately ages past the currency ceiling while
+			*  nothing is streaming. A surface must keep painting it (a fresh
+			*  frame is captured at each wake), not blank to "unavailable". */
+			battery: boolean()
 		})))
 	},
 	status: {
@@ -230188,6 +230195,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	static WAKE_HYSTERESIS_MS = 3e4;
 	static SLEEP_HYSTERESIS_MS = 5e3;
 	/**
+	* How long a freshly committed state is protected from a hub-summary
+	* awake→sleeping flip. The summary's per-channel sleep flag lags real
+	* pushes by over a minute (measured >75 s on 2026-08-16); 3 min covers
+	* two full discovery-refresh cycles of lag without letting a genuinely
+	* stuck "awake" slice stand forever — the reconcile still wins after
+	* the grace, which is exactly its recovery role.
+	*/
+	static HUB_SUMMARY_SLEEP_GRACE_MS = 18e4;
+	/**
 	* Wall-clock ms of the last PROACTIVE wake — one we issued on our own
 	* initiative (background snapshot refresh), not because the operator
 	* or a stream consumer asked for the camera. Drives
@@ -231167,15 +231183,35 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*
 	* @param source - `'hub-summary'` is AUTHORITATIVE (the NVR reports
 	*   per-channel sleep state from its own firmware, not from socket
-	*   I/O inference) and therefore bypasses the hysteresis. The other
-	*   two sources are inference-derived and stay gated.
+	*   I/O inference) and therefore bypasses the hysteresis — with ONE
+	*   exception: the summary LAGS real push state (measured >75 s behind
+	*   an `awake` push, 2026-08-16), so an awake→sleeping flip from the
+	*   summary is refused while a fresher committed state is still inside
+	*   `HUB_SUMMARY_SLEEP_GRACE_MS`. Without the guard the 60 s reconcile
+	*   clobbered the fresh awake right back to sleeping for a full cycle —
+	*   the viewer flashed the live frame, then the sleeping overlay, then
+	*   live again. Sleeping→awake from the summary is always honoured
+	*   (it strands nothing; the camera wakes regardless).
 	* @returns `true` when the slice actually changed.
 	*/
 	commitSleepState(next, source) {
 		if (!this.isBattery) return false;
 		if (this.sleeping === next) return false;
 		if (source !== "hub-summary" && !this.acceptSleepingTransition(next)) return false;
-		if (source === "hub-summary") this.sleepStateChangedAt = Date.now();
+		if (source === "hub-summary") {
+			const sinceCommitMs = Date.now() - this.sleepStateChangedAt;
+			if (next === true && this.sleepStateChangedAt > 0 && sinceCommitMs < ReolinkCamera.HUB_SUMMARY_SLEEP_GRACE_MS) {
+				this.ctx.logger.debug("hub-summary sleep flip refused — fresher state inside grace", {
+					tags: { deviceId: this.id },
+					meta: {
+						sinceCommitMs,
+						graceMs: ReolinkCamera.HUB_SUMMARY_SLEEP_GRACE_MS
+					}
+				});
+				return false;
+			}
+			this.sleepStateChangedAt = Date.now();
+		}
 		this.state.battery.sleeping = next;
 		this.ctx.logger.info("battery sleep state committed", {
 			tags: { deviceId: this.id },
@@ -231315,13 +231351,42 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		});
 	}
 	/**
+	* Hub-fed battery refresh for an adopted child. The parent's
+	* `getAllChannelsBatteryInfo` CGI carries per-channel percent/charge
+	* state over the hub's own mains-powered socket, so it costs the
+	* battery channel nothing — this is how a hub child's
+	* percentage/charging ever moves (a sleeping child answers no poll of
+	* its own, and its pushes only arrive on firmware transitions).
+	*
+	* Deliberately does NOT stamp `lastContactAt`: the value is the HUB's
+	* cached read of the channel, not proof the camera itself answered —
+	* folding it into contact would mask a genuinely gone camera from the
+	* unreachable derivation (that is what pushes and streams are for).
+	* `sleeping` is likewise untouched — sleep state has its own writers
+	* (pushes + the guarded hub-summary reconcile).
+	*/
+	applyHubBatteryInfo(info) {
+		if (!this.isBattery) return;
+		const mapped = this.mapBatteryInfo({
+			...info.batteryPercent !== void 0 ? { batteryPercent: info.batteryPercent } : {},
+			...info.chargeStatus !== void 0 ? { chargeStatus: info.chargeStatus } : {},
+			...info.adapterStatus !== void 0 ? { adapterStatus: info.adapterStatus } : {}
+		});
+		this.setCapSlice(batteryCapability, {
+			...this.state.battery,
+			percentage: mapped.percentage,
+			charging: mapped.charging,
+			lastUpdated: Date.now()
+		});
+	}
+	/**
 	* Battery cams require an explicit wake before cmd_id 109 will
 	* answer reliably. The lib documents this pattern in
-	* `predownloadRecordingMp4` (`ensureAwake` → `wakeUp` →
-	* operation → retry with longer wait on failure). `getSnapshot`
-	* itself only re-`login()`s, which over BCUDP can complete before
-	* the camera firmware is fully up — the snapshot then times out
-	* because the video subsystem isn't ready yet.
+	* `predownloadRecordingMp3`/`predownloadRecordingMp4` (`ensureAwake`
+	* → `wakeUp` → operation → retry with longer wait on failure).
+	* `getSnapshot` itself only re-`login()`s, which over BCUDP can
+	* complete before the camera firmware is fully up — the snapshot then
+	* times out because the video subsystem isn't ready yet.
 	*
 	* Probe live testing (scripts/probe-reolink-snapshot.mts) confirmed:
 	*   awake state: getSnapshot in ~1s
@@ -236775,6 +236840,12 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 	* keeps the slice + map in sync after every change).
 	*/
 	channelToDeviceId = /* @__PURE__ */ new Map();
+	/** One-shot: the raw per-channel battery payload is logged once per
+	*  process so the firmware's charge-field naming is on record. */
+	batteryShapeLogged = false;
+	/** Channels the last successful discovery refresh listed as present but
+	*  NOT adopted — their pushes are expected drops (debug), not faults. */
+	knownUnadoptedChannels = /* @__PURE__ */ new Set();
 	/** Wall-clock ms of the last discovery refresh that included this
 	*  child's channel. Drives the offline marker — a child that hasn't
 	*  appeared in the firmware's channel list for `MISSING_OFFLINE_MS`
@@ -237188,6 +237259,11 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 		};
 		this.runtimeState.setCapState(deviceDiscoveryCapability.name, slice);
 		if (lastError === null) {
+			this.knownUnadoptedChannels.clear();
+			for (const d of discovered) {
+				const ch = d.metadata.rtspChannel;
+				if (!d.alreadyAdopted && typeof ch === "number") this.knownUnadoptedChannels.add(ch);
+			}
 			const adoptedCount = discovered.filter((d) => d.alreadyAdopted).length;
 			const availableCount = discovered.length - adoptedCount;
 			const onlineCount = discovered.filter((d) => d.status === "online").length;
@@ -237211,6 +237287,49 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 		if (lastError === null) {
 			await this.reconcileAdoptedChildOnline(discovered);
 			await this.reconcileAdoptedChildSleepState(discovered);
+			await this.reconcileAdoptedChildBattery();
+		}
+	}
+	/**
+	* Push the hub's per-channel battery read into each adopted battery
+	* child. `getAllChannelsBatteryInfo` is one CGI on the hub's own
+	* mains-powered socket — it never touches a battery camera — and it is
+	* the ONLY way a sleeping hub child's percentage/charging ever moves:
+	* the child answers no poll of its own while asleep, and its battery
+	* pushes arrive only on firmware transitions (measured live: 3628 sat
+	* at 80% / charging:none for 3 h while plugged in, 2026-08-16).
+	*
+	* Independent of the discovery call's success path: a battery-read
+	* failure must not fail discovery, so it is caught and logged here.
+	*/
+	async reconcileAdoptedChildBattery() {
+		if (this.channelToDeviceId.size === 0) return;
+		try {
+			const data = await (await this.ensureApi()).getAllChannelsBatteryInfo();
+			const entries = Object.entries(data.batteryInfoData);
+			if (entries.length === 0) return;
+			if (!this.batteryShapeLogged) {
+				this.batteryShapeLogged = true;
+				this.ctx.logger.info("Reolink Hub: per-channel battery payload (first read)", { meta: { raw: entries.map(([ch, v]) => ({
+					channel: Number(ch),
+					...v
+				})) } });
+			}
+			const all = await this.ctx.devices.getAll();
+			for (const [chKey, info] of entries) {
+				const deviceId = this.channelToDeviceId.get(Number(chKey));
+				if (deviceId === void 0) continue;
+				const child = all.find((d) => d.id === deviceId);
+				if (!(child instanceof ReolinkCamera)) continue;
+				const cgi = info.entries[0];
+				child.applyHubBatteryInfo({
+					batteryPercent: info.batteryLevel,
+					...typeof cgi?.["chargeStatus"] === "string" ? { chargeStatus: cgi["chargeStatus"] } : {},
+					...typeof cgi?.["adapterStatus"] === "string" ? { adapterStatus: cgi["adapterStatus"] } : {}
+				});
+			}
+		} catch (err) {
+			this.ctx.logger.debug("Reolink Hub: per-channel battery refresh failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		}
 	}
 	/**
@@ -237420,9 +237539,11 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			const now = Date.now();
 			if (now - last > 6e4) {
 				this.unroutedChannelLoggedAt.set(channel, now);
-				this.ctx.logger.warn("Reolink Hub: simpleEvent for an unmapped channel dropped", { meta: {
+				const knownUnadopted = this.knownUnadoptedChannels.has(channel);
+				this.ctx.logger[knownUnadopted ? "debug" : "warn"]("Reolink Hub: simpleEvent for an unmapped channel dropped", { meta: {
 					channel,
-					type: ev?.type ?? "unknown"
+					type: ev?.type ?? "unknown",
+					knownUnadopted
 				} });
 			}
 			return;

package/dist/addon.mjs

@@ -19784,7 +19784,14 @@ targets: array(object({
 				"sleeping",
 				"unreachable",
 				"waking"
-			]).nullable()
+			]).nullable(),
+			/** A battery camera (whatever its current state). An AWAKE battery
+			*  camera is deliberately NOT recaptured on the poll cadence — every
+			*  capture is a camera hit that would keep it out of sleep — so its
+			*  cached frame legitimately ages past the currency ceiling while
+			*  nothing is streaming. A surface must keep painting it (a fresh
+			*  frame is captured at each wake), not blank to "unavailable". */
+			battery: boolean()
 		})))
 	},
 	status: {
@@ -230168,6 +230175,15 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	static WAKE_HYSTERESIS_MS = 3e4;
 	static SLEEP_HYSTERESIS_MS = 5e3;
 	/**
+	* How long a freshly committed state is protected from a hub-summary
+	* awake→sleeping flip. The summary's per-channel sleep flag lags real
+	* pushes by over a minute (measured >75 s on 2026-08-16); 3 min covers
+	* two full discovery-refresh cycles of lag without letting a genuinely
+	* stuck "awake" slice stand forever — the reconcile still wins after
+	* the grace, which is exactly its recovery role.
+	*/
+	static HUB_SUMMARY_SLEEP_GRACE_MS = 18e4;
+	/**
 	* Wall-clock ms of the last PROACTIVE wake — one we issued on our own
 	* initiative (background snapshot refresh), not because the operator
 	* or a stream consumer asked for the camera. Drives
@@ -231147,15 +231163,35 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*
 	* @param source - `'hub-summary'` is AUTHORITATIVE (the NVR reports
 	*   per-channel sleep state from its own firmware, not from socket
-	*   I/O inference) and therefore bypasses the hysteresis. The other
-	*   two sources are inference-derived and stay gated.
+	*   I/O inference) and therefore bypasses the hysteresis — with ONE
+	*   exception: the summary LAGS real push state (measured >75 s behind
+	*   an `awake` push, 2026-08-16), so an awake→sleeping flip from the
+	*   summary is refused while a fresher committed state is still inside
+	*   `HUB_SUMMARY_SLEEP_GRACE_MS`. Without the guard the 60 s reconcile
+	*   clobbered the fresh awake right back to sleeping for a full cycle —
+	*   the viewer flashed the live frame, then the sleeping overlay, then
+	*   live again. Sleeping→awake from the summary is always honoured
+	*   (it strands nothing; the camera wakes regardless).
 	* @returns `true` when the slice actually changed.
 	*/
 	commitSleepState(next, source) {
 		if (!this.isBattery) return false;
 		if (this.sleeping === next) return false;
 		if (source !== "hub-summary" && !this.acceptSleepingTransition(next)) return false;
-		if (source === "hub-summary") this.sleepStateChangedAt = Date.now();
+		if (source === "hub-summary") {
+			const sinceCommitMs = Date.now() - this.sleepStateChangedAt;
+			if (next === true && this.sleepStateChangedAt > 0 && sinceCommitMs < ReolinkCamera.HUB_SUMMARY_SLEEP_GRACE_MS) {
+				this.ctx.logger.debug("hub-summary sleep flip refused — fresher state inside grace", {
+					tags: { deviceId: this.id },
+					meta: {
+						sinceCommitMs,
+						graceMs: ReolinkCamera.HUB_SUMMARY_SLEEP_GRACE_MS
+					}
+				});
+				return false;
+			}
+			this.sleepStateChangedAt = Date.now();
+		}
 		this.state.battery.sleeping = next;
 		this.ctx.logger.info("battery sleep state committed", {
 			tags: { deviceId: this.id },
@@ -231295,13 +231331,42 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		});
 	}
 	/**
+	* Hub-fed battery refresh for an adopted child. The parent's
+	* `getAllChannelsBatteryInfo` CGI carries per-channel percent/charge
+	* state over the hub's own mains-powered socket, so it costs the
+	* battery channel nothing — this is how a hub child's
+	* percentage/charging ever moves (a sleeping child answers no poll of
+	* its own, and its pushes only arrive on firmware transitions).
+	*
+	* Deliberately does NOT stamp `lastContactAt`: the value is the HUB's
+	* cached read of the channel, not proof the camera itself answered —
+	* folding it into contact would mask a genuinely gone camera from the
+	* unreachable derivation (that is what pushes and streams are for).
+	* `sleeping` is likewise untouched — sleep state has its own writers
+	* (pushes + the guarded hub-summary reconcile).
+	*/
+	applyHubBatteryInfo(info) {
+		if (!this.isBattery) return;
+		const mapped = this.mapBatteryInfo({
+			...info.batteryPercent !== void 0 ? { batteryPercent: info.batteryPercent } : {},
+			...info.chargeStatus !== void 0 ? { chargeStatus: info.chargeStatus } : {},
+			...info.adapterStatus !== void 0 ? { adapterStatus: info.adapterStatus } : {}
+		});
+		this.setCapSlice(batteryCapability, {
+			...this.state.battery,
+			percentage: mapped.percentage,
+			charging: mapped.charging,
+			lastUpdated: Date.now()
+		});
+	}
+	/**
 	* Battery cams require an explicit wake before cmd_id 109 will
 	* answer reliably. The lib documents this pattern in
-	* `predownloadRecordingMp4` (`ensureAwake` → `wakeUp` →
-	* operation → retry with longer wait on failure). `getSnapshot`
-	* itself only re-`login()`s, which over BCUDP can complete before
-	* the camera firmware is fully up — the snapshot then times out
-	* because the video subsystem isn't ready yet.
+	* `predownloadRecordingMp3`/`predownloadRecordingMp4` (`ensureAwake`
+	* → `wakeUp` → operation → retry with longer wait on failure).
+	* `getSnapshot` itself only re-`login()`s, which over BCUDP can
+	* complete before the camera firmware is fully up — the snapshot then
+	* times out because the video subsystem isn't ready yet.
 	*
 	* Probe live testing (scripts/probe-reolink-snapshot.mts) confirmed:
 	*   awake state: getSnapshot in ~1s
@@ -236755,6 +236820,12 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 	* keeps the slice + map in sync after every change).
 	*/
 	channelToDeviceId = /* @__PURE__ */ new Map();
+	/** One-shot: the raw per-channel battery payload is logged once per
+	*  process so the firmware's charge-field naming is on record. */
+	batteryShapeLogged = false;
+	/** Channels the last successful discovery refresh listed as present but
+	*  NOT adopted — their pushes are expected drops (debug), not faults. */
+	knownUnadoptedChannels = /* @__PURE__ */ new Set();
 	/** Wall-clock ms of the last discovery refresh that included this
 	*  child's channel. Drives the offline marker — a child that hasn't
 	*  appeared in the firmware's channel list for `MISSING_OFFLINE_MS`
@@ -237168,6 +237239,11 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 		};
 		this.runtimeState.setCapState(deviceDiscoveryCapability.name, slice);
 		if (lastError === null) {
+			this.knownUnadoptedChannels.clear();
+			for (const d of discovered) {
+				const ch = d.metadata.rtspChannel;
+				if (!d.alreadyAdopted && typeof ch === "number") this.knownUnadoptedChannels.add(ch);
+			}
 			const adoptedCount = discovered.filter((d) => d.alreadyAdopted).length;
 			const availableCount = discovered.length - adoptedCount;
 			const onlineCount = discovered.filter((d) => d.status === "online").length;
@@ -237191,6 +237267,49 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 		if (lastError === null) {
 			await this.reconcileAdoptedChildOnline(discovered);
 			await this.reconcileAdoptedChildSleepState(discovered);
+			await this.reconcileAdoptedChildBattery();
+		}
+	}
+	/**
+	* Push the hub's per-channel battery read into each adopted battery
+	* child. `getAllChannelsBatteryInfo` is one CGI on the hub's own
+	* mains-powered socket — it never touches a battery camera — and it is
+	* the ONLY way a sleeping hub child's percentage/charging ever moves:
+	* the child answers no poll of its own while asleep, and its battery
+	* pushes arrive only on firmware transitions (measured live: 3628 sat
+	* at 80% / charging:none for 3 h while plugged in, 2026-08-16).
+	*
+	* Independent of the discovery call's success path: a battery-read
+	* failure must not fail discovery, so it is caught and logged here.
+	*/
+	async reconcileAdoptedChildBattery() {
+		if (this.channelToDeviceId.size === 0) return;
+		try {
+			const data = await (await this.ensureApi()).getAllChannelsBatteryInfo();
+			const entries = Object.entries(data.batteryInfoData);
+			if (entries.length === 0) return;
+			if (!this.batteryShapeLogged) {
+				this.batteryShapeLogged = true;
+				this.ctx.logger.info("Reolink Hub: per-channel battery payload (first read)", { meta: { raw: entries.map(([ch, v]) => ({
+					channel: Number(ch),
+					...v
+				})) } });
+			}
+			const all = await this.ctx.devices.getAll();
+			for (const [chKey, info] of entries) {
+				const deviceId = this.channelToDeviceId.get(Number(chKey));
+				if (deviceId === void 0) continue;
+				const child = all.find((d) => d.id === deviceId);
+				if (!(child instanceof ReolinkCamera)) continue;
+				const cgi = info.entries[0];
+				child.applyHubBatteryInfo({
+					batteryPercent: info.batteryLevel,
+					...typeof cgi?.["chargeStatus"] === "string" ? { chargeStatus: cgi["chargeStatus"] } : {},
+					...typeof cgi?.["adapterStatus"] === "string" ? { adapterStatus: cgi["adapterStatus"] } : {}
+				});
+			}
+		} catch (err) {
+			this.ctx.logger.debug("Reolink Hub: per-channel battery refresh failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		}
 	}
 	/**
@@ -237400,9 +237519,11 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			const now = Date.now();
 			if (now - last > 6e4) {
 				this.unroutedChannelLoggedAt.set(channel, now);
-				this.ctx.logger.warn("Reolink Hub: simpleEvent for an unmapped channel dropped", { meta: {
+				const knownUnadopted = this.knownUnadoptedChannels.has(channel);
+				this.ctx.logger[knownUnadopted ? "debug" : "warn"]("Reolink Hub: simpleEvent for an unmapped channel dropped", { meta: {
 					channel,
-					type: ev?.type ?? "unknown"
+					type: ev?.type ?? "unknown",
+					knownUnadopted
 				} });
 			}
 			return;

package/package.json

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