@camstack/addon-provider-reolink 1.2.28 → 1.2.30

package/dist/addon.js

@@ -19732,7 +19732,16 @@ targets: array(object({
 			/** A sleeping battery camera: the frame is deliberately stale and will
 			*  NOT refresh in the background. A surface should say so rather than
 			*  present it as current. */
-			sleeping: boolean()
+			sleeping: boolean(),
+			/** Current device state rendered over the cached frame. State images
+			*  remain authoritative even when their photographic background is
+			*  old; null means the link must carry a current camera frame. */
+			stateReason: _enum([
+				"disabled",
+				"sleeping",
+				"unreachable",
+				"waking"
+			]).nullable()
 		})))
 	},
 	status: {
@@ -21392,6 +21401,25 @@ var BatteryStatusSchema = object({
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
 	lastUpdated: number(),
 	/**
+	* Ms epoch of the last time the device PROVED it was reachable — a
+	* completed firmware round-trip, an observed wake, or an inbound push
+	* (firmware event, email). `0`/absent = never since this slice was born.
+	*
+	* This is the ONLY input that separates "asleep" from "gone", and it is
+	* fed exclusively by PASSIVE signals: nothing may write it by reaching
+	* for the radio, because a poll that confirms reachability is the same
+	* poll that drains the battery. See {@link deriveBatteryPresence} — the
+	* single derivation every consumer must use; no surface computes its own.
+	*
+	* It is deliberately NOT a clock in the
+	* `scripts/check-runtime-state-durability.ts` sense: it is the
+	* observation itself, and it is the only thing a 30-hour silence is
+	* visible in. Writers quantise it (see `CONTACT_WRITE_QUANTUM_MS` in the
+	* Reolink provider) so a value that means "recently" cannot cost a
+	* SQLite commit per round-trip.
+	*/
+	lastContactAt: number().optional(),
+	/**
 	* True when the source is a BINARY low-battery indicator (HA
 	* `binary_sensor` device_class=battery / `LOW_BAT`) that has no real
 	* charge level — `percentage` is then a coarse stand-in (100 = normal,
@@ -27427,13 +27455,63 @@ var CamStreamDescriptorSchema = object({
 * set of stream descriptors it can offer for the device, synchronously, so the
 * broker can reconcile its registry against the authoritative provider state.
 */
+/**
+* The catalog as a DURABLE fact rather than a live answer.
+*
+* A battery camera's descriptors are profile-stable — they change when the
+* operator rewrites an encoder profile, not minute to minute — but building
+* them costs a Baichuan login, which on a sleeping Argus IS a wake. So the
+* provider is allowed to build them exactly once per profile and must serve
+* every later pull from a cache.
+*
+* Holding that cache only in RAM is what turned a restart into an outage. The
+* runner comes back with the camera asleep, `buildStreamCatalogUncached`
+* correctly refuses to wake it, the pull answers `[]`, the broker has no
+* cam-stream entry to build a broker from, and `webrtcSession.handleOffer`
+* fails with a flat "No broker for stream" — for as long as the camera sleeps,
+* which on a battery cam is most of the day. The camera was fine. The stream
+* was unreachable because the process had forgotten what the camera offers.
+*
+* Declaring it here puts it in `device-runtime-state`, the kernel's canonical
+* declared collection, with the same `restored` durability `battery` uses for
+* the same reason: the last known value is the only value there is while the
+* device is asleep. The broker's brokers are therefore always DEFINABLE — it
+* is the DIAL that wakes a camera, never the catalog (D173).
+*/
+var StreamCatalogStateSchema = object({
+	/** The descriptors as last built from a real camera response. Never a guess:
+	*  a failed or refused build writes NOTHING, so a restored catalog is always
+	*  one the camera itself once produced. */
+	descriptors: array(CamStreamDescriptorSchema),
+	/** Ms epoch of the build that produced {@link descriptors}. Lets the wake
+	*  path decide whether the camera's own awake window is worth spending on a
+	*  re-read. */
+	lastFetchedAt: number()
+});
 var streamCatalogCapability = {
 	name: "stream-catalog",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	methods: { getCatalog: method(object({ deviceId: number().int().nonnegative() }), array(CamStreamDescriptorSchema).readonly()) }
+	methods: { getCatalog: method(object({ deviceId: number().int().nonnegative() }), array(CamStreamDescriptorSchema).readonly()) },
+	runtimeState: StreamCatalogStateSchema,
+	/**
+	* Runtime-state durability: **restored** — see the schema doc. A cold
+	* catalog on a sleeping battery camera is not a slow first frame, it is a
+	* camera that cannot be watched at all until it happens to wake.
+	*
+	* Churn is nil by construction: the slice is written only by a SUCCESSFUL
+	* build, and a build only runs when there is no cached copy (or the copy is
+	* a day old and the camera is awake anyway).
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock field: written, but excluded from the compare that decides whether
+	*  persisting is worth a SQLite commit — the descriptors are the value. */
+	volatileStateFields: ["lastFetchedAt"]
 };
 /** One of the camera's stream profiles. */
 var StreamProfileSchema = _enum([
@@ -29297,6 +29375,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
+	streamCatalog: streamCatalogCapability,
 	streamParams: streamParamsCapability,
 	switch: switchCapability,
 	tamper: tamperCapability,
@@ -230171,6 +230250,13 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* retries.
 	*/
 	async onProbe() {
+		if (this.isBattery && this.sleeping) {
+			this.ctx.logger.info("onProbe skipped — battery cam is sleeping (no login, no wake)", {
+				tags: { deviceId: this.id },
+				meta: { probeRetriesAvoided: true }
+			});
+			return;
+		}
 		let api;
 		try {
 			api = await this.ensureApi();
@@ -230839,6 +230925,39 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						});
 						await sleep$1(1500);
 					})(), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("wakeForStream timeout")), timeoutMs))]);
