@camstack/addon-provider-homeassistant 1.2.19 → 1.2.21

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

@@ -143,6 +143,16 @@ var ZONE_MACROS = [
 * So the flag is a required field on every spec. A new entity — or the
 * synthetic devices the design addendum still owes — cannot inherit a
 * camera's pressure valve by accident.
+*
+* **`last_image` is exempt, on every level of the fan-out** (operator,
+* 2026-08-09). The valve exists to stop a fleet's worth of entities
+* arriving switched on, but the picture IS the reason to look at a
+* notification: an operator who wires `person_detected` into an
+* automation wants the frame with it, and having to hunt through HA's
+* disabled-entity list per camera per macro per zone is the opposite of
+* what the export is for. The three `*_last_image` entities — camera,
+* per macro, per zone × macro — therefore ship enabled. They cost one
+* entity each and carry a signed URL, not bytes.
 */
 /**
 * The snooze surface, as a `select`.
@@ -213,7 +223,14 @@ function deviceBlock(device) {
 */
 function zoneSpecs(zone) {
 	const slug = toSlug(zone.id);
-	const specs = [];
+	const specs = [{
+		entity: `${slug}_objects`,
+		platform: "sensor",
+		label: `${zone.name} objects`,
+		uniqueSuffix: `${zone.id}_objects`,
+		icon: "mdi:counter",
+		enabledByDefault: true
+	}];
 	for (const macro of ZONE_MACROS) {
 		const label = `${zone.name} ${macro}`;
 		specs.push({
@@ -228,7 +245,7 @@ function zoneSpecs(zone) {
 			platform: "image",
 			label: `${label} last image`,
 			uniqueSuffix: `${zone.id}_${macro}_last_image`,
-			enabledByDefault: false
+			enabledByDefault: true
 		}, {
 			entity: `${slug}_${macro}_last_detection`,
 			platform: "sensor",
@@ -270,6 +287,71 @@ function cameraSpecs(device) {
 			label: "Last image",
 			enabledByDefault: true
 		},
+		(
+		/**
+		* The SCENE — everything on camera, in a zone or not, and including
+		* confirmed stationary objects (they are still there). The frame-wide
+		* scope of the same occupancy snapshot the per-zone counters come from,
+		* which was computed and simply never projected.
+		*/
+		{
+			entity: "objects",
+			platform: "sensor",
+			label: "Objects",
+			icon: "mdi:counter",
+			enabledByDefault: true
+		}),
+		(
+		/**
+		* 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.
+		*
+		* `audio_last_sound`, NOT `audio_last_label`: `<macro>_last_label` is the
+		* TRACK path's naming, reserved for the macros that carry an
+		* identification (`LABELLED_MACROS`), and `audio` is deliberately not one
+		* of them because the track lifecycle has no label for it. Reusing that
+		* name would put two sources on one topic — the classifier here and the
+		* track projector there — which is the two-knobs failure this repo keeps
+		* paying for. Different source, different entity, different name.
+		*
+		* dBFS is negative-going (0 = full scale), so silence reads as a large
+		* negative number rather than as a missing value. There is no unit
+		* declared: HA has no dBFS device class, and mislabelling it `dB` would
+		* put a plausible wrong unit on a dashboard.
+		*/
+		{
+			entity: "audio_last_sound",
+			platform: "sensor",
+			label: "Audio last sound",
+			icon: "mdi:ear-hearing",
+			enabledByDefault: true
+		}),
+		{
+			entity: "audio_volume",
+			platform: "sensor",
+			label: "Audio level",
+			unit: "dBFS",
+			icon: "mdi:volume-high",
+			enabledByDefault: true
+		},
+		(
+		/**
+		* BOTH levels, because they answer different questions and neither
+		* derives from the other in a way an operator should have to do in a
+		* template. dBFS is logarithmic and negative-going — the one to threshold
+		* on ("louder than -30") — while RMS is the linear amplitude, which is
+		* what a graph of relative loudness wants. The analyzer computes both in
+		* the same window; publishing one and making the other a `log10` template
+		* in Home Assistant is work we already did.
+		*/
+		{
+			entity: "audio_level_rms",
+			platform: "sensor",
+			label: "Audio level (RMS)",
+			icon: "mdi:waveform",
+			enabledByDefault: true
+		}),
 		{
 			entity: "last_detection",
 			platform: "sensor",
@@ -345,6 +427,60 @@ function cameraSpecs(device) {
 			enabledByDefault: true
 		});
 	}
+	/**
+	* The doorbell, when the operator has bound the cap to this camera.
+	*
+	* A press is not a detection macro — it is not something the pipeline
+	* classifies — so it is NOT in `EXPORTED_MACROS`, and `MACROS_NOT_EXPORTED`
+	* says a doorbell is an actuator on its own device. Both stay true for the
+	* BUTTON accessory. What was missing is the camera case: a camera with the
+	* `doorbell` cap bound rings, and the operator automates on the ring the same
+	* way they automate on `person_detected`. Reolink's own doorbell is exactly
+	* this shape (`ReolinkSimpleEvent.type === 'doorbell'` at the camera level),
+	* and so is any camera the `virtual-doorbell` wrapper is pointed at.
+	*
+	* Every entity here is fed by the `doorbell` runtime-state slice
+	* (`lastPressedAt`, `pressCountSinceStart`) on `device.state-changed` —
+	* the same road the `battery` slice already travels.
+	*
+	* **`doorbell_last_image` is owed, and the frame for it already exists.**
+	* A press DOES have a picture: `sensor-marker-projector.ts` materialises a
+	* synthetic marker track carrying a `keyFrameSmall` of the camera, taken
+	* before the track is persisted, and the notification names that track as
+	* its media owner. What is missing is only the road to THIS addon:
+	* `persistSyntheticTrack` writes the row directly and emits no
+	* `pipeline-analytics.track-lifecycle`, which is the single event the export
+	* listens to for frames. So the export never hears about the marker while
+	* the notification centre shows its photo — measured 2026-08-09.
+	*
+	* It is NOT fixed by taking a second snapshot here at push time: the marker
+	* projector's own record argues that out (one snapshot, one owner, one
+	* persistence point — the producer's), and a second photograph of a doorway
+	* seconds after the ring is a different picture from the one in the
+	* notification. The fix belongs upstream, at the point that already owns the
+	* frame. Named here rather than shipped as an entity nothing feeds.
+	*/
+	if (device.boundCaps.includes("doorbell")) specs.push({
+		entity: "doorbell_pressed",
+		platform: "binary_sensor",
+		label: "Doorbell pressed",
+		deviceClass: "occupancy",
+		enabledByDefault: true
+	}, {
+		entity: "doorbell_last_pressed",
+		platform: "sensor",
+		label: "Doorbell last pressed",
+		deviceClass: "timestamp",
+		icon: "mdi:bell-ring",
+		enabledByDefault: true
+	}, {
+		entity: "doorbell_press_count",
+		platform: "sensor",
+		label: "Doorbell presses since restart",
+		icon: "mdi:counter",
+		entityCategory: "diagnostic",
+		enabledByDefault: false
+	});
 	specs.push({
 		entity: "snooze",
 		platform: "select",
@@ -365,13 +501,19 @@ function cameraSpecs(device) {
 			entity: `${macro}_last_image`,
 			platform: "image",
 			label: `${label} last image`,
-			enabledByDefault: false
+			enabledByDefault: true
 		}, {
 			entity: `${macro}_last_detection`,
 			platform: "sensor",
 			label: `${label} last detection`,
 			deviceClass: "timestamp",
 			enabledByDefault: false
+		}, {
+			entity: `${macro}_objects`,
+			platform: "sensor",
+			label: `${label} objects`,
+			icon: "mdi:counter",
+			enabledByDefault: false
 		});
 		if (LABELLED_MACROS.includes(macro)) specs.push({
 			entity: `${macro}_last_label`,
@@ -1320,6 +1462,10 @@ function projectZoneOccupancy(deviceKey, input) {
 	const values = [];
 	for (const zone of input.zones) {
 		const slug = toSlug(zone.zoneId);
+		values.push({
+			topic: stateTopic(deviceKey, `${slug}_objects`),
+			value: String(zone.totalObjects)
+		});
 		const totals = new Map(ZONE_MACROS.map((macro) => [macro, 0]));
 		for (const [className, count] of Object.entries(zone.byClass)) {
 			const macro = macroOf(className);
@@ -1331,6 +1477,22 @@ function projectZoneOccupancy(deviceKey, input) {
 			value: String(count)
 		});
 	}
+	if (input.scene !== void 0) {
+		values.push({
+			topic: stateTopic(deviceKey, "objects"),
+			value: String(input.scene.totalObjects)
+		});
+		const totals = new Map(EXPORTED_MACROS.map((macro) => [macro, 0]));
+		for (const [className, count] of Object.entries(input.scene.byClass)) {
+			const macro = macroOf(className);
+			if (macro === null || !totals.has(macro)) continue;
+			totals.set(macro, (totals.get(macro) ?? 0) + count);
+		}
+		for (const [macro, count] of totals) values.push({
+			topic: stateTopic(deviceKey, `${macro}_objects`),
+			value: String(count)
+		});
+	}
 	return values;
 }
 function projectBatterySlice(deviceKey, slice) {
@@ -1366,6 +1528,362 @@ function projectCameraSwitches(deviceKey, switches) {
 		value: bool(sw.enabled)
 	}));
 }
+/**
+* The doorbell slice → its three entities.
+*
+* A press is a PULSE: the slice carries `lastPressedAt`, never a
+* `pressed: true/false`. `doorbell_pressed` is therefore driven by the
+* caller, which knows whether this projection is a fresh press or a
+* reconcile re-read — the same shape `projectMotion` already uses, and the
+* reason the flag is a parameter rather than derived from a timestamp
+* comparison here (a pure function that reads the clock is a pure function
+* that behaves differently in a test).
+*
+* `lastPressedAt: null` publishes NOTHING for the timestamp: HA renders an
+* empty timestamp sensor as `unknown`, which is honest, whereas `0` would
+* render as 1 January 1970 on the operator's dashboard.
+*/
+function projectDoorbellSlice(deviceKey, slice, pressed) {
+	const values = [{
+		topic: stateTopic(deviceKey, "doorbell_pressed"),
+		value: bool(pressed)
+	}, {
+		topic: stateTopic(deviceKey, "doorbell_press_count"),
+		value: String(slice.pressCountSinceStart)
+	}];
+	if (slice.lastPressedAt !== null) values.push({
+		topic: stateTopic(deviceKey, "doorbell_last_pressed"),
+		value: new Date(slice.lastPressedAt).toISOString()
+	});
+	return values;
+}
+/**
+* One audio window → the audio entities.
+*
+* This is the source the catalog's `audio_detected` was always missing.
+* It had only the track lifecycle, which rarely carries an audio macro, so
+* the entity existed and effectively never moved — the note in this
+* package's CLAUDE.md said so without naming the event. The event is
+* `pipeline.audio-inference-result`, and it carries both halves an
+* operator asks for: WHAT was heard and HOW LOUD.
+*
+* The label is the HIGHEST-CONFIDENCE detection of the window, not the
+* first: the analyzer's array order is its own business and depending on
+* it would make the exported label change with an unrelated refactor.
+*
+* A window with no detections publishes NO label. It does not publish an
+* empty string: HA renders that as a valid state, so a quiet minute would
+* blank the last thing heard instead of leaving it — and "what was that
+* noise" is asked after the noise has stopped.
+*
+* The level is published on EVERY window, silence included. That is the
+* point of a volume entity: a flat line is a reading, and dBFS is
+* negative-going (0 = full scale), so no value can be mistaken for one.
+*/
+function projectAudioWindow(deviceKey, input) {
+	const values = [];
+	if (input.dbfs !== void 0 && Number.isFinite(input.dbfs)) values.push({
+		topic: stateTopic(deviceKey, "audio_volume"),
+		value: String(Math.round(input.dbfs * 10) / 10)
+	});
+	if (input.rms !== void 0 && Number.isFinite(input.rms)) values.push({
+		topic: stateTopic(deviceKey, "audio_level_rms"),
+		value: String(Math.round(input.rms * 1e4) / 1e4)
+	});
+	const best = input.detections.reduce((top, d) => top === null || d.confidence > top.confidence ? d : top, null);
+	if (best !== null) values.push({
+		topic: stateTopic(deviceKey, "audio_last_sound"),
+		value: best.className
+	});
+	return values;
+}
+//#endregion
+//#region src/ha-export/synthetic-devices.ts
+/**
+* Synthetic devices — what belongs to the SERVER, exported as devices that
+* exist inside Home Assistant and nowhere else.
+*
+* They are **not camstack devices**, deliberately (operator, 2026-08-04 and
+* again 2026-08-09). They carry rule switches, cluster monitoring and addon
+* health, none of which is a device in camstack's model; putting them in the
+* device list would fill it with things that are not devices. So they are built
+* HERE, by the exporter, and they have no `deviceId`.
+*
+* A LIST, not two special cases. The spec is explicit that the concept is
+* repeatable and more will be added when something needs a home — a one-off
+* would have to be refactored the first time a third is wanted. Adding one is
+* adding an entry to {@link SYNTHETIC_DEVICES} plus its projection.
+*
+* **Their values are RECONCILE-ONLY, on purpose.** Cluster CPU, memory, addon
+* counts and rule state are polled statistics, not events: there is no
+* `nodes.cpu-changed` to subscribe to, and inventing one to make this look
+* event-driven would be a second authority for numbers the topology already
+* owns. They refresh on the reconcile cadence (`reconcileIntervalSec`, 300s by
+* default), which is also what makes them self-healing after a Home Assistant
+* restart.
+*
+* The identity rules are the same wire format as every other device
+* (`../CLAUDE.md`): `device_id` is `camstack-<stableId>` and `unique_id` is
+* `<stableId>_<entity>`. The stable ids here are prefixed `synthetic-` so they
+* can never collide with a real device's, whatever a provider mints.
+*/
+/** The stable id of the notification-centre device. A WIRE FORMAT. */
+var NOTIFICATION_CENTER_STABLE_ID = "synthetic-notification-center";
+/** The stable id of the server device. A WIRE FORMAT. */
+var SERVER_STABLE_ID = "synthetic-server";
+var SYNTHETIC_STABLE_IDS = [NOTIFICATION_CENTER_STABLE_ID, SERVER_STABLE_ID];
+/** Is this device key one of ours? Used by the command route. */
+function isSyntheticDeviceKey(deviceKey) {
+	return SYNTHETIC_STABLE_IDS.some((id) => deviceKeyFor(id) === deviceKey);
+}
+/**
+* Everything a synthetic device exports arrives ENABLED.
+*
+* The pressure valve exists for the camera fan-out — three zones is ~73
+* entities and the fleet is ~880. There is no fan-out here: the largest of
+* these is one switch per notification rule, and a rule the operator wrote is
+* a rule they want to reach. Shipping them disabled would repeat the bug that
+* exported a thermometer's temperature switched off.
+*/
+function buildComponents(stableId, specs) {
+	const deviceKey = deviceKeyFor(stableId);
+	const cmps = {};
+	for (const spec of specs) cmps[toComponentKey(spec.platform, spec.entity)] = {
+		platform: spec.platform,
+		unique_id: `${stableId}_${spec.entity}`,
+		name: spec.label,
+		...spec.platform === "button" ? {} : { state_topic: stateTopic(deviceKey, spec.entity) },
+		...spec.writable === true ? { command_topic: commandTopic(deviceKey, spec.entity) } : {},
+		...spec.deviceClass !== void 0 ? { device_class: spec.deviceClass } : {},
+		...spec.unit !== void 0 ? { unit_of_measurement: spec.unit } : {},
+		...spec.icon !== void 0 ? { icon: spec.icon } : {},
+		...spec.options !== void 0 ? { options: spec.options } : {},
+		...spec.entityCategory !== void 0 ? { entity_category: spec.entityCategory } : {},
+		...spec.platform === "binary_sensor" || spec.platform === "switch" ? {
+			payload_on: "true",
+			payload_off: "false"
+		} : {}
+	};
+	return cmps;
+}
+function plan(stableId, name, specs) {
+	return {
+		deviceKey: deviceKeyFor(stableId),
+		deviceId: null,
+		dev: {
+			ids: [deviceKeyFor(stableId)],
+			name,
+			mf: "CamStack",
+			mdl: "Synthetic"
+		},
+		cmps: buildComponents(stableId, specs)
+	};
+}
+/**
+* The rule switch entity for a rule id.
+*
+* Slugged, because a rule id is free text and an entity segment is not. The
+* `unique_id` is derived from the rule ID and never its NAME, so a renamed rule
+* keeps every automation pointed at it — the friendly name changes in Home
+* Assistant and nothing else does.
+*/
+function ruleEntity(ruleId) {
+	return `rule_${toSlug(ruleId)}`;
+}
+/** `rule_<slug>` → the rule id it came from, or null. */
+function ruleIdFromEntity(entity, rules) {
+	return rules.find((rule) => ruleEntity(rule.id) === entity)?.id ?? null;
+}
+function notificationCenterSpecs(input) {
+	return [
+		{
+			entity: "snoozed",
+			platform: "binary_sensor",
+			label: "Notifications snoozed",
+			icon: "mdi:bell-sleep"
+		},
+		{
+			entity: "rules_enabled",
+			platform: "sensor",
+			label: "Rules enabled",
+			icon: "mdi:counter",
+			entityCategory: "diagnostic"
+		},
+		...input.rules.map((rule) => ({
+			entity: ruleEntity(rule.id),
+			platform: "switch",
+			label: rule.name,
+			writable: true,
+			icon: "mdi:bell-cog"
+		}))
+	];
+}
+function serverSpecs(input) {
+	return [
+		{
+			entity: "cluster_healthy",
+			platform: "binary_sensor",
+			label: "Cluster healthy",
+			icon: "mdi:server-network"
+		},
+		{
+			entity: "nodes_online",
+			platform: "sensor",
+			label: "Nodes online",
+			icon: "mdi:server"
+		},
+		{
+			entity: "nodes_total",
+			platform: "sensor",
+			label: "Nodes total",
+			icon: "mdi:server"
+		},
+		{
+			entity: "addons_healthy",
+			platform: "binary_sensor",
+			label: "Addons healthy",
+			icon: "mdi:puzzle-check"
+		},
+		{
+			entity: "addons_running",
+			platform: "sensor",
+			label: "Addons running",
+			icon: "mdi:puzzle"
+		},
+		{
+			entity: "addons_failed",
+			platform: "sensor",
+			label: "Addons failed",
+			icon: "mdi:puzzle-remove"
+		},
+		{
+			entity: "server_version",
+			platform: "sensor",
+			label: "Server version",
+			icon: "mdi:tag",
+			entityCategory: "diagnostic"
+		},
+		{
+			entity: "update_available",
+			platform: "binary_sensor",
+			label: "Update available",
+			deviceClass: "update",
+			entityCategory: "diagnostic"
+		},
+		...input.nodes.flatMap((node) => {
+			const slug = toSlug(node.id);
+			return [
+				{
+					entity: `${slug}_online`,
+					platform: "binary_sensor",
+					label: `${node.name} online`,
+					deviceClass: "connectivity"
+				},
+				{
+					entity: `${slug}_cpu`,
+					platform: "sensor",
+					label: `${node.name} CPU`,
+					unit: "%",
+					icon: "mdi:cpu-64-bit"
+				},
+				{
+					entity: `${slug}_memory`,
+					platform: "sensor",
+					label: `${node.name} memory`,
+					unit: "%",
+					icon: "mdi:memory"
+				},
+				{
+					entity: `${slug}_uptime`,
+					platform: "sensor",
+					label: `${node.name} uptime`,
+					deviceClass: "timestamp"
+				}
+			];
+		})
+	];
+}
+/** Every synthetic device, in declaration order. */
+function syntheticPlans(input) {
+	return [plan(NOTIFICATION_CENTER_STABLE_ID, "Notification Center", notificationCenterSpecs(input)), plan(SERVER_STABLE_ID, "CamStack Server", serverSpecs(input))];
+}
+/**
+* Every synthetic value, for the reconcile to push.
+*
+* Uptime is published as an ISO timestamp of the BOOT INSTANT, not as a
+* seconds counter: HA's `timestamp` device class renders "3 days ago" and keeps
+* doing so between reconciles, whereas a seconds number would sit frozen at
+* whatever it was 300 seconds ago and read as a stalled machine.
+*/
+function projectSynthetic(input, nowMs) {
+	const nc = deviceKeyFor(NOTIFICATION_CENTER_STABLE_ID);
+	const srv = deviceKeyFor(SERVER_STABLE_ID);
+	const online = input.nodes.filter((node) => node.online);
+	const values = [
+		{
+			topic: stateTopic(nc, "snoozed"),
+			value: String(input.snoozed)
+		},
+		{
+			topic: stateTopic(nc, "rules_enabled"),
+			value: String(input.rules.filter((rule) => rule.enabled).length)
+		},
+		...input.rules.map((rule) => ({
+			topic: stateTopic(nc, ruleEntity(rule.id)),
+			value: String(rule.enabled)
+		})),
+		{
+			topic: stateTopic(srv, "cluster_healthy"),
+			value: String(online.length === input.nodes.length)
+		},
+		{
+			topic: stateTopic(srv, "nodes_online"),
+			value: String(online.length)
+		},
+		{
+			topic: stateTopic(srv, "nodes_total"),
+			value: String(input.nodes.length)
+		},
+		{
+			topic: stateTopic(srv, "addons_healthy"),
+			value: String(input.addonsFailed === 0)
+		},
+		{
+			topic: stateTopic(srv, "addons_running"),
+			value: String(input.addonsRunning)
+		},
+		{
+			topic: stateTopic(srv, "addons_failed"),
+			value: String(input.addonsFailed)
+		},
+		{
+			topic: stateTopic(srv, "server_version"),
+			value: input.serverVersion
+		},
+		{
+			topic: stateTopic(srv, "update_available"),
+			value: String(input.updateAvailable)
+		}
+	];
+	for (const node of input.nodes) {
+		const slug = toSlug(node.id);
+		values.push({
+			topic: stateTopic(srv, `${slug}_online`),
+			value: String(node.online)
+		}, {
+			topic: stateTopic(srv, `${slug}_cpu`),
+			value: String(Math.round(node.cpuPercent))
+		}, {
+			topic: stateTopic(srv, `${slug}_memory`),
+			value: String(Math.round(node.memoryPercent))
+		});
+		if (node.online && node.uptime > 0) values.push({
+			topic: stateTopic(srv, `${slug}_uptime`),
+			value: (/* @__PURE__ */ new Date(nowMs - node.uptime * 1e3)).toISOString()
+		});
+	}
+	return values;
+}
 /** The `BrokerInfo.kind` tag the Home Assistant provider stamps. */
 var HA_BROKER_KIND = "home-assistant";
 /**
@@ -1420,6 +1938,8 @@ var ADDON_ID = "homeassistant-export";
 /** Where the custom component registers its push view inside HA. */
 var PUSH_PATH = "/api/camstack/push";
 var MEDIA_ROUTE_PREFIX = `/addon/${ADDON_ID}/ha-media`;
+/** How long `doorbell_pressed` stays on before its OFF edge is published. */
+var DOORBELL_PULSE_MS = 5e3;
 /** The hub's API port — where the data plane is reverse-proxied. */
 var HUB_API_PORT = 4443;
 /** One PTZ button press, as a relative move. */
@@ -1451,8 +1971,18 @@ var HaExportAddon = class extends BaseAddon {
 	reconcilePending = null;
 	lastError;
 	entityCount = 0;
+	/** deviceId → the `lastPressedAt` already rung, so a re-read does not ring again. */
+	lastDoorbellPressAt = /* @__PURE__ */ new Map();
+	/** deviceId → the pending OFF edge. HA releases nothing on its own. */
+	doorbellReleaseTimers = /* @__PURE__ */ new Map();
 	unclassified = [];
 	/**
+	* The rules as of the last reconcile, so a command arriving on
+	* `rule_<slug>` can be turned back into the rule id it came from. Refreshed
+	* whenever the synthetic devices are, never written to.
+	*/
+	syntheticRules = [];
+	/**
 	* A link that returned repairs NOW, not at the next periodic pass.
 	*
 	* `PushClient` drops its dedup cache the moment Home Assistant answers
@@ -1493,6 +2023,8 @@ var HaExportAddon = class extends BaseAddon {
 		this.startTimer();
 		this.ctx.addDisposer(async () => {
 			this.stopTimer();
+			for (const timer of this.doorbellReleaseTimers.values()) clearTimeout(timer);
+			this.doorbellReleaseTimers.clear();
 			this.reachability.dispose();
 			for (const link of this.links.values()) await link.client.dispose();
 			this.links.clear();
@@ -1549,6 +2081,15 @@ var HaExportAddon = class extends BaseAddon {
 		this.subscribe({ category: EventCategory.MotionOnMotionChanged }, (event) => {
 			this.onMotion(event.data);
 		});
+		/**
+		* The audio window. This is the source `audio_detected` never had: it was
+		* fed only by the track lifecycle, which rarely carries an audio macro, so
+		* the entity existed and effectively never moved. It also carries the
+		* window LEVEL, which nothing else on the export path does.
+		*/
+		this.subscribe({ category: EventCategory.PipelineAudioInferenceResult }, (event) => {
+			this.onAudioWindow(event.data);
+		});
 		this.subscribe({ category: EventCategory.PipelineAnalyticsTrackLifecycle }, (event) => {
 			this.onTrackLifecycle(event.data);
 		});
@@ -1596,6 +2137,40 @@ var HaExportAddon = class extends BaseAddon {
 			}));
 			return;
 		}
+		if (capName === "doorbell") {
+			/**
+			* A press is a PULSE — the slice carries `lastPressedAt`, never a
+			* boolean. `doorbell_pressed` is therefore ON only when THIS delivery
+			* advanced the timestamp, and the previous value is remembered per
+			* device rather than compared against the clock: a reconcile re-read of
+			* an unchanged slice must not ring the doorbell again in Home Assistant,
+			* and a press that arrives while the export was restarting must still
+			* ring once. HA auto-releases nothing, so the OFF edge is published on a
+			* short timer — without it the binary sensor latches on for ever and the
+			* next press produces no edge to automate on.
+			*/
+			const lastPressedAt = readNumber(slice, "lastPressedAt");
+			const pressCountSinceStart = readNumber(slice, "pressCountSinceStart") ?? 0;
+			const previous = this.lastDoorbellPressAt.get(deviceId) ?? null;
+			const pressed = lastPressedAt !== null && lastPressedAt !== previous;
+			if (pressed) this.lastDoorbellPressAt.set(deviceId, lastPressedAt);
+			this.push(deviceId, projectDoorbellSlice(deviceKey, {
+				lastPressedAt,
+				pressCountSinceStart
+			}, pressed));
+			if (pressed) {
+				const existing = this.doorbellReleaseTimers.get(deviceId);
+				if (existing !== void 0) clearTimeout(existing);
+				this.doorbellReleaseTimers.set(deviceId, setTimeout(() => {
+					this.doorbellReleaseTimers.delete(deviceId);
+					this.push(deviceId, projectDoorbellSlice(deviceKey, {
+						lastPressedAt,
+						pressCountSinceStart
+					}, false));
+				}, DOORBELL_PULSE_MS));
+			}
+			return;
+		}
 		if (capName === "motion") {
 			const detected = slice["detected"];
 			const lastDetectedAt = readNumber(slice, "lastDetectedAt");
@@ -1668,6 +2243,54 @@ var HaExportAddon = class extends BaseAddon {
 		}
 		this.push(deviceId, values);
 	}
+	onAudioWindow(data) {
+		const deviceId = readNumber(data, "deviceId");
+		if (deviceId === null) return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		const frame = readRecordField(data, "frame");
+		if (frame === null || typeof frame !== "object" || Array.isArray(frame)) return;
+		const level = readRecord(frame, "level");
+		const dbfs = readNumber(level, "dbfs");
+		const rms = readNumber(level, "rms");
+		const raw = readRecordField(frame, "detections");
+		/**
+		* An `AudioDetection` carries `macroClass` + `score` and its real sound
+		* class in `labels: ScoredLabel[]` — the enrichment chain. It has NO
+		* `className` and no `confidence`; reading those invented names mapped
+		* every window to `[]`, so `audio_last_sound` sat at `unknown` for ever
+		* while the analyzer was classifying happily (found 2026-08-09, symptom:
+		* "le audio labels sembrano non arrivare").
+		*
+		* The best LABEL wins over the macro: `audio` as a value tells an operator
+		* nothing, `dog` or `crying` is the whole point. Falls back to the macro
+		* class only when a detection carries no label at all.
+		*/
+		const detections = Array.isArray(raw) ? raw.flatMap((entry) => {
+			const labels = readRecordField(entry, "labels");
+			const best = Array.isArray(labels) ? labels.reduce((top, l) => {
+				const label = readString(l, "label");
+				const score = readNumber(l, "score") ?? 0;
+				if (label === null) return top;
+				return top === null || score > top.confidence ? {
+					className: label,
+					confidence: score
+				} : top;
+			}, null) : null;
+			if (best !== null) return [best];
+			const macro = readString(entry, "macroClass");
+			const score = readNumber(entry, "score");
+			return macro === null || score === null ? [] : [{
+				className: macro,
+				confidence: score
+			}];
+		}) : [];
+		this.push(deviceId, projectAudioWindow(deviceKey, {
+			detections,
+			...dbfs !== null ? { dbfs } : {},
+			...rms !== null ? { rms } : {}
+		}));
+	}
 	onZoneOccupancy(data) {
 		const deviceId = readNumber(data, "deviceId");
 		if (deviceId === null) return;
@@ -1681,11 +2304,20 @@ var HaExportAddon = class extends BaseAddon {
 			if (zoneId === null) return [];
 			return [{
 				zoneId,
+				totalObjects: readNumber(entry, "totalObjects") ?? 0,
 				byClass: toCountRecord(byClass)
 			}];
 		});
-		if (zones.length === 0) return;
-		this.push(deviceId, projectZoneOccupancy(deviceKey, { zones }));
+		const frame = readRecordField(data, "frame");
+		const scene = frame !== null && typeof frame === "object" && !Array.isArray(frame) ? {
+			totalObjects: readNumber(frame, "totalObjects") ?? 0,
+			byClass: toCountRecord(readRecord(frame, "byClass"))
+		} : void 0;
+		if (zones.length === 0 && scene === void 0) return;
+		this.push(deviceId, projectZoneOccupancy(deviceKey, {
+			zones,
+			...scene !== void 0 ? { scene } : {}
+		}));
 	}
 	/**
 	* Send a device's values to every broker it is exported to.
@@ -1814,12 +2446,35 @@ var HaExportAddon = class extends BaseAddon {
 					}
 				});
 			}
+			/**
+			* The synthetic devices — server-owned surfaces that are not camstack
+			* devices. They are appended to the SAME `exported` map so they travel
+			* the ordinary announce + push path: one code path for identity,
+			* batching and dedup, rather than a parallel one that would drift.
+			* `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();
+			if (synthetic !== null) for (const plan of syntheticPlans(synthetic)) {
+				exported.set(plan.deviceKey, {
+					plan,
+					deviceId: -1,
+					target: {
+						deviceId: -1,
+						type: "synthetic",
+						boundCaps: []
+					},
+					brokerIds: [...enabled]
+				});
+				entityCount += Object.keys(plan.cmps).length;
+			}
 			this.exported = exported;
 			this.keyByDeviceId = keyByDeviceId;
 			this.entityCount = entityCount;
 			this.unclassified = unclassifiedCaps([...allCaps]);
 			await this.announce(exported);
 			await this.pushFullState(exported, snapshots);
+			if (synthetic !== null) await this.pushSynthetic(projectSynthetic(synthetic, Date.now()), [...enabled]);
 			this.ctx.logger.info("ha-export: reconciled", { meta: {
 				reason,
 				brokers: enabled.length,
@@ -1842,6 +2497,69 @@ var HaExportAddon = class extends BaseAddon {
 	* that device only and can never take the loop — or the runner — down
 	* with it.
 	*/
+	/**
+	* Gather the synthetic devices' statistics.
+	*
+	* Best-effort per source: one API that does not answer costs its own
+	* entities for this pass, never the whole set — a hub whose
+	* `notificationRules` provider is restarting must still export its cluster
+	* health, which is exactly when an operator wants it.
+	*
+	* Returns `null` only when NOTHING answered, so the devices are not
+	* announced empty on a hub that is still booting.
+	*/
+	async buildSynthetic() {
+		const rules = await this.ctx.api.notificationRules.listRules.query({}).then((r) => r.rules.map((rule) => ({
+			id: rule.id,
+			name: rule.name,
+			enabled: rule.enabled
+		}))).catch((err) => {
+			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) => {
+			this.ctx.logger.warn("ha-export: could not read the cluster topology", { meta: { error: errMsg(err) } });
+			return null;
+		});
+		const addons = await this.ctx.api.addons.list.query().then((list) => {
+			let running = 0;
+			let failed = 0;
+			for (const addon of list) if (addon.health?.phase === "failed") failed += 1;
+			else running += 1;
+			return {
+				running,
+				failed
+			};
+		}).catch(() => null);
+		const server = await this.ctx.api.serverManagement.getServerPackageStatus.query().catch(() => null);
+		if (rules === null && nodes === null && addons === null && server === null) return null;
+		this.syntheticRules = rules ?? this.syntheticRules;
+		return {
+			rules: rules ?? this.syntheticRules,
+			snoozed: snoozes ?? false,
+			nodes: nodes ?? [],
+			addonsRunning: addons?.running ?? 0,
+			addonsFailed: addons?.failed ?? 0,
+			serverVersion: server?.runningVersion ?? server?.activeVersion ?? "unknown",
+			updateAvailable: server?.updateAvailable ?? false
+		};
+	}
+	/** Push the synthetic values to every enabled broker. */
+	async pushSynthetic(values, brokerIds) {
+		for (const brokerId of brokerIds) {
+			const link = this.links.get(brokerId);
+			if (link === void 0) continue;
+			for (const value of values) link.client.publishState(value.topic, value.value);
+		}
+	}
 	async announce(exported) {
 		for (const entry of exported.values()) for (const brokerId of entry.brokerIds) {
 			const link = this.links.get(brokerId);
@@ -1902,10 +2620,17 @@ var HaExportAddon = class extends BaseAddon {
 				enabled: sw.enabled
 			}))));
 			const occupancy = await this.ctx.api.zoneAnalytics.getCurrentSnapshot.query({ deviceId: entry.deviceId });
-			if (occupancy !== null) values.push(...projectZoneOccupancy(key, { zones: occupancy.zones.map((zone) => ({
-				zoneId: zone.zoneId,
-				byClass: toCountRecord(zone.byClass)
-			})) }));
+			if (occupancy !== null) values.push(...projectZoneOccupancy(key, {
+				zones: occupancy.zones.map((zone) => ({
+					zoneId: zone.zoneId,
+					totalObjects: zone.totalObjects,
+					byClass: toCountRecord(zone.byClass)
+				})),
+				scene: {
+					totalObjects: occupancy.frame.totalObjects,
+					byClass: toCountRecord(occupancy.frame.byClass)
+				}
+			}));
 		}
 		return values;
 	}
