@camstack/addon-pipeline 1.2.374 → 1.2.375

package/dist/stream-broker/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-CBEUVjTS.js");
-const require_node = require("../node-DMgi6pND.js");
+const require_dist = require("../dist-C0Mg8e3I.js");
+const require_node = require("../node-CifGKjsd.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
-const require_segment_demux_js = require("../segment-demux-js-CSQVhbFI.js");
+const require_segment_demux_js = require("../segment-demux-js-LhwVw18z.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -858,6 +858,131 @@ function healthEventIsOperatorFacing(camStreamId) {
 	return !PRIVATE_STREAM_PREFIXES.some((prefix) => camStreamId.startsWith(prefix));
 }
 //#endregion
+//#region src/stream-broker/stream-broker/stream-health-policy.ts
+/**
+* WHAT a stale stream means for a battery camera (D883).
+*
+* A mains camera whose stream goes quiet for the stale window has lost its
+* stream: that is an outage. A battery camera whose stream goes quiet has,
+* ordinarily, gone to sleep — the designed steady state, not a fault. The
+* broker used to tell the two apart by nothing, so every sleep produced a
+* `stream.offline` per profile and every wake a `stream.online`, and the
+* operator's system-event rule pushed each one.
+*
+* The verdict is made HERE, at the emitter, from the battery's own sleep
+* mirror — never by a filter downstream:
+*
+*  - asleep and nobody asked for the stream — NOT an outage (`asleep`);
+*  - asleep, a stream was DEMANDED and none arrived — `wake-timeout`;
+*  - reported awake and the stream is gone — `connection-error`;
+*  - silent past the battery refresh window — `battery-unreachable`.
+*
+* A sleep verdict needs a sleep state that was actually READ. A mirror that
+* was never fed (a restart, a dropped event) is not "asleep": the caller passes
+* `battery: null` and the stream is judged exactly as a mains one (D49 —
+* unknown excludes nothing, and a silent suppression on an unread mirror hid
+* a camera that slept and then died).
+*/
+var OUTAGE_REASONS = [
+	"stale-timeout",
+	"wake-timeout",
+	"connection-error",
+	"battery-unreachable"
+];
+/**
+* How long a demand may wait for a sleeping camera's stream before it counts
+* as a failed wake: the firmware wake bound plus the broker settle window of
+* wake-on-play (8 s + 20 s), with margin for the sweep cadence.
+*/
+var WAKE_DEMAND_BOUND_MS = 45e3;
+function isStreamOutageReason(reason) {
+	return reason !== void 0 && OUTAGE_REASONS.includes(reason);
+}
+function judgeStaleStream(input) {
+	if (input.battery === null) return {
+		kind: "outage",
+		reason: "stale-timeout"
+	};
+	const presence = require_dist.deriveBatteryPresence({
+		status: input.battery.facts,
+		nowMs: input.nowMs
+	});
+	if (presence === "unreachable") return {
+		kind: "outage",
+		reason: "battery-unreachable"
+	};
+	if (presence === "awake") return {
+		kind: "outage",
+		reason: "connection-error"
+	};
+	if (input.demanded) return {
+		kind: "outage",
+		reason: "wake-timeout"
+	};
+	return {
+		kind: "suppressed",
+		presence
+	};
+}
+//#endregion
+//#region src/stream-broker/stream-broker/device-stream-outages.ts
+var DeviceStreamOutages = class {
+	byDevice = /* @__PURE__ */ new Map();
+	get(deviceId) {
+		return this.byDevice.get(deviceId);
+	}
+	/** Open the device's outage, or add this stream to the one already open. */
+	open(deviceId, camStreamId, reason, now) {
+		const existing = this.byDevice.get(deviceId);
+		if (existing) {
+			existing.camStreamIds.add(camStreamId);
+			existing.wakeOnly = false;
+			existing.lastSignalAt = now;
+			return existing;
+		}
+		const created = {
+			reason,
+			since: now,
+			camStreamIds: new Set([camStreamId]),
+			announced: false,
+			wakeOnly: false,
+			lastSignalAt: now
+		};
+		this.byDevice.set(deviceId, created);
+		return created;
+	}
+	/**
+	* A failed wake with no broker to carry it. Joins the device's open outage
+	* (one outage per device) or opens a wake-only one over its REAL streams.
+	*/
+	openWake(deviceId, camStreamIds, reason, now) {
+		const existing = this.byDevice.get(deviceId);
+		if (existing) {
+			existing.lastSignalAt = now;
+			return existing;
+		}
+		const created = {
+			reason,
+			since: now,
+			camStreamIds: new Set(camStreamIds),
+			announced: false,
+			wakeOnly: true,
+			lastSignalAt: now
+		};
+		this.byDevice.set(deviceId, created);
+		return created;
+	}
+	entries() {
+		return this.byDevice.entries();
+	}
+	close(deviceId) {
+		this.byDevice.delete(deviceId);
+	}
+	clear() {
+		this.byDevice.clear();
+	}
+};
+//#endregion
 //#region src/stream-broker/stream-broker/sentry-eligibility.ts
 function sentryEligible(input) {
 	if (input.batteryOperated === null || input.declaresSignals === null) return {
@@ -14555,6 +14680,15 @@ var StreamBroker = class StreamBroker {
 		return false;
 	}
 	/**
+	* Does a consumer want this stream right now (a viewer, a recording, a
+	* detection decode, a camera-reported wake hold)? Sentry sessions and idle
+	* prestream do not count. The stream-health sweep reads it to tell a battery
+	* camera that slept unasked from one that failed to wake for somebody (D883).
+	*/
+	hasLiveDemand() {
+		return this.hasLiveIntent();
+	}
+	/**
 	* True when at least one consumer needs DECODED audio. The audio-specific
 	* subset of {@link hasDemand} — deliberately excludes video-only
 	* consumers so a video-only viewer never spins up the AAC/Opus decode
@@ -17454,6 +17588,10 @@ function resolveBrokerTier(brokerId, localLookup, remoteBrokerTiers) {
 */
 var STREAM_STALE_TIMEOUT_MS = 12e4;
 var STREAM_HEALTH_POLL_MS = 15e3;
+/** How often an unanswered / stale battery probe is asked again. */
+var BATTERY_PROBE_RETRY_MS = 6e4;
+/** A wake-only outage with no further failed wake for this long is over: the demand is gone. */
+var WAKE_ONLY_OUTAGE_TTL_MS = 5 * 6e4;
 /** Compose a SOURCE broker id from a `(deviceId, camStreamId)` tuple. Thin
 *  wrapper over the canonical `makeSourceBrokerId` — single source of truth. */
 function brokerIdFor(deviceId, camStreamId) {
@@ -17646,6 +17784,25 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* guess which one it was looking at.
 	*/
 	streamOfflineReasonByBroker = /* @__PURE__ */ new Map();
+	/**
+	* Brokers whose stream went quiet because their BATTERY camera is asleep.
+	* Not an outage and never announced (D883); remembered so the wake that ends
+	* it is recognised as a plain wake instead of a `recovered`.
+	*/
+	sleepSuppressedBrokers = /* @__PURE__ */ new Set();
+	/**
+	* What the sweep knows of a device's battery: is it one, and what did its
+	* `battery` slice last say. Fed by `BatteryOnStatusChanged` (droppable, empty
+	* after a restart) AND read from the device registry / slice by the sweep
+	* itself — the same two reads wake-on-play makes — so a restart or a lost
+	* event never leaves the verdict standing on an unread mirror (D49).
+	*/
+	batteryProbe = /* @__PURE__ */ new Map();
+	batteryProbeInFlight = /* @__PURE__ */ new Set();
+	/** When a consumer's demand on a quiet battery stream was first seen (the wake bound starts there). */
+	demandSince = /* @__PURE__ */ new Map();
+	/** The stream outage a DEVICE is in (one entry per device, however many profiles). */
+	deviceOutages = new DeviceStreamOutages();
 	streamHealthTimer;
 	/**
 	* Routes an audio-chunk `subscriptionId` (Phase 5 / D9) back to its owning
@@ -18586,6 +18743,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			const deviceId = typeof data.deviceId === "number" ? data.deviceId : null;
 			if (deviceId === null) return;
 			const sleeping = data.status?.sleeping === true;
+			this.recordBatterySleep(deviceId, data.status);
 			this.applyPlaceholderReasonToDevice(deviceId, sleeping ? "sleeping" : "reconnecting");
 		});
 		bus.subscribe({ category: require_dist.EventCategory.BatteryOnWakeStarted }, (event) => {
@@ -18749,18 +18907,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		await this.batteryWakeOnPlay.run(deviceId, {
 			logger: this.logger,
 			isBatteryDevice: (id) => this.isBatteryOperated(id),
-			readBatteryFacts: async (id) => {
-				const slice = await api.deviceState.getCapSlice.query({
-					deviceId: id,
-					capName: require_dist.batteryCapability.name
-				}).catch(() => null);
-				const parsed = require_dist.BatteryStatusSchema.safeParse(slice);
-				if (!parsed.success) return null;
-				return {
-					sleeping: parsed.data.sleeping,
-					lastContactAt: parsed.data.lastContactAt
-				};
-			},
+			readBatteryFacts: (id) => this.readBatterySleepFacts(id),
 			wakeForStream: async (id, timeoutMs) => api.battery.wakeForStream.mutate({
 				deviceId: id,
 				timeoutMs
@@ -18768,6 +18915,9 @@ var StreamBrokerManager = class StreamBrokerManager {
 			reconcileCatalog: (id) => this.reconcileDeviceCatalog(id),
 			ensureBroker: () => this.ensureBrokerForWebrtcSession(deviceId, brokerId, camStreamId),
 			hasBroker: demandHasBroker
+		}).catch((err) => {
+			if (err instanceof BatteryStreamUnavailableError) this.announceBatteryWakeFailure(deviceId, camStreamId, err.presence === "unreachable" ? "battery-unreachable" : "wake-timeout");
+			throw err;
 		});
 	}
 	/** Any broker (local or remote-adapter) registered for this device? The
@@ -20391,6 +20541,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		this.brokers.clear();
 		this.streamHealthByBroker.clear();
 		this.streamOfflineReasonByBroker.clear();
+		this.sleepSuppressedBrokers.clear();
+		this.batteryProbe.clear();
+		this.demandSince.clear();
+		this.deviceOutages.clear();
 		this.audioSubscriptionBroker.clear();
 		await this.rtspServer.stop();
 	}
@@ -20413,6 +20567,8 @@ var StreamBrokerManager = class StreamBrokerManager {
 	evaluateStreamHealth() {
 		if (!this.eventBus) return;
 		const now = Date.now();
+		const outageOpenedOn = /* @__PURE__ */ new Map();
+		const cameBackOn = /* @__PURE__ */ new Map();
 		for (const [brokerId, broker] of this.brokers) {
 			const parsed = this.parseBrokerId(brokerId);
 			if (!parsed) continue;
@@ -20422,30 +20578,386 @@ var StreamBrokerManager = class StreamBrokerManager {
 			const wasHealthy = this.streamHealthByBroker.get(brokerId);
 			const isHealthy = lastPacketAt > 0 && now - lastPacketAt <= STREAM_STALE_TIMEOUT_MS;
 			if (!isHealthy && broker.getStats().status === "streaming") broker.redial("stream-health sweep: phantom streaming, no packets within stale window");
-			if (wasHealthy === isHealthy) continue;
+			const context = {
+				deviceId,
+				camStreamId,
+				brokerId,
+				sourceType: broker.getActiveSourceType(),
+				lastPacketAt
+			};
+			if (wasHealthy === isHealthy) {
+				if (!isHealthy) this.rejudgeQuietBroker(brokerId, broker, context, now, outageOpenedOn);
+				continue;
+			}
 			if (wasHealthy === void 0 && !isHealthy && !broker.suspended) {
 				this.streamHealthByBroker.set(brokerId, false);
 				continue;
 			}
+			let verdict = null;
+			if (!isHealthy && !broker.suspended) {
+				verdict = this.judgeQuietStream(brokerId, deviceId, broker, now);
+				if (verdict === "defer") continue;
+			}
 			this.streamHealthByBroker.set(brokerId, isHealthy);
-			const reason = isHealthy ? wasHealthy === void 0 || !this.streamOfflineReasonByBroker.has(brokerId) ? "first-packet" : this.streamOfflineReasonByBroker.get(brokerId) === "suspended" ? "resumed" : "recovered" : broker.suspended ? "suspended" : "stale-timeout";
-			if (isHealthy) this.streamOfflineReasonByBroker.delete(brokerId);
-			else this.streamOfflineReasonByBroker.set(brokerId, reason);
-			this.emitStreamHealth(isHealthy, {
+			const wasSleepSuppressed = this.sleepSuppressedBrokers.delete(brokerId);
+			const previousReason = this.streamOfflineReasonByBroker.get(brokerId);
+			if (verdict !== null) {
+				if (verdict.kind === "suppressed") {
+					this.markSleepSuppressed(brokerId, context, verdict.presence, lastPacketAt);
+					continue;
+				}
+				this.openStreamOutage(brokerId, context, verdict.reason, now, outageOpenedOn);
+				continue;
+			}
+			if (!isHealthy) {
+				this.demandSince.delete(brokerId);
+				this.streamOfflineReasonByBroker.set(brokerId, "suspended");
+				this.emitStreamHealth(false, {
+					...context,
+					reason: "suspended"
+				});
+				continue;
+			}
+			this.streamOfflineReasonByBroker.delete(brokerId);
+			this.demandSince.delete(brokerId);
+			if (wasSleepSuppressed) this.logger.info("battery camera woke and delivers a stream — plain wake, no event", {
+				tags: { deviceId },
+				meta: { camStreamId }
+			});
+			if (this.deviceOutages.get(deviceId) !== void 0) {
+				if (!cameBackOn.has(deviceId)) cameBackOn.set(deviceId, context);
+				continue;
+			}
+			if (wasSleepSuppressed) {
+				this.writeCameraStreamsSlice(deviceId, this.snapshotProfileSlots(deviceId));
+				continue;
+			}
+			const reason = isStreamOutageReason(previousReason) ? "recovered" : previousReason === "suspended" ? "resumed" : "first-packet";
+			this.emitStreamHealth(true, {
+				...context,
+				reason
+			});
+		}
+		for (const [deviceId, context] of outageOpenedOn) this.announceDeviceOutage(deviceId, context);
+		for (const [deviceId, context] of cameBackOn) this.settleDeviceOutage(deviceId, context);
+		this.expireWakeOnlyOutages(now);
+	}
+	/** Record one stream as part of its device's outage (announced after the pass). */
+	openStreamOutage(brokerId, context, reason, now, outageOpenedOn) {
+		this.sleepSuppressedBrokers.delete(brokerId);
+		this.streamOfflineReasonByBroker.set(brokerId, reason);
+		this.deviceOutages.open(context.deviceId, context.camStreamId, reason, now);
+		if (!outageOpenedOn.has(context.deviceId)) outageOpenedOn.set(context.deviceId, context);
+	}
+	markSleepSuppressed(brokerId, context, presence, lastPacketAt) {
+		this.sleepSuppressedBrokers.add(brokerId);
+		this.streamOfflineReasonByBroker.delete(brokerId);
+		this.logger.info("stream quiet on a sleeping battery camera — not an outage", {
+			tags: { deviceId: context.deviceId },
+			meta: {
+				camStreamId: context.camStreamId,
+				presence,
+				lastPacketAt
+			}
+		});
+		this.writeCameraStreamsSlice(context.deviceId, this.snapshotProfileSlots(context.deviceId));
+	}
+	/**
+	* The verdict on a quiet, non-idle stream. `'defer'` = the device's battery
+	* class is still being asked of the registry; the edge is kept and judged
+	* again. A class that could not be answered, or a slice never read, judges as
+	* a mains camera — never as a sleeper (D49).
+	*/
+	judgeQuietStream(brokerId, deviceId, broker, now) {
+		const probe = this.ensureBatteryProbe(deviceId, now);
+		if (probe.state === "pending") return "defer";
+		return judgeStaleStream({
+			battery: probe.isBattery === true && probe.facts !== null ? { facts: probe.facts } : null,
+			demanded: this.demandHeldPastBound(brokerId, broker, now),
+			nowMs: now
+		});
+	}
+	demandHeldPastBound(brokerId, broker, now) {
+		if (!broker.hasLiveDemand()) {
+			this.demandSince.delete(brokerId);
+			return false;
+		}
+		const since = this.demandSince.get(brokerId) ?? now;
+		this.demandSince.set(brokerId, since);
+		return now - since >= WAKE_DEMAND_BOUND_MS;
+	}
+	/**
+	* A broker that stays quiet, pass after pass. Three things can be true of it:
+	* it was suppressed as a sleeper (the camera may have died, or a wake may
+	* have been demanded since); it went idle while holding an outage open; or it
+	* resumed from an idle suspend on a battery camera that never answered.
+	*/
+	rejudgeQuietBroker(brokerId, broker, context, now, outageOpenedOn) {
+		const { deviceId } = context;
+		const reason = this.streamOfflineReasonByBroker.get(brokerId);
+		if (isStreamOutageReason(reason) && broker.suspended) {
+			this.dropSuspendedOutage(brokerId, context);
+			return;
+		}
+		const suppressed = this.sleepSuppressedBrokers.has(brokerId);
+		const resumedQuiet = reason === "suspended" && !broker.suspended;
+		if (!suppressed && !resumedQuiet) return;
+		if (broker.suspended) {
+			this.demandSince.delete(brokerId);
+			return;
+		}
+		this.refreshBatteryFactsIfDue(deviceId, now);
+		const probe = this.batteryProbe.get(deviceId);
+		if (probe?.state !== "done" || probe.isBattery !== true || probe.facts === null) return;
+		const verdict = judgeStaleStream({
+			battery: { facts: probe.facts },
+			demanded: this.demandHeldPastBound(brokerId, broker, now),
+			nowMs: now
+		});
+		if (verdict.kind === "suppressed") return;
+		this.logger.warn("quiet battery stream is now an outage", {
+			tags: { deviceId },
+			meta: {
+				camStreamId: context.camStreamId,
+				reason: verdict.reason
+			}
+		});
+		this.openStreamOutage(brokerId, context, verdict.reason, now, outageOpenedOn);
+	}
+	/**
+	* An outage stream whose last consumer left (the broker went idle). Nobody is
+	* waiting for it any more, so the outage ends there — closed cleanly, with
+	* the one online that lets every consumer clear its row (reason `suspended`,
+	* which the notification gate discards).
+	*/
+	dropSuspendedOutage(brokerId, context) {
+		const { deviceId, camStreamId } = context;
+		this.demandSince.delete(brokerId);
+		this.streamOfflineReasonByBroker.set(brokerId, "suspended");
+		const outage = this.deviceOutages.get(deviceId);
+		this.logger.info("stream outage dropped — the broker went idle, nobody is waiting", {
+			tags: { deviceId },
+			meta: { camStreamId }
+		});
+		if (!outage) return;
+		outage.camStreamIds.delete(camStreamId);
+		if (outage.camStreamIds.size > 0 || outage.wakeOnly) return;
+		this.closeDeviceOutage(deviceId, outage, "suspended", context);
+	}
+	/** Close a device outage and, when it was announced, say so once (any online closes the rows). */
+	closeDeviceOutage(deviceId, outage, reason, context) {
+		this.deviceOutages.close(deviceId);
+		if (!outage.announced) return;
+		this.emitDeviceStreamHealth(true, deviceId, reason, /* @__PURE__ */ new Set(), context);
+	}
+	/** Wake-only outages end when the failed wakes stop (demand released). */
+	expireWakeOnlyOutages(now) {
+		for (const [deviceId, outage] of [...this.deviceOutages.entries()]) {
+			if (!outage.wakeOnly || now - outage.lastSignalAt < WAKE_ONLY_OUTAGE_TTL_MS) continue;
+			this.logger.info("wake failure outage ended — no further demand", {
+				tags: { deviceId },
+				meta: { reason: outage.reason }
+			});
+			this.closeDeviceOutage(deviceId, outage, "suspended", {
 				deviceId,
+				brokerId: String(deviceId),
+				sourceType: "battery-wake",
+				lastPacketAt: 0
+			});
+		}
+	}
+	/** The device's battery probe; starts the read when there is none (or a retry is due). */
+	ensureBatteryProbe(deviceId, now) {
+		const existing = this.batteryProbe.get(deviceId);
+		if (existing === void 0) {
+			if (!this.api) {
+				const none = {
+					state: "done",
+					isBattery: null,
+					facts: null,
+					readAt: now
+				};
+				this.batteryProbe.set(deviceId, none);
+				return none;
+			}
+			const pending = {
+				state: "pending",
+				isBattery: null,
+				facts: null,
+				readAt: now
+			};
+			this.batteryProbe.set(deviceId, pending);
+			this.probeBattery(deviceId);
+			return pending;
+		}
+		if (existing.state === "done" && existing.isBattery === null && this.api && now - existing.readAt >= BATTERY_PROBE_RETRY_MS && !this.batteryProbeInFlight.has(deviceId)) this.probeBattery(deviceId);
+		return existing;
+	}
+	async probeBattery(deviceId) {
+		this.batteryProbeInFlight.add(deviceId);
+		try {
+			const isBattery = await this.isBatteryOperated(deviceId);
+			const facts = isBattery === true ? await this.readBatterySleepFacts(deviceId) : null;
+			const current = this.batteryProbe.get(deviceId);
+			this.batteryProbe.set(deviceId, {
+				state: "done",
+				isBattery: current?.isBattery === true ? true : isBattery,
+				facts: current?.facts ?? facts,
+				readAt: Date.now()
+			});
+		} finally {
+			this.batteryProbeInFlight.delete(deviceId);
+		}
+	}
+	refreshBatteryFactsIfDue(deviceId, now) {
+		const probe = this.batteryProbe.get(deviceId);
+		if (probe?.state !== "done" || probe.isBattery !== true) return;
+		if (now - probe.readAt < BATTERY_PROBE_RETRY_MS || this.batteryProbeInFlight.has(deviceId)) return;
+		this.batteryProbeInFlight.add(deviceId);
+		this.readBatterySleepFacts(deviceId).then((facts) => {
+			const current = this.batteryProbe.get(deviceId);
+			this.batteryProbe.set(deviceId, {
+				state: "done",
+				isBattery: true,
+				facts: facts ?? current?.facts ?? null,
+				readAt: Date.now()
+			});
+		}).finally(() => this.batteryProbeInFlight.delete(deviceId));
+	}
+	/** The device's `battery` slice as sleep facts, or `null` when it cannot be read. */
+	async readBatterySleepFacts(deviceId) {
+		const api = this.api;
+		if (!api) return null;
+		const slice = await api.deviceState.getCapSlice.query({
+			deviceId,
+			capName: require_dist.batteryCapability.name
+		}).catch(() => null);
+		const parsed = require_dist.BatteryStatusSchema.safeParse(slice);
+		if (!parsed.success) return null;
+		return {
+			sleeping: parsed.data.sleeping,
+			lastContactAt: parsed.data.lastContactAt
+		};
+	}
+	recordBatterySleep(deviceId, status) {
+		const previous = this.batteryProbe.get(deviceId);
+		const facts = status && typeof status.sleeping === "boolean" ? {
+			sleeping: status.sleeping,
+			...typeof status.lastContactAt === "number" ? { lastContactAt: status.lastContactAt } : {}
+		} : null;
+		this.batteryProbe.set(deviceId, {
+			state: "done",
+			isBattery: true,
+			facts: facts ?? previous?.facts ?? null,
+			readAt: Date.now()
+		});
+	}
+	/**
+	* A released broker can no longer carry an outage. When it was the last
+	* stream holding an ANNOUNCED outage open, the outage is closed with an
+	* online (`broker-destroyed`, which the notification gate discards but every
+	* ledger and alert card clears on) — otherwise the row stays open for ever.
+	*/
+	forgetReleasedStreamOutage(context) {
+		const { deviceId, camStreamId } = context;
+		const outage = this.deviceOutages.get(deviceId);
+		if (!outage || !outage.camStreamIds.delete(camStreamId)) return;
+		if (outage.camStreamIds.size > 0) return;
+		this.logger.info("stream outage closed — its last stream was released", {
+			tags: { deviceId },
+			meta: {
+				reason: outage.reason,
 				camStreamId,
-				profile: findProfileForStream(this.assignments.get(deviceId)?.map ?? {}, camStreamId),
-				brokerId,
-				sourceType: broker.getActiveSourceType(),
-				lastPacketAt,
-				reason
+				announced: outage.announced
+			}
+		});
+		this.closeDeviceOutage(deviceId, outage, "broker-destroyed", context);
+	}
+	/** The ONE `stream.offline` of a device outage, naming every stream it covers. */
+	announceDeviceOutage(deviceId, context) {
+		const outage = this.deviceOutages.get(deviceId);
+		if (!outage) return;
+		if (outage.announced) {
+			this.logger.debug("stream outage joined an already announced one — no second event", {
+				tags: { deviceId },
+				meta: {
+					camStreamIds: [...outage.camStreamIds],
+					reason: outage.reason
+				}
 			});
+			return;
+		}
+		outage.announced = true;
+		this.logger.warn("stream outage", {
+			tags: { deviceId },
+			meta: {
+				reason: outage.reason,
+				camStreamIds: [...outage.camStreamIds]
+			}
+		});
+		this.emitDeviceStreamHealth(false, deviceId, outage.reason, outage.camStreamIds, context);
+	}
+	/**
+	* A broker of a device in outage is delivering again. The device is back when
+	* no stream of it is still down for an outage reason; then, and only then,
+	* the single `stream.online` (`recovered`) goes out.
+	*/
+	settleDeviceOutage(deviceId, context) {
+		const outage = this.deviceOutages.get(deviceId);
+		if (!outage) return;
+		for (const camStreamId of [...outage.camStreamIds]) {
+			const brokerId = brokerIdFor(deviceId, camStreamId);
+			if (!isStreamOutageReason(this.streamOfflineReasonByBroker.get(brokerId))) outage.camStreamIds.delete(camStreamId);
 		}
+		if (outage.camStreamIds.size > 0) return;
+		this.deviceOutages.close(deviceId);
+		if (!outage.announced) return;
+		this.logger.info("stream outage over — device delivers again", {
+			tags: { deviceId },
+			meta: {
+				reason: outage.reason,
+				outageMs: Date.now() - outage.since
+			}
+		});
+		this.emitDeviceStreamHealth(true, deviceId, "recovered", new Set(context.camStreamId !== void 0 ? [context.camStreamId] : []), context);
+	}
+	/**
+	* A wake somebody ASKED for did not produce a stream (the viewer's play
+	* button, found no broker and a wake that settled nothing). This is the one
+	* failure with no broker to carry it, so it opens the device outage itself.
+	*/
+	announceBatteryWakeFailure(deviceId, camStreamId, reason) {
+		if (!this.eventBus) return;
+		const published = [...this.cameraStreams.get(deviceId)?.keys() ?? []];
+		const streamIds = camStreamId !== void 0 && published.includes(camStreamId) ? [camStreamId] : published;
+		this.deviceOutages.openWake(deviceId, streamIds, reason, Date.now());
+		this.announceDeviceOutage(deviceId, {
+			deviceId,
+			...streamIds[0] !== void 0 ? { camStreamId: streamIds[0] } : {},
+			brokerId: streamIds[0] !== void 0 ? brokerIdFor(deviceId, streamIds[0]) : String(deviceId),
+			sourceType: "battery-wake",
+			lastPacketAt: 0
+		});
+	}
+	emitDeviceStreamHealth(online, deviceId, reason, camStreamIds, context) {
+		const ids = [...camStreamIds];
+		const first = ids[0] ?? context.camStreamId;
+		const assignments = this.assignments.get(deviceId)?.map ?? {};
+		this.emitStreamHealth(online, {
+			...context,
+			deviceId,
+			...first !== void 0 ? { camStreamId: first } : {},
+			brokerId: first !== void 0 ? brokerIdFor(deviceId, first) : context.brokerId,
+			profile: first !== void 0 ? findProfileForStream(assignments, first) : null,
+			reason,
+			camStreamIds: ids
+		});
 	}
 	emitStreamHealth(online, payload) {
 		const bus = this.eventBus;
 		if (!bus) return;
 		const category = online ? "stream.online" : "stream.offline";
+		const profile = payload.profile !== void 0 ? payload.profile : payload.camStreamId !== void 0 ? findProfileForStream(this.assignments.get(payload.deviceId)?.map ?? {}, payload.camStreamId) : null;
 		bus.emit({
 			id: `${category}-${payload.brokerId}-${Date.now()}`,
 			timestamp: /* @__PURE__ */ new Date(),
@@ -20454,7 +20966,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 				type: "stream-broker",
 				id: payload.brokerId
 			},
-			data: payload
+			data: {
+				...payload,
+				profile
+			}
 		});
 		this.writeCameraStreamsSlice(payload.deviceId, this.snapshotProfileSlots(payload.deviceId));
 	}
@@ -22270,6 +22785,14 @@ var StreamBrokerManager = class StreamBrokerManager {
 		});
 		this.streamHealthByBroker.delete(brokerId);
 		this.streamOfflineReasonByBroker.delete(brokerId);
+		this.sleepSuppressedBrokers.delete(brokerId);
+		this.forgetReleasedStreamOutage({
+			deviceId,
+			camStreamId,
+			brokerId,
+			sourceType: broker.getActiveSourceType(),
+			lastPacketAt: broker.getLastPacketAt()
+		});
 		await broker.stop();
 		this.brokers.delete(brokerId);
 		this.sentryFrames.delete(brokerId);