+					const CONFIRM_TIMEOUT_MS = 1e4;
+					const CONFIRM_POLL_MS = 1e3;
+					const confirmDeadline = Date.now() + CONFIRM_TIMEOUT_MS;
+					let confirmed = false;
+					while (Date.now() < confirmDeadline) {
+						let state = null;
+						try {
+							state = api.getSleepStatus({ channel: this.getChannel() }).state;
+						} catch {
+							state = null;
+						}
+						if (state === "awake") {
+							confirmed = true;
+							break;
+						}
+						await sleep$1(CONFIRM_POLL_MS);
+					}
+					if (confirmed && this.commitSleepState(false, "sleep-poll")) {
+						this.ctx.logger.info("battery wakeForStream: wake confirmed — driving wake transition", {
+							tags: { deviceId: this.id },
+							meta: { confirmMs: Date.now() - startedAt }
+						});
+						this.onWakeTransition("sleep-poll").catch(() => {});
+					} else if (!confirmed) {
+						this.ctx.logger.warn("battery wakeForStream: ACK received but no awake evidence inside the confirm window", {
+							tags: { deviceId: this.id },
+							meta: { confirmTimeoutMs: CONFIRM_TIMEOUT_MS }
+						});
+						return {
+							awoke: false,
+							durationMs: Date.now() - startedAt
+						};
+					}
 					return {
 						awoke: true,
 						durationMs: Date.now() - startedAt
@@ -230871,9 +230990,21 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				status: slice
 			}));
 		});
-		this.refreshBatteryFromApi();
+		this.refreshBatteryFromApi("register");
 	}