@@ -2009,7 +2734,26 @@ var HaExportAddon = class extends BaseAddon {
 			id: broker.id,
 			name: broker.name
 		}));
-		const pruned = pruneBrokers(this.config.membership, haBrokers.map((broker) => broker.id));
+		/**
+		* NEVER prune on an empty enumeration.
+		*
+		* `broker.list` is a fan-out union, so it answers `[]` for the whole window
+		* in which `provider-homeassistant` has not finished registering — and it
+		* registers its caps only at the END of an `initialize()` that restores 239
+		* devices. An empty list there means "I do not know yet", never "the
+		* operator deleted their instance", and the two were indistinguishable to
+		* this code: every boot pruned the membership to nothing and PERSISTED it,
+		* so the operator's exported cameras silently switched themselves off. Seen
+		* live on 2026-08-09 — two cameras exposed, `devices=4`, addon redeployed,
+		* `devices=2` and both switches back to `false` with no line anywhere.
+		*
+		* This is D49 exactly: a destructive step gated on a fallible read must not
+		* fire on the reading that destroys work. A broker that really was deleted
+		* is pruned on the next pass that returns a NON-empty list without it,
+		* which costs one interval and cannot cost the operator their config.
+		*/
+		const pruned = haBrokers.length === 0 ? this.config.membership : pruneBrokers(this.config.membership, haBrokers.map((broker) => broker.id));
+		if (haBrokers.length === 0 && Object.keys(this.config.membership).length > 0) this.ctx.logger.warn("ha-export: no Home Assistant broker answered — keeping the export membership rather than pruning it", { meta: { brokers: Object.keys(this.config.membership) } });
 		if (pruned !== this.config.membership || !sameBrokers(known, this.config.knownBrokers)) await this.updateGlobalSettings({
 			knownBrokers: known,
 			membership: pruned
@@ -2132,6 +2876,49 @@ var HaExportAddon = class extends BaseAddon {
 			reply.send({ error: "device not exported" });
 			return;
 		}
+		/**
+		* A synthetic device has no camstack device behind it, so
+		* `resolveCommand` — which routes by device type and bound caps — cannot
+		* speak for it. Its commands go straight to the authority that already
+		* owns the function, exactly as a camera switch does: the export writes
+		* `setRuleEnabled`, never a store of its own. A second knob that can
+		* disagree with the admin UI is worse than no knob (D62).
+		*/
+		if (isSyntheticDeviceKey(parsed.deviceKey)) {
+			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: {
+					topic,
+					entity: parsed.entity
+				} });
+				reply.status(422);
+				reply.send({ error: "unroutable command" });
+				return;
+			}
+			const enabled = value.toLowerCase() === "true";
+			try {
+				await this.ctx.api.notificationRules.setRuleEnabled.mutate({
+					ruleId,
+					enabled
+				});
+				this.ctx.logger.info("ha-export: notification rule toggled from Home Assistant", { meta: {
+					ruleId,
+					enabled
+				} });
+				await this.reconcile("synthetic-command");
+				reply.status(200);
+				reply.send({});
+			} catch (err) {
+				this.ctx.logger.warn("ha-export: could not apply a notification-rule toggle", { meta: {
+					ruleId,
+					enabled,
+					error: errMsg(err)
+				} });
+				reply.status(422);
+				reply.send({ error: "command not applied" });
+			}
+			return;
+		}
 		const command = resolveCommand(exported.target, parsed.entity, value);
 		if (command === null) {
 			this.ctx.logger.warn("ha-export: dropping an unroutable command", {
@@ -2482,13 +3269,34 @@ var HaExportAddon = class extends BaseAddon {
 		const idStr = String(deviceId);
 		let next = this.config.membership;
 		let touched = false;
-		for (const brokerId of this.enabledBrokerIds()) {
-			const key = `haExport:${deviceId}:${brokerId}`;
-			if (!(key in patch)) continue;
-			next = setExposed(next, brokerId, idStr, patch[key] === true);
+		/**
+		* Driven by the PATCH KEYS, not by the enabled-broker list.
+		*
+		* The key already carries the broker (`haExport:<deviceId>:<brokerId>`) —
+		* the operator could not have been shown the switch otherwise — so reading
+		* the broker from it needs no other state to be warm. Iterating
+		* `enabledBrokerIds()` instead made this depend on a read-through cache,
+		* and when that cache was cold the loop matched nothing, `touched` stayed
+		* false, and the method returned `{success: true}` HAVING DONE NOTHING.
+		* The admin UI showed the switch flip and it silently did not persist;
+		* measured live on 2026-08-09 with two cameras that would not stay
+		* exported. A no-op that reports success is worse than an error.
+		*/
+		const prefix = `haExport:${deviceId}:`;
+		for (const [key, value] of Object.entries(patch)) {
+			if (!key.startsWith(prefix)) continue;
+			const brokerId = key.slice(prefix.length);
+			if (brokerId.length === 0) continue;
+			next = setExposed(next, brokerId, idStr, value === true);
 			touched = true;
 		}
-		if (!touched) return { success: true };
+		if (!touched) {
+			this.ctx.logger.warn("ha-export: a device patch carried no export key — nothing applied", {
+				tags: { deviceId },
+				meta: { keys: Object.keys(patch) }
+			});
+			return { success: true };
+		}
 		await this.updateGlobalSettings({ membership: next });
 		this.ctx.logger.info("ha-export: per-broker export membership changed", {
 			tags: { deviceId },