@camstack/addon-provider-homeassistant 1.2.20 → 1.2.22

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

@@ -1,4 +1,4 @@
-import { G as oauthIntegrationCapability, O as deviceExportCapability, bt as string, c as addonRoutesCapability, ct as BaseAddon, i as CameraSwitchIdSchema, r as COCO_TO_MACRO, v as buildAddonRouteProvider, wt as EventCategory } from "../dist-BSQpoIVg.mjs";
+import { G as oauthIntegrationCapability, O as deviceExportCapability, bt as string, c as addonRoutesCapability, ct as BaseAddon, i as CameraSwitchIdSchema, r as COCO_TO_MACRO, v as buildAddonRouteProvider, wt as EventCategory } from "../dist-CfOPccIv.mjs";
 import { createHmac, timingSafeEqual } from "node:crypto";
 //#region src/ha-export/topics.ts
 /**
@@ -333,8 +333,25 @@ function cameraSpecs(device) {
 			label: "Audio level",
 			unit: "dBFS",
 			icon: "mdi:volume-high",
-			enabledByDefault: false
+			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",
@@ -1569,6 +1586,10 @@ function projectAudioWindow(deviceKey, input) {
 		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"),
@@ -1576,6 +1597,293 @@ function projectAudioWindow(deviceKey, input) {
 	});
 	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";
 /**
@@ -1669,6 +1977,12 @@ var HaExportAddon = class extends BaseAddon {
 	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
@@ -1936,19 +2250,45 @@ var HaExportAddon = class extends BaseAddon {
 		if (deviceKey === void 0) return;
 		const frame = readRecordField(data, "frame");
 		if (frame === null || typeof frame !== "object" || Array.isArray(frame)) return;
-		const dbfs = readNumber(readRecord(frame, "level"), "dbfs");
+		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 className = readString(entry, "className");
-			const confidence = readNumber(entry, "confidence");
-			return className === null || confidence === null ? [] : [{
-				className,
-				confidence
+			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 } : {}
+			...dbfs !== null ? { dbfs } : {},
+			...rms !== null ? { rms } : {}
 		}));
 	}
 	onZoneOccupancy(data) {
@@ -2106,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,
@@ -2134,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);
@@ -2308,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
@@ -2431,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", {
@@ -2781,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 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-provider-homeassistant",
-  "version": "1.2.20",
+  "version": "1.2.22",
   "description": "Home Assistant device provider addon for CamStack",
   "keywords": [
     "camstack",