-	async refreshBatteryFromApi() {
+	/**
+	* @param reason - `'register'` and `'periodic'` are OUR initiative and are
+	*   refused while the camera sleeps; `'wake'` and `'demand'` run because
+	*   something already has the camera awake or is entitled to wake it.
+	*/
+	async refreshBatteryFromApi(reason) {
+		if (this.isBattery && this.sleeping && (reason === "register" || reason === "periodic")) {
+			this.ctx.logger.debug("battery refresh skipped — cam sleeping, reading restored slice", {
+				tags: { deviceId: this.id },
+				meta: { reason }
+			});
+			return;
+		}
 		let api;
 		try {
 			api = await this.ensureApi();
@@ -231031,7 +231162,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		return true;
 	}
 	updateBatteryCache(info) {
-		this.setCapSlice(batteryCapability, this.mapBatteryInfo(info));
+		const mapped = this.mapBatteryInfo(info);
+		const now = Date.now();
+		const quantised = now - now % ReolinkCamera.CONTACT_WRITE_QUANTUM_MS;
+		const previousContact = this.state.battery.lastContactAt ?? 0;
+		this.setCapSlice(batteryCapability, {
+			...mapped,
+			lastContactAt: Math.max(previousContact, quantised)
+		});
 	}
 	/**
 	* Battery cams require an explicit wake before cmd_id 109 will
@@ -233356,6 +233494,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	async buildStreamCatalog() {
 		if (this.cachedStreamDescriptors?.length) return this.withLiveNativeSdp(this.cachedStreamDescriptors);
+		const restored = this.restoreStreamCatalogFromLedger();
+		if (restored) return this.withLiveNativeSdp(restored);
 		if (this.buildStreamCatalogInFlight) return this.withLiveNativeSdp(await this.buildStreamCatalogInFlight);
 		const build = this.buildStreamCatalogUncached();
 		this.buildStreamCatalogInFlight = build;
@@ -233528,6 +233668,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			autoEligible: e.autoEligible
 		}));
 		this.cachedStreamDescriptors = descriptors;
+		this.persistStreamCatalogToLedger(descriptors);
 		return descriptors;
 	}
 	/** Profile-stable stream descriptors, cached after the first successful
@@ -233535,6 +233676,66 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*  sleeping battery cam is never woken by a catalog poll. Invalidated by
 	*  `applyStreamProfilePatch` (codec/resolution may change). */
 	cachedStreamDescriptors;
+	/**
+	* Write the just-built catalog to the durable `stream-catalog` slice, so a
+	* restart with the camera asleep still has descriptors to serve (D173).
+	*
+	* Best-effort by design: the RAM copy is already advanced by the caller, and
+	* losing this write costs one cold catalog after the next restart — never a
+	* wrong catalog. A build that FAILED writes nothing at all and therefore
+	* cannot demote a good stored copy (D49's failure direction).
+	*/
+	persistStreamCatalogToLedger(descriptors) {
+		if (descriptors.length === 0) return;
+		try {
+			const state = {
+				descriptors: [...descriptors],
+				lastFetchedAt: Date.now()
+			};
+			this.runtimeState.setCapState(streamCatalogCapability.name, state);
+			this.ctx.logger.debug("stream catalog persisted to the durable slice", {
+				tags: { deviceId: this.id },
+				meta: { count: descriptors.length }
+			});
+		} catch (err) {
+			this.ctx.logger.debug("stream catalog persist failed — RAM copy stands", {
+				tags: { deviceId: this.id },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+	}
+	/**
+	* Rehydrate `cachedStreamDescriptors` from the durable slice. Returns the
+	* restored descriptors, or `null` when there is nothing to restore.
+	*
+	* Logged at `info` when it fires: "these descriptors came from before the
+	* restart" must never be something a reader has to infer (the DurableLedger
+	* contract, D132).
+	*/
+	restoreStreamCatalogFromLedger() {
+		const stored = this.runtimeState.getCapState(streamCatalogCapability.name);
+		const descriptors = stored?.descriptors;
+		if (!descriptors || descriptors.length === 0) return null;
+		this.cachedStreamDescriptors = [...descriptors];
+		this.ctx.logger.info("stream catalog restored from the durable slice (no camera contact)", {
+			tags: { deviceId: this.id },
+			meta: {
+				count: descriptors.length,
+				builtAt: stored?.lastFetchedAt ?? 0,
+				ageMs: Date.now() - (stored?.lastFetchedAt ?? 0),
+				sleeping: this.sleeping
+			}
+		});
+		return this.cachedStreamDescriptors;
+	}
+	/**
+	* How old a RESTORED catalog may get before a natural wake is worth spending
+	* on a re-read. The catalog is profile-stable, so this is not about
+	* freshness — it is the backstop for a profile changed by something that did
+	* not invalidate the cache (a firmware update, an edit made on the Reolink
+	* app). A day is several natural wakes on any camera that is working.
+	*/
+	static CATALOG_REFRESH_ON_WAKE_MS = 1440 * 6e4;
 	/** Single-flight guard for `buildStreamCatalog`. */
 	buildStreamCatalogInFlight = null;
 	/**
@@ -233997,7 +234198,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						auxAccessoryCount: this.auxAccessoryRefs.size
 					}
 				});
-				await this.refreshBatteryFromApi().catch(() => {});
+				await this.refreshBatteryFromApi("periodic").catch(() => {});
 				await this.alignAuxDevicesState("periodic").catch(() => {});
 				await this.refreshParentSettingsSnapshot().catch(() => {});
 			} finally {
@@ -234032,6 +234233,44 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		}
 	}
 	/**
+	* Is this wake worth spending on a catalog re-read? See
+	* `CATALOG_REFRESH_ON_WAKE_MS`. Held apart from `onWakeTransition` so the
+	* decision is one expression a test can pin.
+	*/
+	shouldRebuildCatalogOnWake() {
+		if (!this.cachedStreamDescriptors?.length) {
+			if (!this.restoreStreamCatalogFromLedger()) return true;
+		}
+		const builtAt = this.runtimeState.getCapState(streamCatalogCapability.name)?.lastFetchedAt ?? 0;
+		if (builtAt <= 0) return true;
+		return Date.now() - builtAt > ReolinkCamera.CATALOG_REFRESH_ON_WAKE_MS;
+	}
+	/**
+	* A PASSIVE proof of reachability just arrived — stamp `battery.lastContactAt`
+	* so `deriveBatteryPresence` can tell "asleep" from "gone" (D173).
+	*
+	* Callable only from paths where the evidence cost us nothing: an inbound
+	* firmware push, an observed wake, a round-trip somebody else's demand
+	* already paid for. Never from a poll issued to answer this question — that
+	* poll is the wake it is trying to detect.
+	*
+	* Quantised to `CONTACT_WRITE_QUANTUM_MS`: the value means "recently", and
+	* writing it at millisecond resolution would put a SQLite commit behind
+	* every Baichuan reply on the hub's busiest write path (the exact cost
+	* `scripts/check-runtime-state-durability.ts` exists to bound).
+	*/
+	markPassiveContact() {
+		if (!this.isBattery) return;
+		const now = Date.now();
+		const quantised = now - now % ReolinkCamera.CONTACT_WRITE_QUANTUM_MS;
+		if (quantised <= (this.state.battery.lastContactAt ?? 0)) return;
+		this.state.battery.lastContactAt = quantised;
+	}
+	/** Write granularity for `battery.lastContactAt` — see `markPassiveContact`.
+	*  Bounds the commit rate this field can cost at 12/hour/device, and only
+	*  for a device something is actually reaching. */
+	static CONTACT_WRITE_QUANTUM_MS = 5 * 6e4;
+	/**
 	* Shared wake-transition handler invoked by both the simpleEvent
 	* `awake` push (canonical fast path) and the sleep poll's
 	* `sleeping → awake` flip (backstop). Mirrors Scrypted's
@@ -234056,7 +234295,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				isBattery: this.isBattery
 			}
 		});
-		if (!this.cachedStreamDescriptors?.length) try {
+		if (this.shouldRebuildCatalogOnWake()) try {
+			this.cachedStreamDescriptors = void 0;
 			if ((await this.buildStreamCatalog()).length > 0) this.ctx.eventBus.emit(createEvent(EventCategory.StreamParamsChanged, this.eventSource(), { deviceId: this.id }));
 		} catch (err) {
 			this.ctx.logger.debug("onWakeTransition: stream catalog build failed — will retry on next wake", {
@@ -235769,7 +236009,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			this.startSleepPoll();
 			this.startBatteryUpdatePolling();
 			this.registerBatteryIfSupported();
-			this.refreshBatteryFromApi();
+			this.refreshBatteryFromApi("demand");
 		} else this.startAlignAuxPolling();
 		this.resubscribeSimpleEvents(api, "adoptApi").catch((err) => {
 			this.ctx.logger.debug("Reolink adoptApi: simple-event subscribe failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
@@ -235881,7 +236121,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				this.startSleepPoll();
 				this.startBatteryUpdatePolling();
 				this.registerBatteryIfSupported();
-				this.refreshBatteryFromApi();
+				this.refreshBatteryFromApi("demand");
 			}
 			this.startWatchdogs();
 			this.probeAndPersistFeatures(api).catch((err) => {
@@ -235965,6 +236205,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.lastEventAt = Date.now();
 		this.consecutiveStaleHealthChecks = 0;
 		this.nextEventHealthCheckAt = 0;
+		this.markPassiveContact();
 		const eventSource = this.eventSource();
 		if (event.type !== "battery") this.ctx.logger.info("Reolink simpleEvent received", { meta: {
 			type: event.type,
@@ -236397,6 +236638,9 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			const data = event.data;
 			if (data.parentDeviceId !== this.id) return;
 			const cid = typeof data.deviceId === "number" ? data.deviceId : null;
+			if (cid !== null) {
+				for (const [ch, did] of this.channelToDeviceId.entries()) if (did === cid) this.channelToDeviceId.delete(ch);
+			}
 			this.ctx.logger.info("Reolink Hub: child unregistered externally — refreshing discovery", cid !== null ? { tags: { deviceId: cid } } : {});
 			this.refreshDiscoveryFromCamera().catch(() => {});
 		}));
@@ -236693,7 +236937,6 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			timeoutMs: HUB_DISCOVERY_REFRESH_TIMEOUT_MS
 		} });
 		const adoptedByChannel = await this.loadAdoptedChildrenByChannel();
-		this.channelToDeviceId.clear();
 		for (const [channel, deviceId] of adoptedByChannel) this.channelToDeviceId.set(channel, deviceId);
 		try {
 			discovered = (await (await this.ensureApi()).getNvrChannelsSummary({
@@ -236701,7 +236944,7 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 				timeoutMs: HUB_DISCOVERY_REFRESH_TIMEOUT_MS
 			})).devices.map((d) => {
 				const childNativeId = computeChildNativeId(this.stableId, d.channel, d.uid);
-				const adoptedDeviceId = adoptedByChannel.get(d.channel) ?? null;
+				const adoptedDeviceId = this.channelToDeviceId.get(d.channel) ?? null;
 				return {
 					childNativeId,
 					name: d.name ?? `Channel ${d.channel}`,

package/dist/addon.mjs

@@ -19727,7 +19727,16 @@ targets: array(object({
 			/** A sleeping battery camera: the frame is deliberately stale and will
 			*  NOT refresh in the background. A surface should say so rather than
 			*  present it as current. */
-			sleeping: boolean()
+			sleeping: boolean(),
+			/** Current device state rendered over the cached frame. State images
+			*  remain authoritative even when their photographic background is
+			*  old; null means the link must carry a current camera frame. */
+			stateReason: _enum([
+				"disabled",
+				"sleeping",
+				"unreachable",
+				"waking"
+			]).nullable()
 		})))
 	},
 	status: {
@@ -21387,6 +21396,25 @@ var BatteryStatusSchema = object({
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
 	lastUpdated: number(),
 	/**
+	* Ms epoch of the last time the device PROVED it was reachable — a
+	* completed firmware round-trip, an observed wake, or an inbound push
+	* (firmware event, email). `0`/absent = never since this slice was born.
+	*
+	* This is the ONLY input that separates "asleep" from "gone", and it is
+	* fed exclusively by PASSIVE signals: nothing may write it by reaching
+	* for the radio, because a poll that confirms reachability is the same
+	* poll that drains the battery. See {@link deriveBatteryPresence} — the
+	* single derivation every consumer must use; no surface computes its own.
+	*
+	* It is deliberately NOT a clock in the
+	* `scripts/check-runtime-state-durability.ts` sense: it is the
+	* observation itself, and it is the only thing a 30-hour silence is
+	* visible in. Writers quantise it (see `CONTACT_WRITE_QUANTUM_MS` in the
+	* Reolink provider) so a value that means "recently" cannot cost a
+	* SQLite commit per round-trip.
+	*/
+	lastContactAt: number().optional(),
+	/**
 	* True when the source is a BINARY low-battery indicator (HA
 	* `binary_sensor` device_class=battery / `LOW_BAT`) that has no real
 	* charge level — `percentage` is then a coarse stand-in (100 = normal,
@@ -27422,13 +27450,63 @@ var CamStreamDescriptorSchema = object({
 * set of stream descriptors it can offer for the device, synchronously, so the
 * broker can reconcile its registry against the authoritative provider state.
 */
+/**
+* The catalog as a DURABLE fact rather than a live answer.
+*
+* A battery camera's descriptors are profile-stable — they change when the
+* operator rewrites an encoder profile, not minute to minute — but building
+* them costs a Baichuan login, which on a sleeping Argus IS a wake. So the
+* provider is allowed to build them exactly once per profile and must serve
+* every later pull from a cache.
+*
+* Holding that cache only in RAM is what turned a restart into an outage. The
+* runner comes back with the camera asleep, `buildStreamCatalogUncached`
+* correctly refuses to wake it, the pull answers `[]`, the broker has no
+* cam-stream entry to build a broker from, and `webrtcSession.handleOffer`
+* fails with a flat "No broker for stream" — for as long as the camera sleeps,
+* which on a battery cam is most of the day. The camera was fine. The stream
+* was unreachable because the process had forgotten what the camera offers.
+*
+* Declaring it here puts it in `device-runtime-state`, the kernel's canonical
+* declared collection, with the same `restored` durability `battery` uses for
+* the same reason: the last known value is the only value there is while the
+* device is asleep. The broker's brokers are therefore always DEFINABLE — it
+* is the DIAL that wakes a camera, never the catalog (D173).
+*/
+var StreamCatalogStateSchema = object({
+	/** The descriptors as last built from a real camera response. Never a guess:
+	*  a failed or refused build writes NOTHING, so a restored catalog is always
+	*  one the camera itself once produced. */
+	descriptors: array(CamStreamDescriptorSchema),
+	/** Ms epoch of the build that produced {@link descriptors}. Lets the wake
+	*  path decide whether the camera's own awake window is worth spending on a
+	*  re-read. */
+	lastFetchedAt: number()
+});
 var streamCatalogCapability = {
 	name: "stream-catalog",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
 	deviceTypes: [DeviceType.Camera],
-	methods: { getCatalog: method(object({ deviceId: number().int().nonnegative() }), array(CamStreamDescriptorSchema).readonly()) }
+	methods: { getCatalog: method(object({ deviceId: number().int().nonnegative() }), array(CamStreamDescriptorSchema).readonly()) },
+	runtimeState: StreamCatalogStateSchema,
+	/**
+	* Runtime-state durability: **restored** — see the schema doc. A cold
+	* catalog on a sleeping battery camera is not a slow first frame, it is a
+	* camera that cannot be watched at all until it happens to wake.
+	*
+	* Churn is nil by construction: the slice is written only by a SUCCESSFUL
+	* build, and a build only runs when there is no cached copy (or the copy is
+	* a day old and the camera is awake anyway).
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock field: written, but excluded from the compare that decides whether
+	*  persisting is worth a SQLite commit — the descriptors are the value. */
+	volatileStateFields: ["lastFetchedAt"]
 };
 /** One of the camera's stream profiles. */
 var StreamProfileSchema = _enum([
@@ -29292,6 +29370,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
+	streamCatalog: streamCatalogCapability,
 	streamParams: streamParamsCapability,
 	switch: switchCapability,
 	tamper: tamperCapability,
@@ -230151,6 +230230,13 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	* retries.
 	*/
 	async onProbe() {
+		if (this.isBattery && this.sleeping) {
+			this.ctx.logger.info("onProbe skipped — battery cam is sleeping (no login, no wake)", {
+				tags: { deviceId: this.id },
+				meta: { probeRetriesAvoided: true }
+			});
+			return;
+		}
 		let api;
 		try {
 			api = await this.ensureApi();
@@ -230819,6 +230905,39 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						});
 						await sleep$1(1500);
 					})(), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error("wakeForStream timeout")), timeoutMs))]);
