@camstack/addon-provider-homeassistant 1.2.42 → 1.2.44

package/dist/ha-export/ha-export.addon.mjs

@@ -1,4 +1,4 @@
-import { M as deviceExportCapability, Ot as EventCategory, S as buildAddonRouteProvider, Y as oauthIntegrationCapability, a as CameraSwitchIdSchema, c as HvacModeSchema, f as addonRoutesCapability, ft as BaseAddon, i as COCO_TO_MACRO, l as MediaPlayerRepeatSchema, s as FanDirectionSchema, t as AlarmArmModeSchema, wt as string } from "../dist-DolpU5X1.mjs";
+import { At as EventCategory, C as buildAddonRouteProvider, Et as string, N as deviceExportCapability, X as oauthIntegrationCapability, a as COCO_TO_MACRO, c as FanDirectionSchema, i as CAMERA_SWITCH_ORDER, l as HvacModeSchema, o as CameraSwitchIdSchema, p as addonRoutesCapability, pt as BaseAddon, t as AlarmArmModeSchema, u as MediaPlayerRepeatSchema, vt as nodePin } from "../dist-BjB1J9mO.mjs";
 import { createHmac, timingSafeEqual } from "node:crypto";
 //#region src/ha-export/topics.ts
 /**
@@ -1252,9 +1252,14 @@ function cameraSpecs(device) {
 		}),
 		(
 		/**
-		* What was heard, and how loud. Fed by `pipeline.audio-inference-result`
-		* — the event this addon did not subscribe to at all, which is why
-		* `audio_detected` below has effectively never moved.
+		* What was heard, and how loud. Both fed by `pipeline.audio-inference-result`
+		* via `projectAudioWindow` — which is also where `audio_detected` (the
+		* `audio` row of the macro loop below) gets its value now. Until this was
+		* fixed, `audio_detected` was fed only by the track lifecycle, which
+		* almost never carries an audio macro, so the entity existed and
+		* effectively never moved: a comment right here used to claim this window
+		* was already its source, and it was not — an avanzo that described the
+		* right design while being false.
 		*
 		* `audio_last_sound`, NOT `audio_last_label`: `<macro>_last_label` is the
 		* TRACK path's naming, reserved for the macros that carry an
@@ -1333,8 +1338,10 @@ function cameraSpecs(device) {
 		enabledByDefault: false
 	});
 	/**
-	* One HA switch per AVAILABLE camera switch, rendered from
-	* `getCameraSwitches` and commanded back through `setCameraSwitch`.
+	* One HA switch per AVAILABLE camera function, rendered from
+	* `deriveCameraFunctions` and commanded back through
+	* `resolveCameraFunctionWrite` + `applyCameraFunctionWrite` — each straight
+	* onto the authority that already owns it (D62, D113 phase 4).
 	*
 	* The export never writes an authority itself: a second knob that can
 	* disagree with the admin UI is worse than no knob (D62). An
@@ -1430,6 +1437,30 @@ function cameraSpecs(device) {
 		entityCategory: "diagnostic",
 		enabledByDefault: false
 	});
+	/**
+	* `status` — the entity D62 exists for outside this repo. A camera an
+	* operator switched off must never paint the same picture in Home
+	* Assistant as one that is genuinely broken (`projectCameraStatus`).
+	*
+	* No `device_class`: HA's `enum` device class demands `options`, and a
+	* `select` here would be a control that cannot be written — the dead
+	* control this whole export refuses to ship.
+	*/
+	specs.push({
+		entity: "status",
+		platform: "sensor",
+		label: "Status",
+		icon: "mdi:cctv",
+		enabledByDefault: true
+	});
+	/** «Is it recording right now?» — `CameraStatus.recording.active`. */
+	specs.push({
+		entity: "recording_active",
+		platform: "binary_sensor",
+		label: "Recording",
+		deviceClass: "running",
+		enabledByDefault: true
+	});
 	specs.push({
 		entity: "snooze",
 		platform: "select",
@@ -2687,7 +2718,7 @@ var CAPS_NOT_EXPORTED = [
 	},
 	{
 		cap: "privacy-mask",
-		reason: "Rendered as a camera switch through getCameraSwitches, never written directly (D62)."
+		reason: "Rendered as two camera function switches (privacy-mask, device-audio) through deriveCameraFunctions, never written directly (D62, D113 phase 4)."
 	},
 	{
 		cap: "zone-analytics",
@@ -2943,17 +2974,8 @@ function buildDevicePlan(device, options = UNNEGOTIATED_PLAN_OPTIONS) {
 * refusal carries a named reason so the log line says which of those it
 * was.
 */
-/** The camera switch ids, keyed by the entity slug the catalog emits. */
-var CAMERA_SWITCH_BY_SLUG = Object.fromEntries([
-	"stream-broker",
-	"object-detection",
-	"privacy-mask",
-	"device-audio",
-	"broker-audio",
-	"audio-analysis",
-	"recording",
-	"notifications"
-].map((id) => [toSlug(id), id]));
+/** The camera function ids, keyed by the entity slug the catalog emits. */
+var CAMERA_SWITCH_BY_SLUG = Object.fromEntries(CAMERA_SWITCH_ORDER.map((id) => [toSlug(id), id]));
 var PTZ_DIRECTION_BY_ENTITY = Object.fromEntries(PTZ_BUTTONS.map((entity) => [entity, entity.slice(4)]));
 function parseBool(value) {
 	const lower = value.trim().toLowerCase();
@@ -3538,7 +3560,7 @@ function resolveCommand(target, entity, value) {
 			return {
 				ok: true,
 				command: {
-					kind: "camera-switch",
+					kind: "camera-function",
 					deviceId: target.deviceId,
 					switchId,
 					enabled
@@ -3698,7 +3720,7 @@ function build(builder, deviceId, value, capName) {
 */
 function isCameraCommand(command) {
 	switch (command.kind) {
-		case "camera-switch":
+		case "camera-function":
 		case "reboot":
 		case "ptz-move":
 		case "ptz-preset":
@@ -3937,6 +3959,187 @@ async function call(slice, capName, make) {
 	}
 	return { ok: true };
 }
+//#endregion
+//#region src/ha-export/camera-function-writes.ts
+/**
+* Esegue la SCRITTURA di una funzione camera sull'autorità che la possiede.
+*
+* `deriveCameraFunctions`/`resolveCameraFunctionWrite` (`camera-functions.ts`)
+* decidono; questo modulo agisce. È il file che
+* `scripts/check-switch-successor-surfaces.ts` punta come successore della
+* coppia deprecata `getCameraSwitches` / `setCameraSwitch` (D113 fase 4).
+*/
+async function applyCameraFunctionWrite(api, deviceId, write, sourceNodeId) {
+	switch (write.kind) {
+		case "device-disabled":
+			await api.deviceManager.setDisabled.mutate({
+				deviceId,
+				disabled: write.disabled
+			});
+			return;
+		case "wrapper-binding":
+			await api.deviceManager.setWrapperActive.mutate({
+				deviceId,
+				capName: write.capName,
+				wrapperAddonId: write.wrapperAddonId,
+				active: write.active
+			});
+			return;
+		case "recording-enabled": {
+			const config = await api.recording.getDeviceConfig.query({ deviceId });
+			await api.recording.setDeviceConfig.mutate({
+				deviceId,
+				config: {
+					...config,
+					enabled: write.enabled
+				}
+			});
+			return;
+		}
+		case "notification-mute":
+			await api.notificationRules.setDeviceMuted.mutate({
+				deviceId,
+				muted: write.muted
+			});
+			return;
+		case "camera-mask":
+			await api.privacyMask.setMask.mutate({
+				deviceId,
+				patch: { enabled: write.enabled }
+			});
+			return;
+		case "camera-audio":
+			await api.privacyMask.setAudioEnabled.mutate({
+				deviceId,
+				enabled: write.enabled
+			});
+			return;
+		case "broker-audio-mute":
+			if (sourceNodeId === null) throw new Error(`refusing an unrouted broker audio write for device ${String(deviceId)}: no source node`);
+			await api.streamBroker.setDeviceAudioMute.mutate({
+				deviceId,
+				muted: write.muted
+			}, nodePin(sourceNodeId));
+			return;
+	}
+}
+//#endregion
+//#region src/ha-export/camera-functions.ts
+var DETECTION_CAP = "detection-pipeline";
+var AUDIO_ANALYSIS_CAP = "audio-analysis";
+/** Ordine di resa: raggio d'azione più ampio prima, sorgente prima del consumatore. */
+var ORDER = [
+	"stream-broker",
+	"object-detection",
+	"privacy-mask",
+	"device-audio",
+	"broker-audio",
+	"audio-analysis",
+	"recording",
+	"notifications"
+];
+var LABELS = {
+	"stream-broker": "Camera",
+	"object-detection": "Object detection & tracking",
+	"privacy-mask": "Privacy mask",
+	"device-audio": "Camera microphone",
+	"broker-audio": "Audio distribution",
+	"audio-analysis": "Audio detection & classification",
+	recording: "Recording",
+	notifications: "Notifications"
+};
+var UNAVAILABLE = {
+	available: false,
+	enabled: true
+};
+function resolveWrapper(capName, reads) {
+	if (reads.bindableCapNames === null || reads.wrappedCapNames === null) return UNAVAILABLE;
+	if (!reads.bindableCapNames.includes(capName)) return UNAVAILABLE;
+	if (reads.wrapperAddonIdByCap.get(capName) === void 0) return UNAVAILABLE;
+	return {
+		available: true,
+		enabled: reads.wrappedCapNames.includes(capName)
+	};
+}
+function resolveOne(id, reads) {
+	switch (id) {
+		case "stream-broker": return reads.deviceDisabled === null ? UNAVAILABLE : {
+			available: true,
+			enabled: !reads.deviceDisabled
+		};
+		case "object-detection": return resolveWrapper(DETECTION_CAP, reads);
+		case "audio-analysis": return resolveWrapper(AUDIO_ANALYSIS_CAP, reads);
+		case "recording": return reads.recordingEnabled === null ? UNAVAILABLE : {
+			available: true,
+			enabled: reads.recordingEnabled
+		};
+		case "notifications": return reads.notificationsMuted === null ? UNAVAILABLE : {
+			available: true,
+			enabled: !reads.notificationsMuted
+		};
+		case "privacy-mask": return reads.privacy === null ? UNAVAILABLE : {
+			available: true,
+			enabled: reads.privacy.maskEnabled
+		};
+		case "device-audio": return reads.privacy === null || reads.privacy.audioEnabled === null ? UNAVAILABLE : {
+			available: true,
+			enabled: reads.privacy.audioEnabled
+		};
+		case "broker-audio": return reads.brokerAudioMuted === null ? UNAVAILABLE : {
+			available: true,
+			enabled: !reads.brokerAudioMuted
+		};
+	}
+}
+function deriveCameraFunctions(reads) {
+	return ORDER.map((id) => ({
+		id,
+		label: LABELS[id],
+		...resolveOne(id, reads)
+	}));
+}
+/** `null` = non disponibile: la scrittura va RIFIUTATA, non approssimata. */
+function resolveCameraFunctionWrite(id, on, reads) {
+	if (!resolveOne(id, reads).available) return null;
+	switch (id) {
+		case "stream-broker": return {
+			kind: "device-disabled",
+			disabled: !on
+		};
+		case "object-detection":
+		case "audio-analysis": {
+			const capName = id === "object-detection" ? DETECTION_CAP : AUDIO_ANALYSIS_CAP;
+			const wrapperAddonId = reads.wrapperAddonIdByCap.get(capName);
+			if (wrapperAddonId === void 0) return null;
+			return {
+				kind: "wrapper-binding",
+				capName,
+				wrapperAddonId,
+				active: on
+			};
+		}
+		case "recording": return {
+			kind: "recording-enabled",
+			enabled: on
+		};
+		case "notifications": return {
+			kind: "notification-mute",
+			muted: !on
+		};
+		case "privacy-mask": return {
+			kind: "camera-mask",
+			enabled: on
+		};
+		case "device-audio": return {
+			kind: "camera-audio",
+			enabled: on
+		};
+		case "broker-audio": return {
+			kind: "broker-audio-mute",
+			muted: !on
+		};
+	}
+}
 /**
 * The ONE derivation of "a signed, expiring URL".
 *
@@ -4682,16 +4885,18 @@ function projectBatterySlice(deviceKey, slice) {
 }
 /**
 * The per-camera function switches, mirrored 1:1 from
-* `pipelineOrchestrator.getCameraSwitches`.
+* `deriveCameraFunctions` (`camera-functions.ts`) — the pure derivation over
+* the AUTHORITIES that own each function, replacing the deprecated
+* `pipelineOrchestrator.getCameraSwitches` group (D113 phase 4).
 *
-* An UNAVAILABLE switch publishes nothing, because `enabled` is
+* An UNAVAILABLE function publishes nothing, because `enabled` is
 * meaningless when `available` is false — a source that did not answer
 * must never become a control rendered `on`.
 */
-function projectCameraSwitches(deviceKey, switches) {
-	return switches.filter((sw) => sw.available).map((sw) => ({
-		topic: stateTopic(deviceKey, toSlug(sw.id)),
-		value: bool(sw.enabled)
+function projectCameraFunctions(deviceKey, functions) {
+	return functions.filter((fn) => fn.available).map((fn) => ({
+		topic: stateTopic(deviceKey, toSlug(fn.id)),
+		value: bool(fn.enabled)
 	}));
 }
 /**
@@ -4757,12 +4962,88 @@ function projectAudioWindow(deviceKey, input) {
 		value: String(Math.round(input.rms * 1e4) / 1e4)
 	});
 	const best = input.detections.reduce((top, d) => top === null || d.confidence > top.confidence ? d : top, null);
+	/**
+	* `audio_detected` — the source it never had. The catalog's comment used
+	* to claim this window was already feeding it; it was not (grep found no
+	* publisher), and that comment was a leftover describing the right design
+	* while being false. This window is the fix: it raises on any window that
+	* carries a classification and lowers on a quiet one, WITHOUT clearing
+	* `audio_last_sound` — "what was that noise" is asked after the noise has
+	* stopped.
+	*/
+	values.push({
+		topic: stateTopic(deviceKey, "audio_detected"),
+		value: bool(best !== null)
+	});
 	if (best !== null) values.push({
 		topic: stateTopic(deviceKey, "audio_last_sound"),
 		value: best.className
 	});
 	return values;
 }
+/** Inverse of `SNOOZE_MINUTES` — a minute count back to the option label. */
+var SNOOZE_OPTION_BY_MINUTES = new Map(Object.entries(SNOOZE_MINUTES).map(([option, minutes]) => [minutes, option]));
+/**
+* The `snooze` select's STATE. The authority is
+* `notificationRules.listSnoozes`, which carries `startedAt`/`expiresAt` but
+* not the preset label an operator picked — there is nowhere to store that
+* label, and there must not be: it is reconstructed from the two timestamps
+* every time, so it can never drift from the authority.
+*
+* No active snooze publishes `Off`, never silence: Home Assistant reads a
+* missing state update as "the last value still holds", so a select gone
+* quiet after a snooze expires would keep showing the expired duration
+* forever.
+*
+* A duration the select's closed vocabulary cannot express — a snooze the
+* viewer created with an arbitrary minute count — publishes NOTHING.
+* Rounding it to the nearest preset would let Home Assistant re-send a
+* duration the operator never chose; `unknown` is the honest state.
+*/
+function projectSnooze(deviceKey, window) {
+	if (window === null) return [{
+		topic: stateTopic(deviceKey, "snooze"),
+		value: "Off"
+	}];
+	const minutes = Math.round((window.expiresAt - window.startedAt) / 6e4);
+	const option = SNOOZE_OPTION_BY_MINUTES.get(minutes);
+	if (option === void 0) return [];
+	return [{
+		topic: stateTopic(deviceKey, "snooze"),
+		value: option
+	}];
+}
+/**
+* `status` — the entity D62 exists for. A camera an operator switched off and
+* a camera that is genuinely broken must never paint the same picture in Home
+* Assistant: this is what tells the two apart.
+*
+* Order matters: the `switches` stage failing to answer makes the WHOLE
+* badge unknown, because an empty `switchedOff` is only a positive claim when
+* `degraded` does not name `switches` — reporting `ok` here would be the D62
+* failure landing inside the very field written to prevent it.
+*/
+function projectCameraStatus(deviceKey, input) {
+	const values = [{
+		topic: stateTopic(deviceKey, "status"),
+		value: cameraStatusToken(input)
+	}];
+	if (input.recording !== null) values.push({
+		topic: stateTopic(deviceKey, "recording_active"),
+		value: bool(input.recording.active)
+	});
+	else if (!input.degradedStages.includes("recording")) values.push({
+		topic: stateTopic(deviceKey, "recording_active"),
+		value: bool(false)
+	});
+	return values;
+}
+function cameraStatusToken(input) {
+	if (input.degradedStages.includes("switches")) return "unknown";
+	if (input.switchedOff.length > 0) return "switched_off";
+	if (input.degradedStages.length > 0) return "degraded";
+	return "ok";
+}
 //#endregion
 //#region src/ha-export/synthetic-devices.ts
 /**
@@ -4803,6 +5084,25 @@ function isSyntheticDeviceKey(deviceKey) {
 	return SYNTHETIC_STABLE_IDS.some((id) => deviceKeyFor(id) === deviceKey);
 }
 /**
+* Pure derivation of the three alert entities (Task D1) — the conditions
+* nobody said, surfaced from `alerts.list`.
+*
+* Counts and raises the badge ONLY on `status: 'active'` alerts whose
+* `severity` is `warning` or `error`. `info` moves neither: a badge that
+* lights up on `info` teaches an operator to ignore it, which is how the
+* 2026-08-08 four-hour blackout produced not one visible alert despite the
+* liveness monitor's findings running the whole time.
+*/
+function deriveAlertSummary(alerts) {
+	const relevant = alerts.filter((a) => a.status === "active" && (a.severity === "warning" || a.severity === "error"));
+	const last = relevant.reduce((top, a) => top === null || a.updatedAt > top.updatedAt ? a : top, null);
+	return {
+		active: relevant.length > 0,
+		count: relevant.length,
+		lastTitle: last?.title ?? null
+	};
+}
+/**
 * Everything a synthetic device exports arrives ENABLED.
 *
 * The pressure valve exists for the camera fan-out — three zones is ~73
@@ -4875,6 +5175,79 @@ function notificationCenterSpecs(input) {
 			icon: "mdi:counter",
 			entityCategory: "diagnostic"
 		},
+		(
+		/**
+		* The GLOBAL snooze, as a control (Task D4) — the half `snoozed` (above)
+		* never had. Its state is NOT projected here: `ha-export.addon.ts` pushes
+		* it through the SAME `projectSnooze` a camera's snooze uses, so the rule
+		* lives in one place — two expressions of it in two files is how
+		* `audio_detected` went mute for a year.
+		*/
+		{
+			entity: "snooze",
+			platform: "select",
+			label: "Snooze all notifications",
+			writable: true,
+			options: SNOOZE_OPTIONS
+		}),
+		(
+		/**
+		* The last trigger, six entities: five facts plus its picture — "conoscere
+		* gli ultimi trigger, le ultime immagini... e da quale label" (operator,
+		* 2026-08-25). ENABLED by default like every other entity on this device
+		* (see {@link buildComponents}'s docblock): a rule the operator wrote is a
+		* rule they want to watch fire.
+		*
+		* Fixed count regardless of camera fleet size — the fan-out this design
+		* explicitly avoids (960 entities at 30 cameras × 32 rules) lives ONLY in
+		* the per-rule switches below, which already existed. These six are on
+		* ONE synthetic device and never repeat per camera or per rule.
+		*/
+		{
+			entity: "last_trigger_at",
+			platform: "sensor",
+			label: "Last trigger",
+			deviceClass: "timestamp"
+		}),
+		{
+			entity: "last_trigger_rule",
+			platform: "sensor",
+			label: "Last trigger rule",
+			icon: "mdi:bell-ring-outline"
+		},
+		{
+			entity: "last_trigger_camera",
+			platform: "sensor",
+			label: "Last trigger camera",
+			icon: "mdi:cctv"
+		},
+		(
+		/** The identified label, or the detected class when none was resolved —
+		*  see {@link SyntheticLastTrigger.label}. Never blank. */
+		{
+			entity: "last_trigger_label",
+			platform: "sensor",
+			label: "Last trigger label",
+			icon: "mdi:tag-outline"
+		}),
+		(
+		/** `pending` / `sent` / `dead` — the outbox row's own status, straight
+		*  from `getHistory`, never a second delivery ledger. */
+		{
+			entity: "last_trigger_status",
+			platform: "sensor",
+			label: "Last trigger delivery status",
+			icon: "mdi:send-check-outline",
+			entityCategory: "diagnostic"
+		}),
+		(
+		/** See {@link SyntheticLastTrigger.imageUrl} for the expired/unreachable
+		*  degrade: no value is published rather than a link that 404s. */
+		{
+			entity: "last_trigger_image",
+			platform: "image",
+			label: "Last trigger image"
+		}),
 		...input.rules.map((rule) => ({
 			entity: ruleEntity(rule.id),
 			platform: "switch",
@@ -4936,6 +5309,56 @@ function serverSpecs(input) {
 			deviceClass: "update",
 			entityCategory: "diagnostic"
 		},
+		(
+		/**
+		* The conditions nobody said (Task D1) — `alerts.list`'s active,
+		* warning-or-error findings. `info` never raises `alerts_active` or
+		* inflates the count: a badge that lights up on `info` teaches an
+		* operator to ignore it, which is how the four-hour blackout stayed
+		* quiet through every liveness finding it produced.
+		*/
+		{
+			entity: "alerts_active",
+			platform: "binary_sensor",
+			label: "Alerts active",
+			deviceClass: "problem"
+		}),
+		{
+			entity: "alerts_active_count",
+			platform: "sensor",
+			label: "Active alerts",
+			icon: "mdi:alert"
+		},
+		{
+			entity: "alerts_last_title",
+			platform: "sensor",
+			label: "Last active alert",
+			icon: "mdi:alert-circle-outline",
+			entityCategory: "diagnostic"
+		},
+		(
+		/** The oldest footage across the whole cluster (Task D2). */
+		{
+			entity: "oldest_footage",
+			platform: "sensor",
+			label: "Oldest footage",
+			deviceClass: "timestamp",
+			entityCategory: "diagnostic"
+		}),
+		(
+		/**
+		* The seed-vs-contract verdict (Task D3, D3's `image_contract`) — the
+		* 2026-08-02 guasto, where `runningVersion` was current while the
+		* container image was weeks old from a renamed repository nothing
+		* rebuilt. Hub only: it describes THIS process's own image.
+		*/
+		{
+			entity: "image_contract",
+			platform: "sensor",
+			label: "Image contract",
+			icon: "mdi:package-variant-closed-check",
+			entityCategory: "diagnostic"
+		}),
 		...input.nodes.flatMap((node) => {
 			const slug = toSlug(node.id);
 			return [
@@ -4964,7 +5387,38 @@ function serverSpecs(input) {
 					platform: "sensor",
 					label: `${node.name} uptime`,
 					deviceClass: "timestamp"
-				}
+				},
+				(
+				/** The disk (Task D2) — every node, hub included: every node records. */
+				{
+					entity: `${slug}_footage_used_bytes`,
+					platform: "sensor",
+					label: `${node.name} footage used`,
+					deviceClass: "data_size",
+					unit: "B",
+					entityCategory: "diagnostic"
+				}),
+				{
+					entity: `${slug}_footage_free_percent`,
+					platform: "sensor",
+					label: `${node.name} footage free`,
+					unit: "%",
+					icon: "mdi:harddisk",
+					entityCategory: "diagnostic"
+				},
+				...node.isHub ? [] : [{
+					entity: `${slug}_version`,
+					platform: "sensor",
+					label: `${node.name} version`,
+					icon: "mdi:tag",
+					entityCategory: "diagnostic"
+				}, {
+					entity: `${slug}_update_available`,
+					platform: "binary_sensor",
+					label: `${node.name} update available`,
+					deviceClass: "update",
+					entityCategory: "diagnostic"
+				}]
 			];
 		})
 	];
@@ -5029,8 +5483,51 @@ function projectSynthetic(input, nowMs) {
 		{
 			topic: stateTopic(srv, "update_available"),
 			value: String(input.updateAvailable)
+		},
+		{
+			topic: stateTopic(srv, "alerts_active"),
+			value: String(input.alertsActive)
+		},
+		{
+			topic: stateTopic(srv, "alerts_active_count"),
+			value: String(input.alertsActiveCount)
 		}
 	];
+	if (input.lastTrigger !== null) {
+		const t = input.lastTrigger;
+		values.push({
+			topic: stateTopic(nc, "last_trigger_at"),
+			value: new Date(t.at).toISOString()
+		}, {
+			topic: stateTopic(nc, "last_trigger_rule"),
+			value: t.ruleName
+		}, {
+			topic: stateTopic(nc, "last_trigger_camera"),
+			value: t.deviceName
+		}, {
+			topic: stateTopic(nc, "last_trigger_label"),
+			value: t.label
+		}, {
+			topic: stateTopic(nc, "last_trigger_status"),
+			value: t.status
+		});
+		if (t.imageUrl !== null) values.push({
+			topic: stateTopic(nc, "last_trigger_image"),
+			value: t.imageUrl
+		});
+	}
+	if (input.alertsLastTitle !== null) values.push({
+		topic: stateTopic(srv, "alerts_last_title"),
+		value: input.alertsLastTitle
+	});
+	if (input.oldestFootageMs !== null) values.push({
+		topic: stateTopic(srv, "oldest_footage"),
+		value: new Date(input.oldestFootageMs).toISOString()
+	});
+	if (input.imageContractState !== null) values.push({
+		topic: stateTopic(srv, "image_contract"),
+		value: input.imageContractState
+	});
 	for (const node of input.nodes) {
 		const slug = toSlug(node.id);
 		values.push({
@@ -5047,6 +5544,24 @@ function projectSynthetic(input, nowMs) {
 			topic: stateTopic(srv, `${slug}_uptime`),
 			value: (/* @__PURE__ */ new Date(nowMs - node.uptime * 1e3)).toISOString()
 		});
+		if (node.footageUsedBytes !== null) values.push({
+			topic: stateTopic(srv, `${slug}_footage_used_bytes`),
+			value: String(node.footageUsedBytes)
+		});
+		if (node.footageFreePercent !== null) values.push({
+			topic: stateTopic(srv, `${slug}_footage_free_percent`),
+			value: String(Math.round(node.footageFreePercent * 10) / 10)
+		});
+		if (!node.isHub) {
+			if (node.rootPackageVersion !== null) values.push({
+				topic: stateTopic(srv, `${slug}_version`),
+				value: node.rootPackageVersion
+			});
+			if (node.updateAvailable !== null) values.push({
+				topic: stateTopic(srv, `${slug}_update_available`),
+				value: String(node.updateAvailable)
+			});
+		}
 	}
 	return values;
 }
@@ -5185,6 +5700,17 @@ var HaExportAddon = class extends BaseAddon {
 	*/
 	syntheticRules = [];
 	/**
+	* `pipelineOrchestrator.getCameraStatuses`, keyed by deviceId — ONE call
+	* per reconcile pass for every exported camera (Task C3), never per
+	* device: the input is optional and omitting it means "the whole fleet",
+	* which is exactly the path this repo just finished removing from hot
+	* loops. Feeds `status` / `recording_active` (Traccia C) and
+	* `broker-audio`'s node pin (Traccia A2). Cleared to empty on a failed
+	* read — never stale data from a previous pass, which would be a status
+	* silently wrong rather than absent.
+	*/
+	cameraStatusByDeviceId = /* @__PURE__ */ new Map();
+	/**
 	* A link that returned repairs NOW, not at the next periodic pass.
 	*
 	* `PushClient` drops its dedup cache the moment Home Assistant answers
@@ -5684,6 +6210,39 @@ var HaExportAddon = class extends BaseAddon {
 			const devices = await this.ctx.api.deviceManager.listAll.query({});
 			const snapshots = await this.ctx.api.deviceState.getAllSnapshots.query({});
 			const byId = new Map(devices.map((device) => [device.id, device]));
+			/**
+			* The exported cameras' `CameraStatus`, ONE call for every one of them
+			* (Task C3). Computed BEFORE the per-device loop: `status`,
+			* `recording_active` and `broker-audio`'s node pin all read from it, and
+			* asking per camera would be the fan-out this repo just finished
+			* removing from a 300 s poll.
+			*/
+			const exposedIds = exposedDeviceIds(this.config.membership, enabled);
+			const cameraDeviceIds = [];
+			for (const idStr of exposedIds) {
+				const numericId = Number(idStr);
+				if (!Number.isFinite(numericId)) continue;
+				const candidate = byId.get(numericId);
+				if (candidate !== void 0 && candidate.type === "camera" && candidate.addonId !== "provider-homeassistant") cameraDeviceIds.push(numericId);
+			}
+			this.cameraStatusByDeviceId = await this.readCameraStatuses(cameraDeviceIds);
+			/** `notificationRules.listDeviceMutes` — once per pass, a flat list. */
+			const mutedDeviceIds = await this.ctx.api.notificationRules.listDeviceMutes.query({}).then((r) => r.mutedDeviceIds).catch((err) => {
+				this.ctx.logger.warn("ha-export: could not read notification mutes, camera functions degrade", { meta: { error: errMsg(err) } });
+				return null;
+			});
+			/** `deviceManager.listBindableCapsForDeviceType` — once per TYPE, not per device. */
+			const bindableCapsByType = /* @__PURE__ */ new Map();
+			/**
+			* `notificationRules.listSnoozes` — ONE read for the whole pass, shared
+			* by every camera's `snooze` select (Task B1) and the synthetic
+			* `snooze` select on *Notification Center* (Task D4): two expressions
+			* of the same read is how `audio_detected` went mute for a year.
+			*/
+			const snoozes = await this.ctx.api.notificationRules.listSnoozes.query({}).then((r) => r.snoozes).catch((err) => {
+				this.ctx.logger.warn("ha-export: could not read snoozes, snooze selects go unknown", { meta: { error: errMsg(err) } });
+				return [];
+			});
 			const exported = /* @__PURE__ */ new Map();
 			const keyByDeviceId = /* @__PURE__ */ new Map();
 			const allCaps = /* @__PURE__ */ new Set();
@@ -5709,7 +6268,24 @@ var HaExportAddon = class extends BaseAddon {
 					this.ctx.logger.warn("ha-export: refusing to export a device imported from Home Assistant", { tags: { deviceId: numericId } });
 					continue;
 				}
-				const catalogDevice = await this.buildCatalogDevice(device, snapshots[String(numericId)]);
+				/**
+				* ONE collection of the eight function authorities per camera per
+				* pass (Task A1/A3) — reused below by the announce (the switch
+				* catalog, via `buildCatalogDevice`) AND by the state push
+				* (`currentStateFor`, off `ExportedDevice.cameraFunctions`). The two
+				* used to call the deprecated `getCameraSwitches` separately for the
+				* same answer.
+				*/
+				const cameraFunctions = device.type === "camera" ? deriveCameraFunctions(await this.readCameraFunctions({
+					deviceId: numericId,
+					deviceType: device.type,
+					deviceDisabled: device.disabled,
+					privacySlice: toSnapshot(snapshots[String(numericId)])["privacy-mask"],
+					sourceNodeId: this.cameraStatusByDeviceId.get(numericId)?.assignment.sourceNodeId ?? null,
+					bindableCapsByType,
+					mutedDeviceIds
+				})) : null;
+				const catalogDevice = await this.buildCatalogDevice(device, snapshots[String(numericId)], cameraFunctions);
 				for (const cap of catalogDevice.boundCaps) allCaps.add(cap);
 				const brokerIds = brokersExposing(this.config.membership, deviceIdStr).filter((id) => enabled.includes(id));
 				/**
@@ -5729,7 +6305,8 @@ var HaExportAddon = class extends BaseAddon {
 						boundCaps: catalogDevice.boundCaps
 					},
 					brokerIds,
-					streams: catalogDevice.streams ?? []
+					streams: catalogDevice.streams ?? [],
+					cameraFunctions
 				});
 				keyByDeviceId.set(numericId, plan.deviceKey);
 				entityCount += Object.keys(plan.cmps).length;
@@ -5758,7 +6335,7 @@ var HaExportAddon = class extends BaseAddon {
 			* `brokerIds` is every enabled broker, because they belong to the server
 			* and not to a membership the operator picks per camera.
 			*/
-			const synthetic = await this.buildSynthetic();
+			const synthetic = await this.buildSynthetic(snoozes, byId);
 			if (synthetic !== null) for (const plan of syntheticPlans(synthetic)) {
 				exported.set(plan.deviceKey, {
 					plan,
@@ -5769,7 +6346,8 @@ var HaExportAddon = class extends BaseAddon {
 						boundCaps: []
 					},
 					brokerIds: [...enabled],
-					streams: []
+					streams: [],
+					cameraFunctions: null
 				});
 				entityCount += Object.keys(plan.cmps).length;
 			}
@@ -5797,8 +6375,16 @@ var HaExportAddon = class extends BaseAddon {
 				}
 			});
 			await this.announce(exported);
-			await this.pushFullState(exported, snapshots);
-			if (synthetic !== null) await this.pushSynthetic(projectSynthetic(synthetic, Date.now()), [...enabled]);
+			await this.pushFullState(exported, snapshots, snoozes);
+			if (synthetic !== null) {
+				/**
+				* The global snooze's STATE (Task D4) rides the SAME `projectSnooze`
+				* a camera's `snooze` select uses, over the SAME `snoozes` read this
+				* pass already made — one expression of the rule, not two.
+				*/
+				const ncKey = deviceKeyFor(NOTIFICATION_CENTER_STABLE_ID);
+				await this.pushSynthetic([...projectSynthetic(synthetic, Date.now()), ...projectSnooze(ncKey, latestGlobalSnoozeWindow(snoozes))], [...enabled]);
+			}
 			this.ctx.logger.info("ha-export: reconciled", { meta: {
 				reason,
 				brokers: enabled.length,
@@ -5832,7 +6418,7 @@ var HaExportAddon = class extends BaseAddon {
 	* Returns `null` only when NOTHING answered, so the devices are not
 	* announced empty on a hub that is still booting.
 	*/
-	async buildSynthetic() {
+	async buildSynthetic(snoozes, byId) {
 		const rules = await this.ctx.api.notificationRules.listRules.query({}).then((r) => r.rules.map((rule) => ({
 			id: rule.id,
 			name: rule.name,
@@ -5841,15 +6427,9 @@ var HaExportAddon = class extends BaseAddon {
 			this.ctx.logger.warn("ha-export: could not read notification rules", { meta: { error: errMsg(err) } });
 			return null;
 		});
-		const snoozes = await this.ctx.api.notificationRules.listSnoozes.query({}).then((r) => r.snoozes.length > 0).catch(() => null);
-		const nodes = await this.ctx.api.nodes.topology.query().then((list) => list.map((node) => ({
-			id: node.id,
-			name: node.name,
-			online: node.isOnline,
-			cpuPercent: node.cpuPercent,
-			memoryPercent: node.memoryPercent,
-			uptime: node.uptime
-		}))).catch((err) => {
+		/** Reuses the ONE `listSnoozes` read the pass already made (Task B1/D4). */
+		const anySnoozed = snoozes.length > 0;
+		const topology = await this.ctx.api.nodes.topology.query().catch((err) => {
 			this.ctx.logger.warn("ha-export: could not read the cluster topology", { meta: { error: errMsg(err) } });
 			return null;
 		});
@@ -5864,16 +6444,132 @@ var HaExportAddon = class extends BaseAddon {
 			};
 		}).catch(() => null);
 		const server = await this.ctx.api.serverManagement.getServerPackageStatus.query().catch(() => null);
-		if (rules === null && nodes === null && addons === null && server === null) return null;
+		const alerts = await this.readActiveAlerts();
+		const lastTrigger = await this.buildLastTrigger(byId);
+		if (rules === null && topology === null && addons === null && server === null) return null;
 		this.syntheticRules = rules ?? this.syntheticRules;
+		const { nodes, oldestFootageMs } = await this.buildSyntheticNodes(topology ?? []);
 		return {
 			rules: rules ?? this.syntheticRules,
-			snoozed: snoozes ?? false,
-			nodes: nodes ?? [],
+			snoozed: anySnoozed,
+			lastTrigger,
+			nodes,
 			addonsRunning: addons?.running ?? 0,
 			addonsFailed: addons?.failed ?? 0,
 			serverVersion: server?.runningVersion ?? server?.activeVersion ?? "unknown",
-			updateAvailable: server?.updateAvailable ?? false
+			updateAvailable: server?.updateAvailable ?? false,
+			alertsActive: alerts.active,
+			alertsActiveCount: alerts.count,
+			alertsLastTitle: alerts.lastTitle,
+			oldestFootageMs,
+			imageContractState: server?.imageContract?.state ?? null
+		};
+	}
+	/**
+	* The most recent notification-rule trigger — "conoscere gli ultimi
+	* trigger, le ultime immagini... e da quale label" (operator, 2026-08-25).
+	*
+	* `getHistory` is already newest-first (§3.2), so `limit: 1` is the whole
+	* question. Best-effort like every other synthetic source here: a failed
+	* read costs only these six entities, never the rest of the device.
+	*/
+	async buildLastTrigger(byId) {
+		try {
+			const { entries } = await this.ctx.api.notificationRules.getHistory.query({ filter: { limit: 1 } });
+			const entry = entries[0];
+			if (entry === void 0) return null;
+			const label = entry.subject.label ?? entry.subject.className;
+			const artifactId = entry.artifactIds?.[0];
+			const imageUrl = artifactId === void 0 ? null : await this.ctx.api.notificationRules.resolveArtifactUrl.query({ artifactId }).then((r) => r.url).catch((err) => {
+				this.ctx.logger.debug("ha-export: could not resolve the last trigger image url", {
+					tags: { deviceId: entry.deviceId },
+					meta: {
+						artifactId,
+						error: errMsg(err)
+					}
+				});
+				return null;
+			});
+			return {
+				at: entry.createdAt,
+				ruleName: entry.ruleName,
+				deviceName: byId.get(entry.deviceId)?.name ?? `camera ${entry.deviceId}`,
+				label,
+				status: entry.status,
+				imageUrl
+			};
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read the last notification trigger", { meta: { error: errMsg(err) } });
+			return null;
+		}
+	}
+	/**
+	* `alerts.list` — the conditions nobody said (Task D1). Best-effort: a
+	* failed read yields "nothing active", not a fabricated absence dressed up
+	* as a clean one — this addon logs the drop rather than pretending the
+	* cluster is quiet. The derivation itself is pure — see
+	* `deriveAlertSummary` in `synthetic-devices.ts`, which is what is tested.
+	*/
+	async readActiveAlerts() {
+		try {
+			return deriveAlertSummary(await this.ctx.api.alerts.list.query({
+				unreadOnly: false,
+				limit: 50
+			}));
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read alerts, the alert entities go quiet", { meta: { error: errMsg(err) } });
+			return {
+				active: false,
+				count: 0,
+				lastTitle: null
+			};
+		}
+	}
+	/**
+	* Per-node disk usage (Task D2) and per-AGENT package status (Task D3),
+	* fanned out from the topology this pass already read. Bounded per node —
+	* one unreachable node degrades its own two rows, never the others'.
+	*/
+	async buildSyntheticNodes(topology) {
+		let oldestFootageMs = null;
+		return {
+			nodes: await Promise.all(topology.map(async (node) => {
+				const disk = await this.ctx.api.recording.getStorageUsage.query({}, nodePin(node.id)).catch((err) => {
+					this.ctx.logger.warn("ha-export: could not read storage usage for a node, its disk entities go unknown", { meta: {
+						nodeId: node.id,
+						error: errMsg(err)
+					} });
+					return null;
+				});
+				const freePercents = (disk?.locations ?? []).filter((loc) => loc.availableBytes !== null && loc.totalBytes !== null && loc.totalBytes > 0).map((loc) => loc.availableBytes / loc.totalBytes * 100);
+				const footageFreePercent = freePercents.length > 0 ? Math.min(...freePercents) : null;
+				for (const device of disk?.devices ?? []) {
+					const oldest = device.oldestMs;
+					if (oldest === null || oldest === void 0) continue;
+					if (oldestFootageMs === null || oldest < oldestFootageMs) oldestFootageMs = oldest;
+				}
+				const packageStatus = node.isHub ? null : await this.ctx.api.serverManagement.getServerPackageStatus.query({ nodeId: node.id }).catch((err) => {
+					this.ctx.logger.warn("ha-export: could not read package status for an agent node, its update entities go unknown", { meta: {
+						nodeId: node.id,
+						error: errMsg(err)
+					} });
+					return null;
+				});
+				return {
+					id: node.id,
+					name: node.name,
+					online: node.isOnline,
+					cpuPercent: node.cpuPercent,
+					memoryPercent: node.memoryPercent,
+					uptime: node.uptime,
+					isHub: node.isHub,
+					footageUsedBytes: disk?.totalUsedBytes ?? null,
+					footageFreePercent,
+					rootPackageVersion: node.rootPackage?.version ?? null,
+					updateAvailable: packageStatus?.updateAvailable ?? null
+				};
+			})),
+			oldestFootageMs
 		};
 	}
 	/** Push the synthetic values to every enabled broker. */
@@ -5901,9 +6597,9 @@ var HaExportAddon = class extends BaseAddon {
 			}
 		}
 	}
-	async pushFullState(exported, snapshots) {
+	async pushFullState(exported, snapshots, snoozes) {
 		for (const entry of exported.values()) try {
-			const values = await this.currentStateFor(entry, snapshots[String(entry.deviceId)]);
+			const values = await this.currentStateFor(entry, snapshots[String(entry.deviceId)], snoozes);
 			this.push(entry.deviceId, values);
 		} catch (err) {
 			this.ctx.logger.warn("ha-export: could not read current state for a device", {
@@ -5914,7 +6610,7 @@ var HaExportAddon = class extends BaseAddon {
 		for (const link of this.links.values()) await link.client.flush();
 	}
 	/** Everything readable without waiting for an event. */
-	async currentStateFor(entry, snapshotRaw) {
+	async currentStateFor(entry, snapshotRaw, snoozes) {
 		const key = entry.plan.deviceKey;
 		const values = [];
 		const snapshot = toSnapshot(snapshotRaw);
@@ -5984,13 +6680,26 @@ var HaExportAddon = class extends BaseAddon {
 			* video itself. The url this block used to publish was read by
 			* nobody — see `camera-entities.ts`.
 			*/
-			const group = await this.ctx.api.pipelineOrchestrator.getCameraSwitches.query({ deviceId: entry.deviceId });
-			values.push(...projectCameraSwitches(key, group.switches.map((sw) => ({
-				id: sw.id,
-				label: sw.label,
-				available: sw.available,
-				enabled: sw.enabled
-			}))));
+			values.push(...projectCameraFunctions(key, entry.cameraFunctions ?? []));
+			/**
+			* `status` / `recording_active` (Traccia C) — off the SAME
+			* `CameraStatus` `runReconcile` already read once for the whole pass
+			* (Task C3). A camera the batch read did not cover (the call failed
+			* entirely, or a camera added mid-pass) publishes NEITHER: an invented
+			* `ok` is the D62 failure this entity exists to prevent.
+			*/
+			const cameraStatus = this.cameraStatusByDeviceId.get(entry.deviceId);
+			if (cameraStatus !== void 0) values.push(...projectCameraStatus(key, toCameraStatusInput(cameraStatus)));
+			/**
+			* `snooze` (Task B1) — reconstructed from `notificationRules.listSnoozes`,
+			* never stored: the select's state is the SAME authority the write path
+			* (`applySnooze`) already uses.
+			*/
+			const snoozeValues = projectSnooze(key, latestDeviceSnoozeWindow(snoozes, entry.deviceId));
+			if (snoozeValues.length === 0) {
+				if (snoozes.filter((s) => s.scope === "device" && s.deviceId === entry.deviceId).length > 0) this.ctx.logger.debug("ha-export: an active snooze has a duration the select cannot express, publishing nothing", { tags: { deviceId: entry.deviceId } });
+			}
+			values.push(...snoozeValues);
 			const occupancy = await this.ctx.api.zoneAnalytics.getCurrentSnapshot.query({ deviceId: entry.deviceId });
 			if (occupancy !== null) values.push(...projectZoneOccupancy(key, {
 				zones: occupancy.zones.map((zone) => ({
@@ -6006,11 +6715,20 @@ var HaExportAddon = class extends BaseAddon {
 		}
 		return values;
 	}
-	async buildCatalogDevice(device, snapshotRaw) {
+	async buildCatalogDevice(device, snapshotRaw, cameraFunctions) {
 		const snapshot = toSnapshot(snapshotRaw);
 		const boundCaps = await this.loadBoundCaps(device.id);
 		const zones = device.type === "camera" ? await this.loadZones(device.id) : [];
-		const switches = device.type === "camera" ? await this.loadSwitches(device.id) : [];
+		/**
+		* Every camera function, available or not — `entity-catalog.ts` is the
+		* one place that filters to `available`, exactly as it did for
+		* `getCameraSwitches`'s answer.
+		*/
+		const switches = (cameraFunctions ?? []).map((fn) => ({
+			id: fn.id,
+			label: fn.label,
+			available: fn.available
+		}));
 		const ptzPresets = device.type === "camera" && boundCaps.includes("ptz") ? await this.loadPresets(device.id) : [];
 		const streams = device.type === "camera" && boundCaps.includes("webrtc-session") ? await this.loadStreamChoices(device.id) : [];
 		const manufacturer = readString(device.metadata ?? {}, "manufacturer");
@@ -6096,25 +6814,118 @@ var HaExportAddon = class extends BaseAddon {
 			return [];
 		}
 	}
-	async loadSwitches(deviceId) {
+	/**
+	* `pipelineOrchestrator.getCameraStatuses`, for every exported camera in
+	* ONE call (Task C3). Best-effort for the WHOLE batch: a failure here means
+	* `status`, `recording_active` and every `broker-audio` control degrade for
+	* this pass — never a value invented from a previous pass's answer.
+	*/
+	async readCameraStatuses(deviceIds) {
+		if (deviceIds.length === 0) return /* @__PURE__ */ new Map();
+		const startedAt = Date.now();
 		try {
-			return (await this.ctx.api.pipelineOrchestrator.getCameraSwitches.query({ deviceId })).switches.map((sw) => ({
-				id: sw.id,
-				label: sw.label,
-				available: sw.available
-			}));
+			const statuses = await this.ctx.api.pipelineOrchestrator.getCameraStatuses.query({ deviceIds: [...deviceIds] });
+			this.ctx.logger.debug("ha-export: read camera statuses for the pass", { meta: {
+				cameraStatusMs: Date.now() - startedAt,
+				cameras: deviceIds.length
+			} });
+			return new Map(statuses.map((status) => [status.deviceId, status]));
 		} catch (err) {
-			/**
-			* A source that did not answer produces NO control, never one
-			* defaulted to on. This is the rule `CameraSwitch.available`
-			* exists to enforce, and it has to survive the read failing.
-			*/
-			this.ctx.logger.warn("ha-export: could not read camera switches, exporting no controls", {
+			this.ctx.logger.warn("ha-export: could not read camera statuses — status, recording_active and broker-audio degrade for every exported camera this pass", { meta: {
+				error: errMsg(err),
+				cameras: deviceIds.length
+			} });
+			return /* @__PURE__ */ new Map();
+		}
+	}
+	/**
+	* The eight per-camera function authorities (Task A1), assembled into
+	* {@link CameraFunctionReads}. Every source degrades INDEPENDENTLY with a
+	* WARN carrying `tags: { deviceId }` — a dropped authority must never look
+	* like "this function does not exist" (D62).
+	*
+	* `bindableCapsByType`/`mutedDeviceIds` are the reconcile pass's shared
+	* caches when the caller has them (a per-TYPE lookup and a flat list read
+	* once for the whole pass); omitted, each is read fresh — the one-off
+	* command path (`dispatch`) has no pass to share.
+	*/
+	async readCameraFunctions(input) {
+		const { deviceId, deviceType, deviceDisabled, privacySlice, sourceNodeId } = input;
+		const bindableCache = input.bindableCapsByType;
+		let bindableCapNames = bindableCache?.get(deviceType);
+		if (bindableCache === void 0 || bindableCapNames === void 0) {
+			bindableCapNames = await this.ctx.api.deviceManager.listBindableCapsForDeviceType.query({ deviceType }).then((entries) => entries.filter((e) => e.wrappers.length > 0).map((e) => e.capName)).catch((err) => {
+				this.ctx.logger.warn("ha-export: could not read bindable caps for a device type, camera functions degrade", {
+					tags: { deviceId },
+					meta: {
+						deviceType,
+						error: errMsg(err)
+					}
+				});
+				return null;
+			});
+			bindableCache?.set(deviceType, bindableCapNames);
+		}
+		const wrapperAddonIdByCap = /* @__PURE__ */ new Map();
+		const wrappedCapNames = await this.ctx.api.deviceManager.getBindings.query({ deviceId }).then((bindings) => {
+			const active = [];
+			for (const entry of bindings.entries) {
+				if (entry.kind !== "wrapped") continue;
+				active.push(entry.capName);
+				if (entry.providerAddonId !== "") wrapperAddonIdByCap.set(entry.capName, entry.providerAddonId);
+			}
+			return active;
+		}).catch((err) => {
+			this.ctx.logger.warn("ha-export: could not read bindings, camera functions degrade", {
 				tags: { deviceId },
 				meta: { error: errMsg(err) }
 			});
-			return [];
-		}
+			return null;
+		});
+		const recordingEnabled = await this.ctx.api.recording.getDeviceConfig.query({ deviceId }).then((config) => config.enabled).catch((err) => {
+			this.ctx.logger.warn("ha-export: could not read recording config, the recording function degrades", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return null;
+		});
+		const mutedDeviceIds = input.mutedDeviceIds !== void 0 ? input.mutedDeviceIds : await this.ctx.api.notificationRules.listDeviceMutes.query({}).then((r) => r.mutedDeviceIds).catch((err) => {
+			this.ctx.logger.warn("ha-export: could not read notification mutes, the notifications function degrades", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return null;
+		});
+		const notificationsMuted = mutedDeviceIds === null ? null : mutedDeviceIds.includes(deviceId);
+		/**
+		* The `privacy-mask` slice already in the snapshot this pass downloaded
+		* (D224: a camera fact's freshness lives in the provider that owns it) —
+		* zero new dialers to the camera.
+		*/
+		const privacy = privacySlice === void 0 ? null : {
+			maskEnabled: privacySlice["enabled"] === true,
+			audioEnabled: typeof privacySlice["audioEnabled"] === "boolean" ? privacySlice["audioEnabled"] : null
+		};
+		const brokerAudioMuted = sourceNodeId === null ? null : await this.ctx.api.streamBroker.getDeviceAudioMute.query({ deviceId }, nodePin(sourceNodeId)).then((r) => r.muted).catch((err) => {
+			this.ctx.logger.warn("ha-export: could not read broker audio mute, the broker-audio function degrades", {
+				tags: { deviceId },
+				meta: {
+					sourceNodeId,
+					error: errMsg(err)
+				}
+			});
+			return null;
+		});
+		return {
+			deviceDisabled,
+			bindableCapNames,
+			wrappedCapNames,
+			wrapperAddonIdByCap,
+			recordingEnabled,
+			notificationsMuted,
+			privacy,
+			brokerAudioMuted
+		};
 	}
 	async loadPresets(deviceId) {
 		try {
@@ -6367,6 +7178,38 @@ var HaExportAddon = class extends BaseAddon {
 		* disagree with the admin UI is worse than no knob (D62).
 		*/
 		if (isSyntheticDeviceKey(parsed.deviceKey)) {
+			/**
+			* The global snooze select (Task D4) — the OTHER control this branch
+			* routes, alongside the per-rule switches below. Same rule as the
+			* camera's own snooze (`applySnooze`): the export writes
+			* `createSnooze`/`cancelSnooze` directly, `scope: 'all'`, never a
+			* store of its own.
+			*/
+			if (parsed.deviceKey === deviceKeyFor("synthetic-notification-center") && parsed.entity === "snooze") {
+				if (!SNOOZE_OPTIONS.includes(value)) {
+					this.ctx.logger.warn("ha-export: dropping a global snooze command, unknown option", { meta: {
+						topic,
+						value
+					} });
+					reply.status(422);
+					reply.send({ error: "unroutable command" });
+					return;
+				}
+				const minutes = SNOOZE_MINUTES[value] ?? null;
+				try {
+					await this.applyGlobalSnooze(minutes);
+					reply.status(200);
+					reply.send({});
+				} catch (err) {
+					this.ctx.logger.warn("ha-export: could not apply the global snooze from Home Assistant", { meta: {
+						minutes,
+						error: errMsg(err)
+					} });
+					reply.status(422);
+					reply.send({ error: "command not applied" });
+				}
+				return;
+			}
 			const ruleId = ruleIdFromEntity(parsed.entity, this.syntheticRules);
 			if (ruleId === null) {
 				this.ctx.logger.warn("ha-export: dropping a synthetic command with no authority behind it", { meta: {
@@ -6452,20 +7295,62 @@ var HaExportAddon = class extends BaseAddon {
 				return false;
 			}
 			switch (command.kind) {
-				case "camera-switch": {
+				case "camera-function": {
 					const parsed = CameraSwitchIdSchema.safeParse(command.switchId);
 					if (!parsed.success) {
-						this.ctx.logger.warn("ha-export: dropping a command for an unknown camera switch", {
+						this.ctx.logger.warn("ha-export: dropping a command for an unknown camera function", {
 							tags: { deviceId: command.deviceId },
 							meta: { switchId: command.switchId }
 						});
 						return false;
 					}
-					await this.ctx.api.pipelineOrchestrator.setCameraSwitch.mutate({
+					/**
+					* A FRESH read for this one device — the pass-level caches are up to
+					* `reconcileIntervalSec` old, and an availability decision that
+					* writes belongs to the moment of the command, not the last poll.
+					*/
+					const device = await this.ctx.api.deviceManager.getDevice.query({ deviceId: command.deviceId });
+					if (device === null) {
+						this.ctx.logger.warn("ha-export: dropping a camera-function command, the device is not in the registry", { tags: { deviceId: command.deviceId } });
+						return false;
+					}
+					const privacySlice = await this.ctx.api.deviceState.getCapSlice.query({
+						deviceId: command.deviceId,
+						capName: "privacy-mask"
+					}).catch((err) => {
+						this.ctx.logger.warn("ha-export: could not read the privacy slice for a camera-function command", {
+							tags: { deviceId: command.deviceId },
+							meta: { error: errMsg(err) }
+						});
+						return null;
+					});
+					/**
+					* The source node comes from the last reconcile's `CameraStatus`
+					* batch (Task C3) rather than a fresh per-command call: it changes
+					* rarely, and only `broker-audio` needs it — a stale pin degrades
+					* that ONE function for this command, not the other seven.
+					*/
+					const sourceNodeId = this.cameraStatusByDeviceId.get(command.deviceId)?.assignment.sourceNodeId ?? null;
+					const reads = await this.readCameraFunctions({
 						deviceId: command.deviceId,
-						switchId: parsed.data,
-						enabled: command.enabled
+						deviceType: device.type,
+						deviceDisabled: device.disabled,
+						privacySlice: privacySlice ?? void 0,
+						sourceNodeId
 					});
+					const write = resolveCameraFunctionWrite(parsed.data, command.enabled, reads);
+					if (write === null) {
+						/**
+						* Refused, never approximated. No optimistic ack: the next
+						* reconcile corrects Home Assistant's toggle back to reality.
+						*/
+						this.ctx.logger.warn("ha-export: dropping a camera-function command, the function is not available", {
+							tags: { deviceId: command.deviceId },
+							meta: { switchId: parsed.data }
+						});
+						return false;
+					}
+					await applyCameraFunctionWrite(this.ctx.api, command.deviceId, write, sourceNodeId);
 					return true;
 				}
 				case "reboot": {
@@ -6529,19 +7414,69 @@ var HaExportAddon = class extends BaseAddon {
 				tags: { deviceId },
 				meta: { cancelled: mine.length }
 			});
-			return true;
+		} else {
+			await this.ctx.api.notificationRules.createSnooze.mutate({ snooze: {
+				scope: "device",
+				deviceId,
+				durationMinutes: minutes
+			} });
+			this.ctx.logger.info("ha-export: snoozed from Home Assistant", {
+				tags: { deviceId },
+				meta: { minutes }
+			});
 		}
-		await this.ctx.api.notificationRules.createSnooze.mutate({ snooze: {
-			scope: "device",
-			deviceId,
-			durationMinutes: minutes
-		} });
-		this.ctx.logger.info("ha-export: snoozed from Home Assistant", {
-			tags: { deviceId },
-			meta: { minutes }
-		});
+		/**
+		* Republish right away — the select is otherwise stale for up to
+		* `reconcileIntervalSec` after a write Home Assistant itself made
+		* (Task B1 passo 4).
+		*/
+		await this.republishSnooze(deviceId);
 		return true;
 	}
+	/** Push `snooze`'s current state for one camera, outside the reconcile cadence. */
+	async republishSnooze(deviceId) {
+		const key = this.keyByDeviceId.get(deviceId);
+		if (key === void 0) return;
+		try {
+			const { snoozes } = await this.ctx.api.notificationRules.listSnoozes.query({});
+			this.push(deviceId, projectSnooze(key, latestDeviceSnoozeWindow(snoozes, deviceId)));
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not republish snooze after a write from Home Assistant", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+		}
+	}
+	/**
+	* The global `select` on *Notification Center* (Task D4) — `scope: 'all'`,
+	* the same authority `applySnooze` already writes for a camera. `Off`
+	* cancels every global snooze, exactly as a camera's `Off` cancels its own.
+	*/
+	async applyGlobalSnooze(minutes) {
+		if (minutes === null) {
+			const { snoozes } = await this.ctx.api.notificationRules.listSnoozes.query({});
+			const mine = snoozes.filter((snooze) => snooze.scope === "all");
+			for (const snooze of mine) await this.ctx.api.notificationRules.cancelSnooze.mutate({ snoozeId: snooze.id });
+			this.ctx.logger.info("ha-export: cancelled the global snooze from Home Assistant", { meta: { cancelled: mine.length } });
+		} else {
+			await this.ctx.api.notificationRules.createSnooze.mutate({ snooze: {
+				scope: "all",
+				durationMinutes: minutes
+			} });
+			this.ctx.logger.info("ha-export: snoozed globally from Home Assistant", { meta: { minutes } });
+		}
+		await this.republishGlobalSnooze();
+	}
+	/** Push the global `snooze` select's current state, outside the reconcile cadence. */
+	async republishGlobalSnooze() {
+		try {
+			const { snoozes } = await this.ctx.api.notificationRules.listSnoozes.query({});
+			const ncKey = deviceKeyFor(NOTIFICATION_CENTER_STABLE_ID);
+			await this.pushSynthetic(projectSnooze(ncKey, latestGlobalSnoozeWindow(snoozes)), this.enabledBrokerIds());
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not republish the global snooze after a write from Home Assistant", { meta: { error: errMsg(err) } });
+		}
+	}
 	/**
 	* A public, signed, expiring route Home Assistant can fetch bytes from.
 	*
@@ -6934,6 +7869,37 @@ function toSnapshot(raw) {
 	for (const [cap, slice] of Object.entries(raw)) if (slice !== null && typeof slice === "object") out[cap] = { ...slice };
 	return out;
 }
+/** `CameraStatus` → the narrower shape `projectCameraStatus` needs. */
+function toCameraStatusInput(status) {
+	return {
+		switchedOff: status.switchedOff,
+		degradedStages: status.degraded.map((d) => d.stage),
+		recording: status.recording === null ? null : { active: status.recording.active }
+	};
+}
+/**
+* The ACTIVE window for one scope, from a flat `listSnoozes` answer.
+*
+* "Active" is `expiresAt` in the future — `listSnoozes` never sweeps expired
+* rows (expiry is a comparison, not a job), so a reader that skipped this
+* would keep publishing a duration that ended hours ago. When several windows
+* match, the one expiring LATEST wins: that is the duration still in effect.
+*/
+function latestSnoozeWindow(snoozes, matches, now) {
+	const latest = snoozes.filter((s) => matches(s) && s.expiresAt > now).reduce((top, s) => top === null || s.expiresAt > top.expiresAt ? s : top, null);
+	return latest === null ? null : {
+		startedAt: latest.startedAt,
+		expiresAt: latest.expiresAt
+	};
+}
+/** The camera's own `scope: 'device'` snoozes (Task B1). */
+function latestDeviceSnoozeWindow(snoozes, deviceId) {
+	return latestSnoozeWindow(snoozes, (s) => s.scope === "device" && s.deviceId === deviceId, Date.now());
+}
+/** The global `scope: 'all'` snooze (Task D4). */
+function latestGlobalSnoozeWindow(snoozes) {
+	return latestSnoozeWindow(snoozes, (s) => s.scope === "all", Date.now());
+}
 function toCountRecord(raw) {
 	if (raw === null || typeof raw !== "object") return {};
 	const out = {};