@camstack/addon-provider-reolink 1.2.86 → 1.2.88

package/dist/DiagnosticsTools-QJ3CRYGA-9NV95vRN.mjs

@@ -0,0 +1,2 @@
+import { d as testChannelStreams, i as collectMultifocalDiagnostics } from "./addon.mjs";
+export { collectMultifocalDiagnostics, testChannelStreams };

package/dist/addon.js

@@ -13532,6 +13532,24 @@ var deviceProviderCapability = {
 		})
 	}
 };
+/**
+* Device Manager capability — hub-side singleton that unifies device persistence,
+* live registry access, and all management operations into a single tRPC surface.
+*
+* Replaces:
+*   - `device-persistence` capability (persistence methods absorbed here)
+*   - `device-management.router.ts` (deleted in Phase 2)
+*   - `device-ops.router.ts` (compat layer — deleted; device-provider ops absorbed here)
+*
+* All device provider addons (rtsp, onvif, frigate, …) are hub-local: they may
+* fork into separate processes but never run on remote cluster agents. Therefore:
+*   - No nodeId routing needed — this is a pure hub singleton.
+*   - The hub's DeviceRegistry is the single source of truth for all live devices.
+*   - No shadow registry or cross-node aggregation required.
+*
+* Forked workers register devices back to the hub via `ctx.devices`
+* (DeviceManagerApi → ctx.api.deviceManager.registerDevice), same as today.
+*/
 /** One child-placement directive on a container's `childLayout`. Structurally
 *  identical to `ChildLayoutEntry` in `device-management.ts` — the cap wire
 *  shape for the same field. The child is identified by its re-sync-stable
@@ -13630,7 +13648,12 @@ var ConfigEntrySchema = object({
 	value: unknown(),
 	description: string().optional()
 });
-var LinkedDevicesModeSchema = _enum(["auto", "manual"]);
+/**
+* Only `manual` since D356: the operator picks, nothing links itself. The
+* field survives on the wire because a viewer already OTA'd parses it —
+* drop it once no shipped client reads `mode`.
+*/
+var LinkedDevicesModeSchema = _enum(["manual"]);
 /** One resolved linked device — the compact projection consumers need. */
 var LinkedDeviceSchema = object({
 	deviceId: number(),
@@ -19298,6 +19321,9 @@ var RetrainStatusSchema = _enum([
 *
 * `debug` does NOT pin; it is attention, not durability.
 *
+* `debugNote` is the operator's own words about WHAT should be checked on this
+* track, and it lives and dies with `debug` — see {@link MAX_TRACK_DEBUG_NOTE_LEN}.
+*
 * `favourited` IS a BOOLEAN pin (durability bit), not a retrain lifecycle.
 * A favourited track is skipped by retention the same way `staging` is, but
 * it does not enter `none|staging|trained` and has no staging budget.
@@ -19308,6 +19334,21 @@ var TrackFlagFields = {
 	markForTrain: boolean().optional(),
 	/** Operator marked this track for diagnostic attention. */
 	debug: boolean().optional(),
+	/**
+	* What the operator wants CHECKED on this track, in their own words.
+	*
+	* The flag alone says "look at this" and nothing about what for; a debug set
+	* reviewed hours later is a list of tracks with no question attached. Bound
+	* to `debug` on the WRITE side — the body clears it when `debug` goes off,
+	* and refuses it on a track whose debug is off — so a note can never outlive
+	* the attention it belongs to.
+	*
+	* `''` is a real value ("marked, nothing to add"); the ABSENT key means
+	* "leave whatever is stored alone", which is what lets a surface turn debug
+	* on without a note (a cancelled prompt) and what lets it edit the note
+	* without touching the flag.
+	*/
+	debugNote: string().max(500).optional(),
 	/** Operator favourited this track. Pins it against pruning. */
 	favourited: boolean().optional()
 };
@@ -19334,6 +19375,12 @@ var TrackFlagsSchema = object({
 	trackId: string(),
 	markForTrain: boolean(),
 	debug: boolean(),
+	/** The note as it STANDS after the write — never absent here (a track with no
+	*  note reports `''`), for the same reason the booleans are required: a
+	*  surface that has just written must be able to render the note it now owns
+	*  without a re-fetch, and an absent key would read as "unchanged" on a
+	*  screen that has no previous value to keep. */
+	debugNote: string(),
 	favourited: boolean(),
 	/** The lifecycle state the boolean was derived from. Required here (unlike on
 	*  a track row) because this shape is only ever produced by the write body,
@@ -34180,6 +34227,17 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
+/**
+* Default silence budget before a sleeping battery camera is called gone.
+*
+* Sized off the mechanism that produces contact, not off taste: a battery cam
+* on this deployment surfaces a firmware push (battery level, sleep/wake, or a
+* motion email) on the order of hours even with no visitors, and the snapshot
+* wrapper's own battery window is 1 hour. Six hours is therefore several
+* missed opportunities, not one — so a single quiet night does not raise a
+* fault, and a genuinely flat camera is named well inside a day.
+*/
+var BATTERY_UNREACHABLE_AFTER_MS = 360 * 6e4;
 DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
 new Set(Object.values(DeviceType));
 DeviceFeature.BatteryOperated;
@@ -231298,7 +231356,8 @@ var RawReadSliceSchema = _enum([
 	"osd",
 	"led",
 	"pir",
-	"autoReboot"
+	"autoReboot",
+	"battery"
 ]);
 /**
 * The allow-list. `Record<RawReadSlice, …>` keeps the catalog and the enum
@@ -231309,17 +231368,26 @@ var RawReadSliceSchema = _enum([
 var RAW_READ_CATALOG = {
 	image: {
 		command: "getVideoInput",
-		snapshotKey: "imageSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "imageSnapshot"
+		},
 		invoke: (api, channel) => api.getVideoInput(channel)
 	},
 	motion: {
 		command: "getMotionAlarm",
-		snapshotKey: "motionSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "motionSnapshot"
+		},
 		invoke: (api, channel) => api.getMotionAlarm(channel)
 	},
 	ai: {
 		command: "getAiDetectTypes + getAiDetectionFull (per type)",
-		snapshotKey: "aiSensitivitySnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "aiSensitivitySnapshot"
+		},
 		invoke: async (api, channel) => {
 			const detectTypes = await api.getAiDetectTypes(channel, { timeoutMs: 1500 });
 			const perType = {};
@@ -231336,71 +231404,204 @@ var RAW_READ_CATALOG = {
 	},
 	enc: {
 		command: "getEnc",
-		snapshotKey: "encSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "encSnapshot"
+		},
 		invoke: (api, channel) => api.getEnc(channel)
 	},
 	encOptions: {
 		command: "getEncOptions",
-		snapshotKey: "encOptionsSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "encOptionsSnapshot"
+		},
 		invoke: (api, channel) => api.getEncOptions(channel)
 	},
 	mask: {
 		command: "getMask",
-		snapshotKey: "maskSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "maskSnapshot"
+		},
 		invoke: (api, channel) => api.getMask(channel)
 	},
 	audioNoise: {
 		command: "getAudioNoise",
-		snapshotKey: "audioNoiseSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "audioNoiseSnapshot"
+		},
 		invoke: (api, channel) => api.getAudioNoise(channel)
 	},
 	autofocus: {
 		command: "getAutoFocus",
-		snapshotKey: "autoFocusSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "autoFocusSnapshot"
+		},
 		invoke: (api, channel) => api.getAutoFocus(channel, { timeoutMs: 1500 })
 	},
 	netPort: {
 		command: "getNetPort",
-		snapshotKey: "netPortSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "netPortSnapshot"
+		},
 		invoke: (api) => api.getNetPort()
 	},
 	ntp: {
 		command: "getNtp",
-		snapshotKey: "ntpSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "ntpSnapshot"
+		},
 		invoke: (api) => api.getNtp()
 	},
 	systemGeneral: {
 		command: "getSystemGeneral",
-		snapshotKey: "systemGeneralSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "systemGeneralSnapshot"
+		},
 		invoke: (api) => api.getSystemGeneral()
 	},
 	osd: {
 		command: "getOsd",
-		snapshotKey: "osdSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "osdSnapshot"
+		},
 		invoke: (api, channel) => api.getOsd(channel)
 	},
 	led: {
 		command: "getIrLights",
-		snapshotKey: "ledSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "ledSnapshot"
+		},
 		invoke: (api, channel) => api.getIrLights(channel)
 	},
 	pir: {
 		command: "getPirInfo",
-		snapshotKey: "pirSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "pirSnapshot"
+		},
 		invoke: (api, channel) => api.getPirInfo(channel)
 	},
 	autoReboot: {
 		command: "getAutoReboot",
-		snapshotKey: "autoRebootSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "autoRebootSnapshot"
+		},
 		invoke: (api) => api.getAutoReboot()
+	},
+	/**
+	* Battery — one slice, TWO firmware reads, chosen by how the camera is
+	* attached. They are not variants of one call:
+	*
+	*   - **standalone**: `getBatteryInfo(channel)` — the camera's own
+	*     answer, one `BatteryInfo`;
+	*   - **hub child**: `getAllChannelsBatteryInfo()` — a HUB-level CGI
+	*     keyed by channel, projected to the requested one here so the slice
+	*     stays per-camera like the other fifteen (a "cluster-wide" second
+	*     slice shape would have to be understood by every caller).
+	*
+	* Both vocabularies carry `adapterStatus` next to `chargeStatus`, which
+	* is why this slice exists: the provider keeps only the latter, and
+	* whether `adapterStatus` MOVES was previously observable exactly once
+	* per hub process (`ReolinkHub.batteryShapeLogged`). The answer is
+	* returned as the firmware gave it, under a `readVia` that names the path
+	* — NOT normalised into a shared shape. The paths do not carry the same
+	* fields (`voltage`/`lowPower` on the camera read, `channelsReported` and
+	* the channel-status row on the hub read); a field the firmware did not
+	* send must be ABSENT, because a default here would be indistinguishable
+	* from a reading (D315).
+	*
+	* A camera that cannot answer at all throws, and the read comes back
+	* `read-failed` carrying the firmware's reason — "we could not read it"
+	* must never be served as "it has no battery".
+	*/
+	battery: {
+		command: "getBatteryInfo (standalone) / getAllChannelsBatteryInfo projected (hub child)",
+		believed: {
+			kind: "capRuntimeState",
+			capName: "battery"
+		},
+		servedByParentHub: true,
+		invoke: async (api, channel, ctx) => {
+			if (!ctx.hubChild) return {
+				readVia: "camera",
+				command: "getBatteryInfo",
+				channel,
+				batteryInfo: await api.getBatteryInfo(channel)
+			};
+			const byChannel = (await api.getAllChannelsBatteryInfo()).batteryInfoData;
+			const channelsReported = Object.keys(byChannel).map(Number).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+			const info = byChannel[channel];
+			if (info === void 0) throw new Error(`getAllChannelsBatteryInfo answered for channels [${channelsReported.join(", ")}] but not channel ${channel} — this camera's battery was NOT reported. That is an unanswered read, not "no battery".`);
+			const [cgiBattery, channelStatus] = info.entries;
+			return {
+				readVia: "parentHub",
+				command: "getAllChannelsBatteryInfo",
+				channel,
+				channelsReported,
+				batteryInfo: {
+					...info,
+					entries: [cgiBattery ?? null, redactChannelIdentity(channelStatus)]
+				}
+			};
+		}
 	}
 };
+/**
+* The hub's channel-status row (`entries[1]`) carries the camera's Reolink
+* P2P `uid` — a routable cloud identifier for the device. A charge-state
+* read has no reason to hand it out, so it is dropped here rather than
+* relied on not to be looked at. The drop is STATED (`uidRedacted`): a
+* removed field and a firmware that never sent one must not look alike.
+* Everything else in the row (channel, name, online, sleep, typeInfo) is
+* kept verbatim — it is the context that makes the battery row readable.
+*/
+function redactChannelIdentity(entry) {
+	if (entry === void 0) return null;
+	const { uid, ...rest } = entry;
+	return {
+		...rest,
+		uidRedacted: uid !== void 0
+	};
+}
+/**
+* Age of a `capRuntimeState` belief. The cap slice carries `lastUpdated`
+* rather than a freshness-map stamp, and its `empty` seed is `0` — which is
+* NOT an observation, so it resolves to `never`. A slice that was never
+* written at all is `never` too: on a battery reading, "we hold no value"
+* and "we measured 0%" are an alarm apart (see `BatteryStatusSchema`).
+*/
+function capStateAge(state, now) {
+	if (state === void 0) return { state: "never" };
+	const lastUpdated = state.lastUpdated;
+	if (typeof lastUpdated !== "number" || lastUpdated <= 0) return { state: "never" };
+	return {
+		state: "known",
+		fetchedAt: lastUpdated,
+		ageMs: Math.max(0, now - lastUpdated)
+	};
+}
 /** What CamStack currently believes about the slice, with its own age. */
 var BelievedStateSchema = object({
-	/** The persisted projection (`deviceCache.<snapshotKey>`), verbatim. */
+	/** The persisted projection / cap slice, verbatim. */
 	snapshot: unknown(),
-	/** deviceCache field the projection lives in. */
-	snapshotKey: string(),
+	/** Where that belief lives — mirrors {@link BelievedSource}. */
+	source: discriminatedUnion("kind", [object({
+		kind: literal("deviceCache"),
+		snapshotKey: string()
+	}), object({
+		kind: literal("capRuntimeState"),
+		capName: literal("battery")
+	})]),
 	/** Tri-state freshness — `never` / `unknown` (legacy, no stamp) / `known`. */
 	age: union([
 		object({ state: literal("never") }),
@@ -231439,11 +231640,17 @@ var RawReadInputSchema = object({
 	deviceId: number().int().nonnegative(),
 	slice: RawReadSliceSchema
 });
-function believedState(cache, entry, now) {
-	const age = resolveSnapshotAge(cache, entry.snapshotKey, now);
+function believedState(deps, entry) {
+	const source = entry.believed;
+	if (source.kind === "capRuntimeState") return {
+		snapshot: toPlainJson(deps.batteryState),
+		source,
+		age: capStateAge(deps.batteryState, deps.now)
+	};
+	const age = resolveSnapshotAge(deps.cache, source.snapshotKey, deps.now);
 	return {
-		snapshot: toPlainJson(cache === void 0 ? void 0 : Reflect.get(cache, entry.snapshotKey)),
-		snapshotKey: entry.snapshotKey,
+		snapshot: toPlainJson(deps.cache === void 0 ? void 0 : Reflect.get(deps.cache, source.snapshotKey)),
+		source,
 		age
 	};
 }
@@ -231463,8 +231670,9 @@ function toPlainJson(value) {
 */
 async function performRawRead(slice, deps) {
 	const entry = RAW_READ_CATALOG[slice];
-	const believed = believedState(deps.cache, entry, deps.now);
-	if (deps.sleeping) {
+	const believed = believedState(deps, entry);
+	const servedWithoutTouchingCamera = deps.hubChild && entry.servedByParentHub === true;
+	if (deps.sleeping && !servedWithoutTouchingCamera) {
 		deps.logger.info("reolink raw read refused — battery cam is sleeping", {
 			tags: { deviceId: deps.deviceId },
 			meta: { slice }
@@ -231474,7 +231682,7 @@ async function performRawRead(slice, deps) {
 			deviceId: deps.deviceId,
 			slice,
 			reason: "sleeping",
-			message: "Battery camera is asleep — a raw read would wake it, so it is refused. The believed state below is what CamStack currently serves.",
+			message: deps.hubChild ? `Battery camera is asleep and the "${slice}" read is addressed to the camera channel, which would wake it — refused. The believed state below is what CamStack currently serves. (The "battery" slice is answered by the parent hub and stays readable while the camera sleeps.)` : "Battery camera is asleep — a raw read would wake it, so it is refused. The believed state below is what CamStack currently serves.",
 			believed
 		};
 	}
@@ -231500,12 +231708,14 @@ async function performRawRead(slice, deps) {
 		};
 	}
 	try {
-		const payload = await entry.invoke(api, deps.channel);
+		const payload = await entry.invoke(api, deps.channel, { hubChild: deps.hubChild });
 		deps.logger.info("reolink raw read served", {
 			tags: { deviceId: deps.deviceId },
 			meta: {
 				slice,
-				command: entry.command
+				command: entry.command,
+				viaParentHub: servedWithoutTouchingCamera,
+				cameraWasSleeping: deps.sleeping
 			}
 		});
 		return {
@@ -231564,6 +231774,67 @@ var reolinkDebugActions = defineCustomActions({ debugRawRead: customAction(RawRe
 	auth: "admin"
 }) });
 //#endregion
+//#region src/battery-charging.ts
+/**
+* Da `adapterStatus` + `chargeStatus` alla sorgente di alimentazione.
+*
+* I due campi rispondono a DUE domande diverse, e confonderle è il bug che
+* questo modulo esiste per chiudere:
+*
+*  - `adapterStatus` — l'alimentazione è COLLEGATA? Il firmware manda 0/1/2
+*    (nessuna · adattatore DC · pannello solare) e il confine dell'hub lo
+*    traduce in `'none' | 'dc' | 'solarPanel'` (`mapHubChargeStatus` e
+*    `mapHubAdapterStatus` in `reolink-hub.ts`), perché il vocabolario del
+*    percorso standalone è già a stringhe.
+*  - `chargeStatus` — la CELLA cosa sta facendo? 0 ferma · 1 in carica ·
+*    2 carica completa.
+*
+* La vecchia derivazione consultava l'adattatore SOLO per cercarci 'solar', e
+* un DC collegato cadeva nel ripiego `'none'`. Due Argus 3E lo nascondevano per
+* caso: piene e collegate rispondono `chargeStatus: 2`, che il ramo `isCharging`
+* mappava su `'dc'` per la ragione sbagliata. La Argus MagiCam (batteryVersion
+* 1, firmware 2026) collegata in permanenza risponde `chargeStatus: 0`, e per
+* tutta la sua vita è stata riportata NON in carica.
+*
+* Che `adapterStatus` sia un segnale vero e non una costante è MISURATO: il
+* 2026-09-05 l'operatore ha staccato il device 3628 e il payload grezzo è
+* passato da `adapterStatus: 1` a `0`, con `chargeStatus: 0` da entrambe le
+* parti — cioè `chargeStatus` da solo NON distingue i due stati.
+*
+* ⚠️ Questa funzione non sa ancora dire "non lo so": `BatteryStatus['charging']`
+* non ha un valore `unknown`, quindi due campi illeggibili producono `'none'`,
+* che è un valore NEGATIVO al posto di un non-noto. È il difetto D315 che
+* `percentage` ha già chiuso (è `nullable`) e questo campo no; chiuderlo tocca
+* `battery.cap.ts`, cioè la closure del server, e vive nel proprio lavoro.
+*/
+function deriveChargingSource(adapterStatus, chargeStatus) {
+	const adapter = (adapterStatus ?? "").toLowerCase();
+	const charge = (chargeStatus ?? "").toLowerCase();
+	if (adapter.includes("solar")) return "solar";
+	if (adapter === "dc") return "dc";
+	if (charge === "charging" || charge === "chargecomplete") return "dc";
+	return "none";
+}
+/**
+* Did this reading SAY anything about the power source? A battery push may
+* carry only the level (every `BatteryInfo` field is optional and nodelink
+* dispatches as soon as one is present); a caller that derives `charging`
+* from such a push turns "nothing was said" into 'none' and overwrites a known
+* 'dc'. When this is false the caller keeps its previous belief.
+*/
+function reportsPowerSource(info) {
+	return info.adapterStatus !== void 0 || info.chargeStatus !== void 0;
+}
+//#endregion
+//#region src/battery-contact-expiry.ts
+function shouldWakeForContact(input) {
+	if (input.hubChild) return false;
+	if (!input.sleeping) return false;
+	const last = input.lastContactAt;
+	if (typeof last !== "number" || last <= 0) return false;
+	return input.nowMs - last + input.tickMs >= input.unreachableAfterMs;
+}
+//#endregion
 //#region src/log-channels.ts
 /**
 * The diagnostic log CHANNELS `provider-reolink` declares.
@@ -236339,8 +236610,10 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			deviceId: this.id,
 			channel: this.getChannel(),
 			sleeping: this.isBattery && this.sleeping,
+			hubChild: this.isHubChild(),
 			getApi: () => this.ensureApi(),
 			cache: this.config.get("deviceCache"),
+			batteryState: this.runtimeState.getCapState("battery"),
 			logger: this.ctx.logger,
 			now: Date.now()
 		});
@@ -236671,13 +236944,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* tracker is more reliable.
 	*/
 	mapBatteryInfo(info) {
-		const percentage = typeof info.batteryPercent === "number" ? Math.max(0, Math.min(100, Math.round(info.batteryPercent))) : this.state.battery.percentage ?? null;
-		const adapter = (info.adapterStatus ?? "").toLowerCase();
-		const charge = (info.chargeStatus ?? "").toLowerCase();
-		const isCharging = charge === "charging" || charge === "chargecomplete";
 		return {
-			percentage,
-			charging: adapter.includes("solar") ? "solar" : isCharging ? "dc" : "none",
+			percentage: typeof info.batteryPercent === "number" ? Math.max(0, Math.min(100, Math.round(info.batteryPercent))) : this.state.battery.percentage ?? null,
+			charging: reportsPowerSource(info) ? deriveChargingSource(info.adapterStatus, info.chargeStatus) : this.state.battery.charging ?? "none",
 			sleeping: info.sleeping === true || this.sleeping,
 			lastUpdated: Date.now()
 		};
@@ -240226,6 +240495,17 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		const cycle = (async () => {
 			try {
 				if (this.isBattery && this.sleeping) {
+					if (shouldWakeForContact({
+						nowMs: Date.now(),
+						lastContactAt: this.state.battery.lastContactAt,
+						sleeping: true,
+						hubChild: this.isHubChild(),
+						unreachableAfterMs: 216e5,
+						tickMs: ReolinkCamera.BATTERY_UPDATE_INTERVAL_MS
+					})) {
+						await this.wakeForContactRefresh();
+						return;
+					}
 					this.ctx.logger.debug("battery-update: cam sleeping — skipping cycle without connecting", { tags: { deviceId: this.id } });
 					return;
 				}
@@ -240270,6 +240550,43 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.batteryUpdateInFlight = cycle;
 		return cycle;
 	}
+	/**
+	* D355: wake a standalone battery camera ONCE because its last passive
+	* contact is about to expire, and refresh every slice while it is up.
+	* Bounded by `canProactivelyWake` (the shared cooldown) and by the fact
+	* that a wake that answers resets the silence. A wake that fails is left
+	* alone: the silence then reaches the budget and `deriveBatteryPresence`
+	* says `unreachable` — for the first time on evidence.
+	*/
+	async wakeForContactRefresh() {
+		if (!this.canProactivelyWake("contact-expiry")) return;
+		this.markWakeIssued();
+		const lastContactAt = this.state.battery.lastContactAt ?? 0;
+		const silenceMs = Date.now() - lastContactAt;
+		this.ctx.logger.info("battery contact expiring — waking once to refresh every slice (D355)", {
+			tags: { deviceId: this.id },
+			meta: {
+				silenceMs,
+				budgetMs: BATTERY_UNREACHABLE_AFTER_MS
+			}
+		});
+		try {
+			await this.ensureApi();
+		} catch (err) {
+			this.ctx.logger.warn("battery contact wake FAILED — silence continues and the camera will read unreachable at the budget", {
+				tags: { deviceId: this.id },
+				meta: {
+					silenceMs,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			return;
+		}
+		await this.refreshBatteryFromApi("demand").catch(() => {});
+		await this.warmCapSlicesOnWake().catch(() => {});
+		await this.alignAuxDevicesState("wake").catch(() => {});
+		await this.warmSnapshotOnWake().catch(() => {});
+	}
 	/** Arm the periodic battery-cam refresh timer. No-op for wired cams
 	*  (their state is kept fresh by the 10 s aux-align poll and push
 	*  events). Idempotent. */
@@ -245192,6 +245509,7 @@ exports.collectMultifocalDiagnostics = collectMultifocalDiagnostics;
 exports.collectNativeDiagnostics = collectNativeDiagnostics;
 exports.collectNvrDiagnostics = collectNvrDiagnostics;
 exports.createDiagnosticsBundle = createDiagnosticsBundle;
+exports.customActions = reolinkDebugActions;
 exports.reolinkCameraSchema = reolinkCameraSchema;
 exports.reolinkDebugActions = reolinkDebugActions;
 exports.runAllDiagnosticsConsecutively = runAllDiagnosticsConsecutively;

package/dist/addon.mjs

@@ -13527,6 +13527,24 @@ var deviceProviderCapability = {
 		})
 	}
 };
+/**
+* Device Manager capability — hub-side singleton that unifies device persistence,
+* live registry access, and all management operations into a single tRPC surface.
+*
+* Replaces:
+*   - `device-persistence` capability (persistence methods absorbed here)
+*   - `device-management.router.ts` (deleted in Phase 2)
+*   - `device-ops.router.ts` (compat layer — deleted; device-provider ops absorbed here)
+*
+* All device provider addons (rtsp, onvif, frigate, …) are hub-local: they may
+* fork into separate processes but never run on remote cluster agents. Therefore:
+*   - No nodeId routing needed — this is a pure hub singleton.
+*   - The hub's DeviceRegistry is the single source of truth for all live devices.
+*   - No shadow registry or cross-node aggregation required.
+*
+* Forked workers register devices back to the hub via `ctx.devices`
+* (DeviceManagerApi → ctx.api.deviceManager.registerDevice), same as today.
+*/
 /** One child-placement directive on a container's `childLayout`. Structurally
 *  identical to `ChildLayoutEntry` in `device-management.ts` — the cap wire
 *  shape for the same field. The child is identified by its re-sync-stable
@@ -13625,7 +13643,12 @@ var ConfigEntrySchema = object({
 	value: unknown(),
 	description: string().optional()
 });
-var LinkedDevicesModeSchema = _enum(["auto", "manual"]);
+/**
+* Only `manual` since D356: the operator picks, nothing links itself. The
+* field survives on the wire because a viewer already OTA'd parses it —
+* drop it once no shipped client reads `mode`.
+*/
+var LinkedDevicesModeSchema = _enum(["manual"]);
 /** One resolved linked device — the compact projection consumers need. */
 var LinkedDeviceSchema = object({
 	deviceId: number(),
@@ -19293,6 +19316,9 @@ var RetrainStatusSchema = _enum([
 *
 * `debug` does NOT pin; it is attention, not durability.
 *
+* `debugNote` is the operator's own words about WHAT should be checked on this
+* track, and it lives and dies with `debug` — see {@link MAX_TRACK_DEBUG_NOTE_LEN}.
+*
 * `favourited` IS a BOOLEAN pin (durability bit), not a retrain lifecycle.
 * A favourited track is skipped by retention the same way `staging` is, but
 * it does not enter `none|staging|trained` and has no staging budget.
@@ -19303,6 +19329,21 @@ var TrackFlagFields = {
 	markForTrain: boolean().optional(),
 	/** Operator marked this track for diagnostic attention. */
 	debug: boolean().optional(),
+	/**
+	* What the operator wants CHECKED on this track, in their own words.
+	*
+	* The flag alone says "look at this" and nothing about what for; a debug set
+	* reviewed hours later is a list of tracks with no question attached. Bound
+	* to `debug` on the WRITE side — the body clears it when `debug` goes off,
+	* and refuses it on a track whose debug is off — so a note can never outlive
+	* the attention it belongs to.
+	*
+	* `''` is a real value ("marked, nothing to add"); the ABSENT key means
+	* "leave whatever is stored alone", which is what lets a surface turn debug
+	* on without a note (a cancelled prompt) and what lets it edit the note
+	* without touching the flag.
+	*/
+	debugNote: string().max(500).optional(),
 	/** Operator favourited this track. Pins it against pruning. */
 	favourited: boolean().optional()
 };
@@ -19329,6 +19370,12 @@ var TrackFlagsSchema = object({
 	trackId: string(),
 	markForTrain: boolean(),
 	debug: boolean(),
+	/** The note as it STANDS after the write — never absent here (a track with no
+	*  note reports `''`), for the same reason the booleans are required: a
+	*  surface that has just written must be able to render the note it now owns
+	*  without a re-fetch, and an absent key would read as "unchanged" on a
+	*  screen that has no previous value to keep. */
+	debugNote: string(),
 	favourited: boolean(),
 	/** The lifecycle state the boolean was derived from. Required here (unlike on
 	*  a track row) because this shape is only ever produced by the write body,
@@ -34175,6 +34222,17 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
+/**
+* Default silence budget before a sleeping battery camera is called gone.
+*
+* Sized off the mechanism that produces contact, not off taste: a battery cam
+* on this deployment surfaces a firmware push (battery level, sleep/wake, or a
+* motion email) on the order of hours even with no visitors, and the snapshot
+* wrapper's own battery window is 1 hour. Six hours is therefore several
+* missed opportunities, not one — so a single quiet night does not raise a
+* fault, and a genuinely flat camera is named well inside a day.
+*/
+var BATTERY_UNREACHABLE_AFTER_MS = 360 * 6e4;
 DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
 new Set(Object.values(DeviceType));
 DeviceFeature.BatteryOperated;
@@ -179513,7 +179571,7 @@ ${xml}`);
 	* @returns Test results for all stream types and profiles
 	*/
 	async testChannelStreams(channel, logger) {
-		const { testChannelStreams } = await import("./DiagnosticsTools-QJ3CRYGA-CcYIIfQN.mjs");
+		const { testChannelStreams } = await import("./DiagnosticsTools-QJ3CRYGA-9NV95vRN.mjs");
 		return await testChannelStreams({
 			api: this,
 			channel: this.normalizeChannel(channel),
@@ -179529,7 +179587,7 @@ ${xml}`);
 	* @returns Complete diagnostics for all channels and streams
 	*/
 	async collectMultifocalDiagnostics(logger) {
-		const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-QJ3CRYGA-CcYIIfQN.mjs");
+		const { collectMultifocalDiagnostics } = await import("./DiagnosticsTools-QJ3CRYGA-9NV95vRN.mjs");
 		return await collectMultifocalDiagnostics({
 			api: this,
 			logger
@@ -231278,7 +231336,8 @@ var RawReadSliceSchema = _enum([
 	"osd",
 	"led",
 	"pir",
-	"autoReboot"
+	"autoReboot",
+	"battery"
 ]);
 /**
 * The allow-list. `Record<RawReadSlice, …>` keeps the catalog and the enum
@@ -231289,17 +231348,26 @@ var RawReadSliceSchema = _enum([
 var RAW_READ_CATALOG = {
 	image: {
 		command: "getVideoInput",
-		snapshotKey: "imageSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "imageSnapshot"
+		},
 		invoke: (api, channel) => api.getVideoInput(channel)
 	},
 	motion: {
 		command: "getMotionAlarm",
-		snapshotKey: "motionSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "motionSnapshot"
+		},
 		invoke: (api, channel) => api.getMotionAlarm(channel)
 	},
 	ai: {
 		command: "getAiDetectTypes + getAiDetectionFull (per type)",
-		snapshotKey: "aiSensitivitySnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "aiSensitivitySnapshot"
+		},
 		invoke: async (api, channel) => {
 			const detectTypes = await api.getAiDetectTypes(channel, { timeoutMs: 1500 });
 			const perType = {};
@@ -231316,71 +231384,204 @@ var RAW_READ_CATALOG = {
 	},
 	enc: {
 		command: "getEnc",
-		snapshotKey: "encSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "encSnapshot"
+		},
 		invoke: (api, channel) => api.getEnc(channel)
 	},
 	encOptions: {
 		command: "getEncOptions",
-		snapshotKey: "encOptionsSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "encOptionsSnapshot"
+		},
 		invoke: (api, channel) => api.getEncOptions(channel)
 	},
 	mask: {
 		command: "getMask",
-		snapshotKey: "maskSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "maskSnapshot"
+		},
 		invoke: (api, channel) => api.getMask(channel)
 	},
 	audioNoise: {
 		command: "getAudioNoise",
-		snapshotKey: "audioNoiseSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "audioNoiseSnapshot"
+		},
 		invoke: (api, channel) => api.getAudioNoise(channel)
 	},
 	autofocus: {
 		command: "getAutoFocus",
-		snapshotKey: "autoFocusSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "autoFocusSnapshot"
+		},
 		invoke: (api, channel) => api.getAutoFocus(channel, { timeoutMs: 1500 })
 	},
 	netPort: {
 		command: "getNetPort",
-		snapshotKey: "netPortSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "netPortSnapshot"
+		},
 		invoke: (api) => api.getNetPort()
 	},
 	ntp: {
 		command: "getNtp",
-		snapshotKey: "ntpSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "ntpSnapshot"
+		},
 		invoke: (api) => api.getNtp()
 	},
 	systemGeneral: {
 		command: "getSystemGeneral",
-		snapshotKey: "systemGeneralSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "systemGeneralSnapshot"
+		},
 		invoke: (api) => api.getSystemGeneral()
 	},
 	osd: {
 		command: "getOsd",
-		snapshotKey: "osdSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "osdSnapshot"
+		},
 		invoke: (api, channel) => api.getOsd(channel)
 	},
 	led: {
 		command: "getIrLights",
-		snapshotKey: "ledSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "ledSnapshot"
+		},
 		invoke: (api, channel) => api.getIrLights(channel)
 	},
 	pir: {
 		command: "getPirInfo",
-		snapshotKey: "pirSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "pirSnapshot"
+		},
 		invoke: (api, channel) => api.getPirInfo(channel)
 	},
 	autoReboot: {
 		command: "getAutoReboot",
-		snapshotKey: "autoRebootSnapshot",
+		believed: {
+			kind: "deviceCache",
+			snapshotKey: "autoRebootSnapshot"
+		},
 		invoke: (api) => api.getAutoReboot()
+	},
+	/**
+	* Battery — one slice, TWO firmware reads, chosen by how the camera is
+	* attached. They are not variants of one call:
+	*
+	*   - **standalone**: `getBatteryInfo(channel)` — the camera's own
+	*     answer, one `BatteryInfo`;
+	*   - **hub child**: `getAllChannelsBatteryInfo()` — a HUB-level CGI
+	*     keyed by channel, projected to the requested one here so the slice
+	*     stays per-camera like the other fifteen (a "cluster-wide" second
+	*     slice shape would have to be understood by every caller).
+	*
+	* Both vocabularies carry `adapterStatus` next to `chargeStatus`, which
+	* is why this slice exists: the provider keeps only the latter, and
+	* whether `adapterStatus` MOVES was previously observable exactly once
+	* per hub process (`ReolinkHub.batteryShapeLogged`). The answer is
+	* returned as the firmware gave it, under a `readVia` that names the path
+	* — NOT normalised into a shared shape. The paths do not carry the same
+	* fields (`voltage`/`lowPower` on the camera read, `channelsReported` and
+	* the channel-status row on the hub read); a field the firmware did not
+	* send must be ABSENT, because a default here would be indistinguishable
+	* from a reading (D315).
+	*
+	* A camera that cannot answer at all throws, and the read comes back
+	* `read-failed` carrying the firmware's reason — "we could not read it"
+	* must never be served as "it has no battery".
+	*/
+	battery: {
+		command: "getBatteryInfo (standalone) / getAllChannelsBatteryInfo projected (hub child)",
+		believed: {
+			kind: "capRuntimeState",
+			capName: "battery"
+		},
+		servedByParentHub: true,
+		invoke: async (api, channel, ctx) => {
+			if (!ctx.hubChild) return {
+				readVia: "camera",
+				command: "getBatteryInfo",
+				channel,
+				batteryInfo: await api.getBatteryInfo(channel)
+			};
+			const byChannel = (await api.getAllChannelsBatteryInfo()).batteryInfoData;
+			const channelsReported = Object.keys(byChannel).map(Number).filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+			const info = byChannel[channel];
+			if (info === void 0) throw new Error(`getAllChannelsBatteryInfo answered for channels [${channelsReported.join(", ")}] but not channel ${channel} — this camera's battery was NOT reported. That is an unanswered read, not "no battery".`);
+			const [cgiBattery, channelStatus] = info.entries;
+			return {
+				readVia: "parentHub",
+				command: "getAllChannelsBatteryInfo",
+				channel,
+				channelsReported,
+				batteryInfo: {
+					...info,
+					entries: [cgiBattery ?? null, redactChannelIdentity(channelStatus)]
+				}
+			};
+		}
 	}
 };
+/**
+* The hub's channel-status row (`entries[1]`) carries the camera's Reolink
+* P2P `uid` — a routable cloud identifier for the device. A charge-state
+* read has no reason to hand it out, so it is dropped here rather than
+* relied on not to be looked at. The drop is STATED (`uidRedacted`): a
+* removed field and a firmware that never sent one must not look alike.
+* Everything else in the row (channel, name, online, sleep, typeInfo) is
+* kept verbatim — it is the context that makes the battery row readable.
+*/
+function redactChannelIdentity(entry) {
+	if (entry === void 0) return null;
+	const { uid, ...rest } = entry;
+	return {
+		...rest,
+		uidRedacted: uid !== void 0
+	};
+}
+/**
+* Age of a `capRuntimeState` belief. The cap slice carries `lastUpdated`
+* rather than a freshness-map stamp, and its `empty` seed is `0` — which is
+* NOT an observation, so it resolves to `never`. A slice that was never
+* written at all is `never` too: on a battery reading, "we hold no value"
+* and "we measured 0%" are an alarm apart (see `BatteryStatusSchema`).
+*/
+function capStateAge(state, now) {
+	if (state === void 0) return { state: "never" };
+	const lastUpdated = state.lastUpdated;
+	if (typeof lastUpdated !== "number" || lastUpdated <= 0) return { state: "never" };
+	return {
+		state: "known",
+		fetchedAt: lastUpdated,
+		ageMs: Math.max(0, now - lastUpdated)
+	};
+}
 /** What CamStack currently believes about the slice, with its own age. */
 var BelievedStateSchema = object({
-	/** The persisted projection (`deviceCache.<snapshotKey>`), verbatim. */
+	/** The persisted projection / cap slice, verbatim. */
 	snapshot: unknown(),
-	/** deviceCache field the projection lives in. */
-	snapshotKey: string(),
+	/** Where that belief lives — mirrors {@link BelievedSource}. */
+	source: discriminatedUnion("kind", [object({
+		kind: literal("deviceCache"),
+		snapshotKey: string()
+	}), object({
+		kind: literal("capRuntimeState"),
+		capName: literal("battery")
+	})]),
 	/** Tri-state freshness — `never` / `unknown` (legacy, no stamp) / `known`. */
 	age: union([
 		object({ state: literal("never") }),
@@ -231419,11 +231620,17 @@ var RawReadInputSchema = object({
 	deviceId: number().int().nonnegative(),
 	slice: RawReadSliceSchema
 });
-function believedState(cache, entry, now) {
-	const age = resolveSnapshotAge(cache, entry.snapshotKey, now);
+function believedState(deps, entry) {
+	const source = entry.believed;
+	if (source.kind === "capRuntimeState") return {
+		snapshot: toPlainJson(deps.batteryState),
+		source,
+		age: capStateAge(deps.batteryState, deps.now)
+	};
+	const age = resolveSnapshotAge(deps.cache, source.snapshotKey, deps.now);
 	return {
-		snapshot: toPlainJson(cache === void 0 ? void 0 : Reflect.get(cache, entry.snapshotKey)),
-		snapshotKey: entry.snapshotKey,
+		snapshot: toPlainJson(deps.cache === void 0 ? void 0 : Reflect.get(deps.cache, source.snapshotKey)),
+		source,
 		age
 	};
 }
@@ -231443,8 +231650,9 @@ function toPlainJson(value) {
 */
 async function performRawRead(slice, deps) {
 	const entry = RAW_READ_CATALOG[slice];
-	const believed = believedState(deps.cache, entry, deps.now);
-	if (deps.sleeping) {
+	const believed = believedState(deps, entry);
+	const servedWithoutTouchingCamera = deps.hubChild && entry.servedByParentHub === true;
+	if (deps.sleeping && !servedWithoutTouchingCamera) {
 		deps.logger.info("reolink raw read refused — battery cam is sleeping", {
 			tags: { deviceId: deps.deviceId },
 			meta: { slice }
@@ -231454,7 +231662,7 @@ async function performRawRead(slice, deps) {
 			deviceId: deps.deviceId,
 			slice,
 			reason: "sleeping",
-			message: "Battery camera is asleep — a raw read would wake it, so it is refused. The believed state below is what CamStack currently serves.",
+			message: deps.hubChild ? `Battery camera is asleep and the "${slice}" read is addressed to the camera channel, which would wake it — refused. The believed state below is what CamStack currently serves. (The "battery" slice is answered by the parent hub and stays readable while the camera sleeps.)` : "Battery camera is asleep — a raw read would wake it, so it is refused. The believed state below is what CamStack currently serves.",
 			believed
 		};
 	}
@@ -231480,12 +231688,14 @@ async function performRawRead(slice, deps) {
 		};
 	}
 	try {
-		const payload = await entry.invoke(api, deps.channel);
+		const payload = await entry.invoke(api, deps.channel, { hubChild: deps.hubChild });
 		deps.logger.info("reolink raw read served", {
 			tags: { deviceId: deps.deviceId },
 			meta: {
 				slice,
-				command: entry.command
+				command: entry.command,
+				viaParentHub: servedWithoutTouchingCamera,
+				cameraWasSleeping: deps.sleeping
 			}
 		});
 		return {
@@ -231544,6 +231754,67 @@ var reolinkDebugActions = defineCustomActions({ debugRawRead: customAction(RawRe
 	auth: "admin"
 }) });
 //#endregion
+//#region src/battery-charging.ts
+/**
+* Da `adapterStatus` + `chargeStatus` alla sorgente di alimentazione.
+*
+* I due campi rispondono a DUE domande diverse, e confonderle è il bug che
+* questo modulo esiste per chiudere:
+*
+*  - `adapterStatus` — l'alimentazione è COLLEGATA? Il firmware manda 0/1/2
+*    (nessuna · adattatore DC · pannello solare) e il confine dell'hub lo
+*    traduce in `'none' | 'dc' | 'solarPanel'` (`mapHubChargeStatus` e
+*    `mapHubAdapterStatus` in `reolink-hub.ts`), perché il vocabolario del
+*    percorso standalone è già a stringhe.
+*  - `chargeStatus` — la CELLA cosa sta facendo? 0 ferma · 1 in carica ·
+*    2 carica completa.
+*
+* La vecchia derivazione consultava l'adattatore SOLO per cercarci 'solar', e
+* un DC collegato cadeva nel ripiego `'none'`. Due Argus 3E lo nascondevano per
+* caso: piene e collegate rispondono `chargeStatus: 2`, che il ramo `isCharging`
+* mappava su `'dc'` per la ragione sbagliata. La Argus MagiCam (batteryVersion
+* 1, firmware 2026) collegata in permanenza risponde `chargeStatus: 0`, e per
+* tutta la sua vita è stata riportata NON in carica.
+*
+* Che `adapterStatus` sia un segnale vero e non una costante è MISURATO: il
+* 2026-09-05 l'operatore ha staccato il device 3628 e il payload grezzo è
+* passato da `adapterStatus: 1` a `0`, con `chargeStatus: 0` da entrambe le
+* parti — cioè `chargeStatus` da solo NON distingue i due stati.
+*
+* ⚠️ Questa funzione non sa ancora dire "non lo so": `BatteryStatus['charging']`
+* non ha un valore `unknown`, quindi due campi illeggibili producono `'none'`,
+* che è un valore NEGATIVO al posto di un non-noto. È il difetto D315 che
+* `percentage` ha già chiuso (è `nullable`) e questo campo no; chiuderlo tocca
+* `battery.cap.ts`, cioè la closure del server, e vive nel proprio lavoro.
+*/
+function deriveChargingSource(adapterStatus, chargeStatus) {
+	const adapter = (adapterStatus ?? "").toLowerCase();
+	const charge = (chargeStatus ?? "").toLowerCase();
+	if (adapter.includes("solar")) return "solar";
+	if (adapter === "dc") return "dc";
+	if (charge === "charging" || charge === "chargecomplete") return "dc";
+	return "none";
+}
+/**
+* Did this reading SAY anything about the power source? A battery push may
+* carry only the level (every `BatteryInfo` field is optional and nodelink
+* dispatches as soon as one is present); a caller that derives `charging`
+* from such a push turns "nothing was said" into 'none' and overwrites a known
+* 'dc'. When this is false the caller keeps its previous belief.
+*/
+function reportsPowerSource(info) {
+	return info.adapterStatus !== void 0 || info.chargeStatus !== void 0;
+}
+//#endregion
+//#region src/battery-contact-expiry.ts
+function shouldWakeForContact(input) {
+	if (input.hubChild) return false;
+	if (!input.sleeping) return false;
+	const last = input.lastContactAt;
+	if (typeof last !== "number" || last <= 0) return false;
+	return input.nowMs - last + input.tickMs >= input.unreachableAfterMs;
+}
+//#endregion
 //#region src/log-channels.ts
 /**
 * The diagnostic log CHANNELS `provider-reolink` declares.
@@ -236319,8 +236590,10 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			deviceId: this.id,
 			channel: this.getChannel(),
 			sleeping: this.isBattery && this.sleeping,
+			hubChild: this.isHubChild(),
 			getApi: () => this.ensureApi(),
 			cache: this.config.get("deviceCache"),
+			batteryState: this.runtimeState.getCapState("battery"),
 			logger: this.ctx.logger,
 			now: Date.now()
 		});
@@ -236651,13 +236924,9 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* tracker is more reliable.
 	*/
 	mapBatteryInfo(info) {
-		const percentage = typeof info.batteryPercent === "number" ? Math.max(0, Math.min(100, Math.round(info.batteryPercent))) : this.state.battery.percentage ?? null;
-		const adapter = (info.adapterStatus ?? "").toLowerCase();
-		const charge = (info.chargeStatus ?? "").toLowerCase();
-		const isCharging = charge === "charging" || charge === "chargecomplete";
 		return {
-			percentage,
-			charging: adapter.includes("solar") ? "solar" : isCharging ? "dc" : "none",
+			percentage: typeof info.batteryPercent === "number" ? Math.max(0, Math.min(100, Math.round(info.batteryPercent))) : this.state.battery.percentage ?? null,
+			charging: reportsPowerSource(info) ? deriveChargingSource(info.adapterStatus, info.chargeStatus) : this.state.battery.charging ?? "none",
 			sleeping: info.sleeping === true || this.sleeping,
 			lastUpdated: Date.now()
 		};
@@ -240206,6 +240475,17 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		const cycle = (async () => {
 			try {
 				if (this.isBattery && this.sleeping) {
+					if (shouldWakeForContact({
+						nowMs: Date.now(),
+						lastContactAt: this.state.battery.lastContactAt,
+						sleeping: true,
+						hubChild: this.isHubChild(),
+						unreachableAfterMs: 216e5,
+						tickMs: ReolinkCamera.BATTERY_UPDATE_INTERVAL_MS
+					})) {
+						await this.wakeForContactRefresh();
+						return;
+					}
 					this.ctx.logger.debug("battery-update: cam sleeping — skipping cycle without connecting", { tags: { deviceId: this.id } });
 					return;
 				}
@@ -240250,6 +240530,43 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.batteryUpdateInFlight = cycle;
 		return cycle;
 	}
+	/**
+	* D355: wake a standalone battery camera ONCE because its last passive
+	* contact is about to expire, and refresh every slice while it is up.
+	* Bounded by `canProactivelyWake` (the shared cooldown) and by the fact
+	* that a wake that answers resets the silence. A wake that fails is left
+	* alone: the silence then reaches the budget and `deriveBatteryPresence`
+	* says `unreachable` — for the first time on evidence.
+	*/
+	async wakeForContactRefresh() {
+		if (!this.canProactivelyWake("contact-expiry")) return;
+		this.markWakeIssued();
+		const lastContactAt = this.state.battery.lastContactAt ?? 0;
+		const silenceMs = Date.now() - lastContactAt;
+		this.ctx.logger.info("battery contact expiring — waking once to refresh every slice (D355)", {
+			tags: { deviceId: this.id },
+			meta: {
+				silenceMs,
+				budgetMs: BATTERY_UNREACHABLE_AFTER_MS
+			}
+		});
+		try {
+			await this.ensureApi();
+		} catch (err) {
+			this.ctx.logger.warn("battery contact wake FAILED — silence continues and the camera will read unreachable at the budget", {
+				tags: { deviceId: this.id },
+				meta: {
+					silenceMs,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			return;
+		}
+		await this.refreshBatteryFromApi("demand").catch(() => {});
+		await this.warmCapSlicesOnWake().catch(() => {});
+		await this.alignAuxDevicesState("wake").catch(() => {});
+		await this.warmSnapshotOnWake().catch(() => {});
+	}
 	/** Arm the periodic battery-cam refresh timer. No-op for wired cams
 	*  (their state is kept fresh by the 10 s aux-align poll and push
 	*  events). Idempotent. */
@@ -245165,4 +245482,4 @@ var ReolinkProviderAddon = class extends BaseDeviceProvider {
 	}
 };
 //#endregion
-export { ReolinkProviderAddon, collectMultifocalDiagnostics as a, createDiagnosticsBundle as c, sampleStreams as d, testChannelStreams as f, collectCgiDiagnostics as i, runAllDiagnosticsConsecutively as l, reolinkCameraSchema as n, collectNativeDiagnostics as o, reolinkDebugActions as r, collectNvrDiagnostics as s, ReolinkCamera as t, runMultifocalDiagnosticsConsecutively as u };
+export { ReolinkProviderAddon, collectNativeDiagnostics as a, runAllDiagnosticsConsecutively as c, reolinkDebugActions as customActions, testChannelStreams as d, collectMultifocalDiagnostics as i, runMultifocalDiagnosticsConsecutively as l, reolinkCameraSchema as n, collectNvrDiagnostics as o, collectCgiDiagnostics as r, createDiagnosticsBundle as s, ReolinkCamera as t, sampleStreams as u };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { ReolinkProviderAddon, n as reolinkCameraSchema, r as reolinkDebugActions, t as ReolinkCamera } from "./addon.mjs";
+import { ReolinkProviderAddon, customActions as reolinkDebugActions, n as reolinkCameraSchema, t as ReolinkCamera } from "./addon.mjs";
 export { ReolinkCamera, ReolinkProviderAddon, reolinkDebugActions as customActions, reolinkCameraSchema };

package/package.json

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

package/dist/DiagnosticsTools-QJ3CRYGA-CcYIIfQN.mjs

@@ -1,2 +0,0 @@
-import { a as collectMultifocalDiagnostics, f as testChannelStreams } from "./addon.mjs";
-export { collectMultifocalDiagnostics, testChannelStreams };