+					const CONFIRM_TIMEOUT_MS = 1e4;
+					const CONFIRM_POLL_MS = 1e3;
+					const confirmDeadline = Date.now() + CONFIRM_TIMEOUT_MS;
+					let confirmed = false;
+					while (Date.now() < confirmDeadline) {
+						let state = null;
+						try {
+							state = api.getSleepStatus({ channel: this.getChannel() }).state;
+						} catch {
+							state = null;
+						}
+						if (state === "awake") {
+							confirmed = true;
+							break;
+						}
+						await sleep$1(CONFIRM_POLL_MS);
+					}
+					if (confirmed && this.commitSleepState(false, "sleep-poll")) {
+						this.ctx.logger.info("battery wakeForStream: wake confirmed — driving wake transition", {
+							tags: { deviceId: this.id },
+							meta: { confirmMs: Date.now() - startedAt }
+						});
+						this.onWakeTransition("sleep-poll").catch(() => {});
+					} else if (!confirmed) {
+						this.ctx.logger.warn("battery wakeForStream: ACK received but no awake evidence inside the confirm window", {
+							tags: { deviceId: this.id },
+							meta: { confirmTimeoutMs: CONFIRM_TIMEOUT_MS }
+						});
+						return {
+							awoke: false,
+							durationMs: Date.now() - startedAt
+						};
+					}
 					return {
 						awoke: true,
 						durationMs: Date.now() - startedAt
@@ -230851,9 +230970,21 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				status: slice
 			}));
 		});
-		this.refreshBatteryFromApi();
+		this.refreshBatteryFromApi("register");
 	}
-	async refreshBatteryFromApi() {
+	/**
+	* @param reason - `'register'` and `'periodic'` are OUR initiative and are
+	*   refused while the camera sleeps; `'wake'` and `'demand'` run because
+	*   something already has the camera awake or is entitled to wake it.
+	*/
+	async refreshBatteryFromApi(reason) {
+		if (this.isBattery && this.sleeping && (reason === "register" || reason === "periodic")) {
+			this.ctx.logger.debug("battery refresh skipped — cam sleeping, reading restored slice", {
+				tags: { deviceId: this.id },
+				meta: { reason }
+			});
+			return;
+		}
 		let api;
 		try {
 			api = await this.ensureApi();
@@ -231011,7 +231142,14 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		return true;
 	}
 	updateBatteryCache(info) {
-		this.setCapSlice(batteryCapability, this.mapBatteryInfo(info));
+		const mapped = this.mapBatteryInfo(info);
+		const now = Date.now();
+		const quantised = now - now % ReolinkCamera.CONTACT_WRITE_QUANTUM_MS;
+		const previousContact = this.state.battery.lastContactAt ?? 0;
+		this.setCapSlice(batteryCapability, {
+			...mapped,
+			lastContactAt: Math.max(previousContact, quantised)
+		});
 	}
 	/**
 	* Battery cams require an explicit wake before cmd_id 109 will
@@ -233336,6 +233474,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*/
 	async buildStreamCatalog() {
 		if (this.cachedStreamDescriptors?.length) return this.withLiveNativeSdp(this.cachedStreamDescriptors);
+		const restored = this.restoreStreamCatalogFromLedger();
+		if (restored) return this.withLiveNativeSdp(restored);
 		if (this.buildStreamCatalogInFlight) return this.withLiveNativeSdp(await this.buildStreamCatalogInFlight);
 		const build = this.buildStreamCatalogUncached();
 		this.buildStreamCatalogInFlight = build;
@@ -233508,6 +233648,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			autoEligible: e.autoEligible
 		}));
 		this.cachedStreamDescriptors = descriptors;
+		this.persistStreamCatalogToLedger(descriptors);
 		return descriptors;
 	}
 	/** Profile-stable stream descriptors, cached after the first successful
@@ -233515,6 +233656,66 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 	*  sleeping battery cam is never woken by a catalog poll. Invalidated by
 	*  `applyStreamProfilePatch` (codec/resolution may change). */
 	cachedStreamDescriptors;
+	/**
+	* Write the just-built catalog to the durable `stream-catalog` slice, so a
+	* restart with the camera asleep still has descriptors to serve (D173).
+	*
+	* Best-effort by design: the RAM copy is already advanced by the caller, and
+	* losing this write costs one cold catalog after the next restart — never a
+	* wrong catalog. A build that FAILED writes nothing at all and therefore
+	* cannot demote a good stored copy (D49's failure direction).
+	*/
+	persistStreamCatalogToLedger(descriptors) {
+		if (descriptors.length === 0) return;
+		try {
+			const state = {
+				descriptors: [...descriptors],
+				lastFetchedAt: Date.now()
+			};
+			this.runtimeState.setCapState(streamCatalogCapability.name, state);
+			this.ctx.logger.debug("stream catalog persisted to the durable slice", {
+				tags: { deviceId: this.id },
+				meta: { count: descriptors.length }
+			});
+		} catch (err) {
+			this.ctx.logger.debug("stream catalog persist failed — RAM copy stands", {
+				tags: { deviceId: this.id },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+	}
+	/**
+	* Rehydrate `cachedStreamDescriptors` from the durable slice. Returns the
+	* restored descriptors, or `null` when there is nothing to restore.
+	*
+	* Logged at `info` when it fires: "these descriptors came from before the
+	* restart" must never be something a reader has to infer (the DurableLedger
+	* contract, D132).
+	*/
+	restoreStreamCatalogFromLedger() {
+		const stored = this.runtimeState.getCapState(streamCatalogCapability.name);
+		const descriptors = stored?.descriptors;
+		if (!descriptors || descriptors.length === 0) return null;
+		this.cachedStreamDescriptors = [...descriptors];
+		this.ctx.logger.info("stream catalog restored from the durable slice (no camera contact)", {
+			tags: { deviceId: this.id },
+			meta: {
+				count: descriptors.length,
+				builtAt: stored?.lastFetchedAt ?? 0,
+				ageMs: Date.now() - (stored?.lastFetchedAt ?? 0),
+				sleeping: this.sleeping
+			}
+		});
+		return this.cachedStreamDescriptors;
+	}
+	/**
+	* How old a RESTORED catalog may get before a natural wake is worth spending
+	* on a re-read. The catalog is profile-stable, so this is not about
+	* freshness — it is the backstop for a profile changed by something that did
+	* not invalidate the cache (a firmware update, an edit made on the Reolink
+	* app). A day is several natural wakes on any camera that is working.
+	*/
+	static CATALOG_REFRESH_ON_WAKE_MS = 1440 * 6e4;
 	/** Single-flight guard for `buildStreamCatalog`. */
 	buildStreamCatalogInFlight = null;
 	/**
@@ -233977,7 +234178,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 						auxAccessoryCount: this.auxAccessoryRefs.size
 					}
 				});
-				await this.refreshBatteryFromApi().catch(() => {});
+				await this.refreshBatteryFromApi("periodic").catch(() => {});
 				await this.alignAuxDevicesState("periodic").catch(() => {});
 				await this.refreshParentSettingsSnapshot().catch(() => {});
 			} finally {
@@ -234012,6 +234213,44 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		}
 	}
 	/**
+	* Is this wake worth spending on a catalog re-read? See
+	* `CATALOG_REFRESH_ON_WAKE_MS`. Held apart from `onWakeTransition` so the
+	* decision is one expression a test can pin.
+	*/
+	shouldRebuildCatalogOnWake() {
+		if (!this.cachedStreamDescriptors?.length) {
+			if (!this.restoreStreamCatalogFromLedger()) return true;
+		}
+		const builtAt = this.runtimeState.getCapState(streamCatalogCapability.name)?.lastFetchedAt ?? 0;
+		if (builtAt <= 0) return true;
+		return Date.now() - builtAt > ReolinkCamera.CATALOG_REFRESH_ON_WAKE_MS;
+	}
+	/**
+	* A PASSIVE proof of reachability just arrived — stamp `battery.lastContactAt`
+	* so `deriveBatteryPresence` can tell "asleep" from "gone" (D173).
+	*
+	* Callable only from paths where the evidence cost us nothing: an inbound
+	* firmware push, an observed wake, a round-trip somebody else's demand
+	* already paid for. Never from a poll issued to answer this question — that
+	* poll is the wake it is trying to detect.
+	*
+	* Quantised to `CONTACT_WRITE_QUANTUM_MS`: the value means "recently", and
+	* writing it at millisecond resolution would put a SQLite commit behind
+	* every Baichuan reply on the hub's busiest write path (the exact cost
+	* `scripts/check-runtime-state-durability.ts` exists to bound).
+	*/
+	markPassiveContact() {
+		if (!this.isBattery) return;
+		const now = Date.now();
+		const quantised = now - now % ReolinkCamera.CONTACT_WRITE_QUANTUM_MS;
+		if (quantised <= (this.state.battery.lastContactAt ?? 0)) return;
+		this.state.battery.lastContactAt = quantised;
+	}
+	/** Write granularity for `battery.lastContactAt` — see `markPassiveContact`.
+	*  Bounds the commit rate this field can cost at 12/hour/device, and only
+	*  for a device something is actually reaching. */
+	static CONTACT_WRITE_QUANTUM_MS = 5 * 6e4;
+	/**
 	* Shared wake-transition handler invoked by both the simpleEvent
 	* `awake` push (canonical fast path) and the sleep poll's
 	* `sleeping → awake` flip (backstop). Mirrors Scrypted's
@@ -234036,7 +234275,8 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				isBattery: this.isBattery
 			}
 		});
-		if (!this.cachedStreamDescriptors?.length) try {
+		if (this.shouldRebuildCatalogOnWake()) try {
+			this.cachedStreamDescriptors = void 0;
 			if ((await this.buildStreamCatalog()).length > 0) this.ctx.eventBus.emit(createEvent(EventCategory.StreamParamsChanged, this.eventSource(), { deviceId: this.id }));
 		} catch (err) {
 			this.ctx.logger.debug("onWakeTransition: stream catalog build failed — will retry on next wake", {
@@ -235749,7 +235989,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 			this.startSleepPoll();
 			this.startBatteryUpdatePolling();
 			this.registerBatteryIfSupported();
-			this.refreshBatteryFromApi();
+			this.refreshBatteryFromApi("demand");
 		} else this.startAlignAuxPolling();
 		this.resubscribeSimpleEvents(api, "adoptApi").catch((err) => {
 			this.ctx.logger.debug("Reolink adoptApi: simple-event subscribe failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
@@ -235861,7 +236101,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 				this.startSleepPoll();
 				this.startBatteryUpdatePolling();
 				this.registerBatteryIfSupported();
-				this.refreshBatteryFromApi();
+				this.refreshBatteryFromApi("demand");
 			}
 			this.startWatchdogs();
 			this.probeAndPersistFeatures(api).catch((err) => {
@@ -235945,6 +236185,7 @@ var ReolinkCamera = class ReolinkCamera extends BaseDevice {
 		this.lastEventAt = Date.now();
 		this.consecutiveStaleHealthChecks = 0;
 		this.nextEventHealthCheckAt = 0;
+		this.markPassiveContact();
 		const eventSource = this.eventSource();
 		if (event.type !== "battery") this.ctx.logger.info("Reolink simpleEvent received", { meta: {
 			type: event.type,
@@ -236377,6 +236618,9 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			const data = event.data;
 			if (data.parentDeviceId !== this.id) return;
 			const cid = typeof data.deviceId === "number" ? data.deviceId : null;
+			if (cid !== null) {
+				for (const [ch, did] of this.channelToDeviceId.entries()) if (did === cid) this.channelToDeviceId.delete(ch);
+			}
 			this.ctx.logger.info("Reolink Hub: child unregistered externally — refreshing discovery", cid !== null ? { tags: { deviceId: cid } } : {});
 			this.refreshDiscoveryFromCamera().catch(() => {});
 		}));
@@ -236673,7 +236917,6 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 			timeoutMs: HUB_DISCOVERY_REFRESH_TIMEOUT_MS
 		} });
 		const adoptedByChannel = await this.loadAdoptedChildrenByChannel();
-		this.channelToDeviceId.clear();
 		for (const [channel, deviceId] of adoptedByChannel) this.channelToDeviceId.set(channel, deviceId);
 		try {
 			discovered = (await (await this.ensureApi()).getNvrChannelsSummary({
@@ -236681,7 +236924,7 @@ var ReolinkHub = class ReolinkHub extends BaseDevice {
 				timeoutMs: HUB_DISCOVERY_REFRESH_TIMEOUT_MS
 			})).devices.map((d) => {
 				const childNativeId = computeChildNativeId(this.stableId, d.channel, d.uid);
-				const adoptedDeviceId = adoptedByChannel.get(d.channel) ?? null;
+				const adoptedDeviceId = this.channelToDeviceId.get(d.channel) ?? null;
 				return {
 					childNativeId,
 					name: d.name ?? `Channel ${d.channel}`,

package/package.json

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