@camstack/addon-provider-homeassistant 1.2.14 → 1.2.16

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

@@ -0,0 +1,2511 @@
+import { Ct as EventCategory, O as deviceExportCapability, c as addonRoutesCapability, i as CameraSwitchIdSchema, r as COCO_TO_MACRO, st as BaseAddon, v as buildAddonRouteProvider, yt as string } from "../dist-B04tcTnS.mjs";
+import { createHmac, timingSafeEqual } from "node:crypto";
+//#region src/ha-export/topics.ts
+/**
+* The topic grammar. Every topic in the export is built HERE.
+*
+* The previous HA exporter learned this the hard way: deriving one topic
+* by string-editing another (`stateTopic.replace(/\/[^/]+$/, '/availability')`)
+* broke the moment two components had different layouts. There is one
+* builder per topic kind and no exceptions.
+*
+* A topic is a wire format. `state` and `command` are matched verbatim by
+* the component, so a change here silently detaches every entity from its
+* value.
+*/
+/** Root of every topic. Namespaces the export inside HA's event bus. */
+var TOPIC_ROOT = "camstack";
+/** Prefix that turns a device's `stableId` into its HA `device_id`. */
+var DEVICE_KEY_PREFIX = "camstack-";
+/**
+* The HA `device_id` for a camstack device.
+*
+* Derived from `stableId`, never from the numeric id: numeric ids are
+* reallocated by a re-sync, and an operator who re-adopts a camera would
+* get a second HA device with every automation pointing at the orphan.
+*/
+function deviceKeyFor(stableId) {
+	return `${DEVICE_KEY_PREFIX}${stableId}`;
+}
+function stateTopic(deviceKey, entity) {
+	return `${TOPIC_ROOT}/${deviceKey}/${entity}`;
+}
+function commandTopic(deviceKey, entity) {
+	return `${TOPIC_ROOT}/${deviceKey}/${entity}/set`;
+}
+function parseCommandTopic(topic) {
+	const parts = topic.split("/");
+	if (parts.length !== 4) return null;
+	if (parts[0] !== "camstack") return null;
+	if (parts[3] !== "set") return null;
+	const deviceKey = parts[1];
+	const entity = parts[2];
+	if (deviceKey === void 0 || entity === void 0) return null;
+	if (deviceKey.length === 0 || entity.length === 0) return null;
+	return {
+		deviceKey,
+		entity
+	};
+}
+/** `Person last image` ← `person_last_image`. Display only, never an id. */
+function humanise(entity) {
+	const words = entity.replace(/[_-]+/g, " ").trim();
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+/**
+* `person_detected` → `person-detected`.
+*
+* Component keys are kebab; entity/topic segments are snake. They are two
+* different namespaces and conflating them produces entities that build
+* but never receive a value.
+*/
+function toComponentKey(platform, entity) {
+	return `${platform}-${entity.replace(/_/g, "-").replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+/** Lower-case, underscore-joined, diacritic-free. Ids only, never labels. */
+function toSlug(value) {
+	return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+//#endregion
+//#region src/ha-export/entity-catalog.ts
+/**
+* The entity catalog — pure. Device + zones + macros → the `cmps` set.
+*
+* No I/O lives here on purpose: this is the 1:1 mapping the design
+* agreed, and it is where the mapping is tested. A change to this file
+* changes what an operator sees in Home Assistant, so it is tested
+* rather than reasoned about.
+*
+* The split is principled, not expedient (design addendum):
+*
+*   - **Cameras** get a HAND-WRITTEN catalog, because their entities are
+*     projections of pipeline and notification-center output — there is
+*     no capability to derive `last_detection`, `last_label` or a
+*     per-zone count from.
+*   - **Every other kind** is DERIVED from the capability the device
+*     declares. A switch's state IS modelled by a cap; an alarm panel's
+*     state IS `AlarmStateSchema`.
+*
+* Two guards protect the half that a future change would silently break:
+* `MACROS_NOT_EXPORTED` and `CAPS_NOT_EXPORTED` force a written decision
+* for every macro and every mapped capability. Something declared that
+* nothing produces is the failure this repo keeps paying for.
+*/
+/**
+* The macro classes an operator automates on.
+*
+* Deliberately the macros and NOT the 21 fine classes: those include
+* `kite` and `toothbrush`, and 21 × 4 entities per camera buys nothing.
+*/
+var EXPORTED_MACROS = [
+	"motion",
+	"audio",
+	"person",
+	"vehicle",
+	"animal",
+	"package"
+];
+/**
+* Macros that carry an IDENTIFICATION: the recognised face for `person`,
+* the plate for `vehicle`, the sub-class for `animal`.
+*
+* `package`, `motion` and `audio` have no label, so the entity is NOT
+* created for them rather than created empty — an entity that can never
+* receive a value reads to an operator as a broken integration.
+*/
+var LABELLED_MACROS = [
+	"person",
+	"vehicle",
+	"animal"
+];
+/** Per zone the macro set is restricted — matching the reference. */
+var ZONE_MACROS = [
+	"person",
+	"vehicle",
+	"animal"
+];
+/**
+* `enabled_by_default: false` is a DECISION, taken per entity, never
+* inferred from its name or its platform.
+*
+* It used to be inferred — a name-and-platform heuristic written for the
+* camera catalog (`endsWith('_detected')`, `platform === 'switch'`) and
+* then applied to every device the catalog builds. On a camera it is
+* right: three zones is ~73 entities and the fleet is ~880, so only what
+* an operator automates on arrives enabled. On a DERIVED device it was
+* simply wrong — every sensor, every number and the alarm panel matched
+* nothing and shipped switched off, so a temperature sensor exported its
+* temperature disabled and the operator found the thing they installed
+* the integration for turned off. Measured on the live hub, the whole
+* derived half is **228 entities across 115 devices — 2 on average, 3 at
+* most**: there is no fan-out there to protect against.
+*
+* 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.
+*/
+/**
+* The snooze surface, as a `select`.
+*
+* `NC_SNOOZE_MAX_MINUTES` is 1440 server-side and there is no enum of
+* preset durations, so the presets are chosen here. `Off` cancels.
+*/
+var SNOOZE_OPTIONS = [
+	"Off",
+	"15 minutes",
+	"30 minutes",
+	"1 hour",
+	"2 hours",
+	"4 hours",
+	"8 hours",
+	"24 hours"
+];
+var SNOOZE_MINUTES = {
+	"15 minutes": 15,
+	"30 minutes": 30,
+	"1 hour": 60,
+	"2 hours": 120,
+	"4 hours": 240,
+	"8 hours": 480,
+	"24 hours": 1440
+};
+var PTZ_BUTTONS = [
+	"ptz_up",
+	"ptz_down",
+	"ptz_left",
+	"ptz_right",
+	"ptz_zoom_in",
+	"ptz_zoom_out"
+];
+function buildComponent(device, spec) {
+	const deviceKey = deviceKeyFor(device.stableId);
+	return {
+		platform: spec.platform,
+		unique_id: `${device.stableId}_${spec.uniqueSuffix ?? 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.enabledByDefault ? {} : { enabled_by_default: false },
+		...spec.platform === "binary_sensor" || spec.platform === "switch" ? {
+			payload_on: "true",
+			payload_off: "false"
+		} : {},
+		...spec.platform === "button" ? { payload_press: "PRESS" } : {}
+	};
+}
+function deviceBlock(device) {
+	return {
+		ids: [deviceKeyFor(device.stableId)],
+		name: device.name,
+		mf: device.manufacturer ?? "CamStack",
+		mdl: device.model ?? device.type
+	};
+}
+/**
+* The fan-out, and the reason the valve exists: zones × zone-macros × 4.
+* The detector is what an operator automates on; the other three are
+* detail they can switch on per entity.
+*/
+function zoneSpecs(zone) {
+	const slug = toSlug(zone.id);
+	const specs = [];
+	for (const macro of ZONE_MACROS) {
+		const label = `${zone.name} ${macro}`;
+		specs.push({
+			entity: `${slug}_${macro}_detected`,
+			platform: "binary_sensor",
+			label: `${label} detected`,
+			uniqueSuffix: `${zone.id}_${macro}_detected`,
+			deviceClass: "motion",
+			enabledByDefault: true
+		}, {
+			entity: `${slug}_${macro}_last_image`,
+			platform: "image",
+			label: `${label} last image`,
+			uniqueSuffix: `${zone.id}_${macro}_last_image`,
+			enabledByDefault: false
+		}, {
+			entity: `${slug}_${macro}_last_detection`,
+			platform: "sensor",
+			label: `${label} last detection`,
+			uniqueSuffix: `${zone.id}_${macro}_last_detection`,
+			deviceClass: "timestamp",
+			enabledByDefault: false
+		}, {
+			entity: `${slug}_${macro}_objects`,
+			platform: "sensor",
+			label: `${label} objects`,
+			uniqueSuffix: `${zone.id}_${macro}_objects`,
+			icon: "mdi:counter",
+			enabledByDefault: false
+		});
+	}
+	return specs;
+}
+function cameraSpecs(device) {
+	const specs = [
+		{
+			entity: "triggered",
+			platform: "binary_sensor",
+			label: "Triggered",
+			deviceClass: "motion",
+			enabledByDefault: true
+		},
+		{
+			entity: "online",
+			platform: "binary_sensor",
+			label: "Online",
+			deviceClass: "connectivity",
+			entityCategory: "diagnostic",
+			enabledByDefault: true
+		},
+		{
+			entity: "last_image",
+			platform: "image",
+			label: "Last image",
+			enabledByDefault: true
+		},
+		{
+			entity: "last_detection",
+			platform: "sensor",
+			label: "Last detection",
+			deviceClass: "timestamp",
+			icon: "mdi:clock",
+			enabledByDefault: false
+		}
+	];
+	if (device.slices.includes("battery")) specs.push({
+		entity: "battery",
+		platform: "sensor",
+		label: "Battery",
+		deviceClass: "battery",
+		unit: "%",
+		entityCategory: "diagnostic",
+		enabledByDefault: false
+	}, {
+		entity: "charger",
+		platform: "binary_sensor",
+		label: "Charging",
+		deviceClass: "battery_charging",
+		entityCategory: "diagnostic",
+		enabledByDefault: false
+	}, {
+		entity: "sleeping",
+		platform: "binary_sensor",
+		label: "Sleeping",
+		entityCategory: "diagnostic",
+		enabledByDefault: false
+	});
+	/**
+	* One HA switch per AVAILABLE camera switch, rendered from
+	* `getCameraSwitches` and commanded back through `setCameraSwitch`.
+	*
+	* The export never writes an authority itself: a second knob that can
+	* disagree with the admin UI is worse than no knob (D62). An
+	* unavailable switch produces NO entity — a control defaulted to `on`
+	* because a source did not answer is exactly the lie that rule exists
+	* to prevent.
+	*/
+	for (const sw of device.switches) {
+		if (!sw.available) continue;
+		specs.push({
+			entity: toSlug(sw.id),
+			platform: "switch",
+			label: sw.label,
+			writable: true,
+			enabledByDefault: true
+		});
+	}
+	if (device.features.includes("rebootable")) specs.push({
+		entity: "reboot",
+		platform: "button",
+		label: "Reboot",
+		writable: true,
+		enabledByDefault: true
+	});
+	if (device.boundCaps.includes("ptz")) {
+		for (const entity of PTZ_BUTTONS) specs.push({
+			entity,
+			platform: "button",
+			label: humanise(entity),
+			writable: true,
+			enabledByDefault: true
+		});
+		specs.push({
+			entity: "ptz_preset",
+			platform: "select",
+			label: "PTZ preset",
+			writable: true,
+			options: device.ptzPresets ?? [],
+			enabledByDefault: true
+		});
+	}
+	specs.push({
+		entity: "snooze",
+		platform: "select",
+		label: "Snooze notifications",
+		writable: true,
+		options: SNOOZE_OPTIONS,
+		enabledByDefault: true
+	});
+	for (const macro of EXPORTED_MACROS) {
+		const label = humanise(macro);
+		specs.push({
+			entity: `${macro}_detected`,
+			platform: "binary_sensor",
+			label: `${label} detected`,
+			deviceClass: "motion",
+			enabledByDefault: true
+		}, {
+			entity: `${macro}_last_image`,
+			platform: "image",
+			label: `${label} last image`,
+			enabledByDefault: false
+		}, {
+			entity: `${macro}_last_detection`,
+			platform: "sensor",
+			label: `${label} last detection`,
+			deviceClass: "timestamp",
+			enabledByDefault: false
+		});
+		if (LABELLED_MACROS.includes(macro)) specs.push({
+			entity: `${macro}_last_label`,
+			platform: "sensor",
+			label: `${label} last label`,
+			icon: "mdi:tag",
+			enabledByDefault: false
+		});
+	}
+	for (const zone of device.zones) specs.push(...zoneSpecs(zone));
+	return specs;
+}
+function assemble(device, specs) {
+	const cmps = {};
+	for (const spec of specs) cmps[toComponentKey(spec.platform, spec.entity)] = buildComponent(device, spec);
+	return {
+		deviceKey: deviceKeyFor(device.stableId),
+		deviceId: device.id,
+		dev: deviceBlock(device),
+		cmps
+	};
+}
+/** The hand-written half: a camera's entities come from analytics. */
+function buildCameraPlan(device) {
+	return assemble(device, cameraSpecs(device));
+}
+var CAP_ENTITY_MAP = {
+	switch: {
+		platform: "switch",
+		field: "on",
+		writable: true
+	},
+	"lock-control": {
+		platform: "switch",
+		field: "locked",
+		deviceClass: "lock",
+		writable: true
+	},
+	siren: {
+		platform: "switch",
+		field: "active",
+		writable: true
+	},
+	button: {
+		platform: "button",
+		field: "pressed",
+		writable: true
+	},
+	brightness: {
+		platform: "number",
+		field: "brightness",
+		writable: true
+	},
+	binary: {
+		platform: "binary_sensor",
+		field: "state"
+	},
+	motion: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "motion"
+	},
+	contact: {
+		platform: "binary_sensor",
+		field: "open",
+		deviceClass: "door"
+	},
+	presence: {
+		platform: "binary_sensor",
+		field: "present",
+		deviceClass: "presence"
+	},
+	connectivity: {
+		platform: "binary_sensor",
+		field: "online",
+		deviceClass: "connectivity"
+	},
+	flood: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "moisture"
+	},
+	smoke: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "smoke"
+	},
+	gas: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "gas"
+	},
+	"carbon-monoxide": {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "carbon_monoxide"
+	},
+	tamper: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "tamper"
+	},
+	vibration: {
+		platform: "binary_sensor",
+		field: "detected",
+		deviceClass: "vibration"
+	},
+	doorbell: {
+		platform: "sensor",
+		field: "lastPressedAt",
+		deviceClass: "timestamp"
+	},
+	"temperature-sensor": {
+		platform: "sensor",
+		field: "temperature",
+		deviceClass: "temperature",
+		unit: "°C"
+	},
+	"humidity-sensor": {
+		platform: "sensor",
+		field: "humidity",
+		deviceClass: "humidity",
+		unit: "%"
+	},
+	"pressure-sensor": {
+		platform: "sensor",
+		field: "pressure",
+		deviceClass: "pressure",
+		unit: "hPa"
+	},
+	"ambient-light-sensor": {
+		platform: "sensor",
+		field: "illuminance",
+		deviceClass: "illuminance",
+		unit: "lx"
+	},
+	"numeric-sensor": {
+		platform: "sensor",
+		field: "value"
+	},
+	"enum-sensor": {
+		platform: "sensor",
+		field: "value"
+	},
+	battery: {
+		platform: "sensor",
+		field: "percentage",
+		deviceClass: "battery",
+		unit: "%"
+	},
+	"power-meter": {
+		platform: "sensor",
+		field: "watts",
+		deviceClass: "power",
+		unit: "W"
+	},
+	"air-quality-sensor": {
+		platform: "sensor",
+		field: "aqi",
+		deviceClass: "aqi"
+	},
+	"alarm-panel": {
+		platform: "alarm_control_panel",
+		field: "state",
+		writable: true
+	}
+};
+var CAPS_NOT_EXPORTED = [
+	{
+		cap: "snapshot",
+		reason: "Carried by the camera catalog as `last_image`; a second image entity from the cap would duplicate it."
+	},
+	{
+		cap: "privacy-mask",
+		reason: "Rendered as a camera switch through getCameraSwitches, never written directly (D62)."
+	},
+	{
+		cap: "zone-analytics",
+		reason: "Projected into the per-zone object counts on the camera, not an entity of its own."
+	},
+	{
+		cap: "native-object-detection",
+		reason: "On-camera AI feeds the same per-macro entities as the pipeline; a parallel set would disagree with them."
+	},
+	{
+		cap: "ptz",
+		reason: "Rendered as buttons and a preset select by the camera catalog."
+	},
+	{
+		cap: "reboot",
+		reason: "Rendered as a button, gated on the `rebootable` feature rather than the binding."
+	},
+	{
+		cap: "device-status",
+		reason: "Auto-registered by BaseDevice on EVERY device, so it would add an entity to all of them; availability is already the heartbeat, per device."
+	},
+	{
+		cap: "feature-probe",
+		reason: "The runtime truth about what a device CAN do — it decides which entities exist, so exporting it as one would be circular."
+	},
+	{
+		cap: "device-ops",
+		reason: "The per-device operations envelope; its members surface individually (e.g. reboot)."
+	},
+	{
+		cap: "device-discovery",
+		reason: "Adoption-time only — it describes candidates, never the state of an adopted device."
+	}
+];
+/** A capability in neither list — the thing the guard exists to surface. */
+function unclassifiedCaps(caps) {
+	const known = new Set([...Object.keys(CAP_ENTITY_MAP), ...CAPS_NOT_EXPORTED.map((e) => e.cap)]);
+	return [...new Set(caps)].filter((cap) => !known.has(cap)).sort();
+}
+/**
+* The derived half: every non-camera kind, from the caps it declares.
+*
+* **Everything here arrives ENABLED**, and that is the rule rather than
+* an oversight in the other direction. A cap-derived entity IS the reason
+* the device exists — a temperature sensor's temperature, a light's
+* brightness, an alarm panel's state — and there is no fan-out to
+* protect against: measured on the live hub, 115 non-camera devices
+* produce 228 entities, 2 per device on average and 3 at most, because a
+* device declares one or two mapped caps and the rest of its bindings
+* (`device-status`, `feature-probe`, `device-ops`) carry no entity at
+* all. The camera valve is for 73-per-device; this is not that problem,
+* and exporting the operator's temperature switched off was the bug.
+*/
+function buildDerivedPlan(device) {
+	const specs = [{
+		entity: "online",
+		platform: "binary_sensor",
+		label: "Online",
+		deviceClass: "connectivity",
+		entityCategory: "diagnostic",
+		enabledByDefault: true
+	}];
+	for (const cap of device.boundCaps) {
+		const mapping = CAP_ENTITY_MAP[cap];
+		if (mapping === void 0) continue;
+		specs.push({
+			entity: toSlug(cap),
+			platform: mapping.platform,
+			label: humanise(cap),
+			enabledByDefault: true,
+			...mapping.deviceClass !== void 0 ? { deviceClass: mapping.deviceClass } : {},
+			...mapping.unit !== void 0 ? { unit: mapping.unit } : {},
+			...mapping.writable === true ? { writable: true } : {}
+		});
+	}
+	return assemble(device, specs);
+}
+/** Camera or base kind — the only place that decision is made. */
+function buildDevicePlan(device) {
+	return device.type === "camera" ? buildCameraPlan(device) : buildDerivedPlan(device);
+}
+//#endregion
+//#region src/ha-export/command-routes.ts
+/**
+* Home Assistant → camstack.
+*
+* The component POSTs `{topic, value}` onto this addon's `addon-routes`
+* surface; this module turns that pair into a typed command. Resolution
+* is pure so it can be tested without a device, and the addon does the
+* dispatching.
+*
+* The rule that shapes every branch: **an unroutable or malformed
+* command is refused, never approximated.** A `switch` payload that is
+* neither `true` nor `false` is not "off"; a PTZ press on a camera that
+* declares no `ptz` cap is not a no-op worth pretending succeeded. Both
+* return `null`, and the caller logs the drop.
+*/
+/** 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]));
+var PTZ_DIRECTION_BY_ENTITY = Object.fromEntries(PTZ_BUTTONS.map((entity) => [entity, entity.slice(4)]));
+function parseBool(value) {
+	const lower = value.trim().toLowerCase();
+	if (lower === "true" || lower === "on" || lower === "1") return true;
+	if (lower === "false" || lower === "off" || lower === "0") return false;
+	return null;
+}
+function resolveCommand(target, entity, value) {
+	if (target.type === "camera") {
+		const switchId = CAMERA_SWITCH_BY_SLUG[entity];
+		if (switchId !== void 0) {
+			const enabled = parseBool(value);
+			if (enabled === null) return null;
+			return {
+				kind: "camera-switch",
+				deviceId: target.deviceId,
+				switchId,
+				enabled
+			};
+		}
+		if (entity === "reboot") return {
+			kind: "reboot",
+			deviceId: target.deviceId
+		};
+		const direction = PTZ_DIRECTION_BY_ENTITY[entity];
+		if (direction !== void 0) {
+			if (!target.boundCaps.includes("ptz")) return null;
+			return {
+				kind: "ptz-move",
+				deviceId: target.deviceId,
+				direction
+			};
+		}
+		if (entity === "ptz_preset") {
+			if (!target.boundCaps.includes("ptz")) return null;
+			if (value.trim().length === 0) return null;
+			return {
+				kind: "ptz-preset",
+				deviceId: target.deviceId,
+				preset: value
+			};
+		}
+		if (entity === "snooze") {
+			if (!SNOOZE_OPTIONS.includes(value)) return null;
+			const minutes = SNOOZE_MINUTES[value];
+			return {
+				kind: "snooze",
+				deviceId: target.deviceId,
+				minutes: minutes ?? null
+			};
+		}
+		return null;
+	}
+	/**
+	* The derived half. The entity slug is the capability name, so the
+	* mapping table decides both the platform and whether it is writable —
+	* there is no separate list to fall out of sync with the catalog.
+	*/
+	for (const [capName, mapping] of Object.entries(CAP_ENTITY_MAP)) {
+		if (toSlug(capName) !== entity) continue;
+		if (mapping.writable !== true) return null;
+		if (!target.boundCaps.includes(capName)) return null;
+		if (mapping.platform === "button") return {
+			kind: "cap-button",
+			deviceId: target.deviceId,
+			capName
+		};
+		const on = parseBool(value);
+		if (on === null) return null;
+		return {
+			kind: "cap-switch",
+			deviceId: target.deviceId,
+			capName,
+			on
+		};
+	}
+	return null;
+}
+/**
+* The ONE derivation of "a signed, expiring URL".
+*
+* This repo mints unguessable, self-expiring links in three places now — the
+* notification artifact plane, the Home Assistant media plane, and the snapshot
+* link plane. The first two grew independently and are byte-identical logic
+* (`hmac(secret, "<id>:<exp>")`, expiry checked before a constant-time compare),
+* each restating the crypto locally because **addons never import each other**.
+*
+* That reason is real, and the conclusion drawn from it was wrong. Two copies of
+* a signing scheme is how one of them quietly ends up with a different TTL, a
+* different compare, or a missing expiry check, and nothing fails until a link
+* that should have died keeps working. The fix is the same one D52 applies to
+* crop geometry: one derivation, in a place every addon may depend on. A
+* framework package is exactly that place — `@camstack/types/node`, off the root
+* entry because `node:crypto` must never be traversed by a browser bundler.
+*
+* What this module deliberately does NOT decide: the TTL, the base URL, the
+* shape of `id`, and the access level of the route. Those are per-plane policy
+* and each caller states them where a reader can see them.
+*/
+/**
+* The signature over `(id, expMs)`.
+*
+* `id` is whatever the plane uses to name the thing being served — an artifact
+* id, a track id, a `<deviceId>:<width>` pair. It is joined with `:` so a caller
+* must not put a `:` inside a field whose boundary matters; where a plane has
+* more than one field, it composes them itself and owns that ambiguity.
+*/
+function signExpiringUrl(secret, id, expMs) {
+	return createHmac("sha256", secret).update(`${id}:${String(expMs)}`).digest("hex");
+}
+/**
+* Verify a request's `(id, exp, sig)`.
+*
+* **Expiry is checked BEFORE the compare**, so an expired link is refused
+* whether or not its signature is valid — a leaked URL stops working on its own
+* and cannot be kept alive by holding a correct signature. The compare itself is
+* constant-time so a public route cannot be probed for the signature byte by
+* byte.
+*/
+function verifyExpiringUrl(input) {
+	const { secret, id, exp, sig, nowMs } = input;
+	if (exp === void 0 || sig === void 0) return false;
+	const expMs = typeof exp === "number" ? exp : Number(exp);
+	if (!Number.isFinite(expMs)) return false;
+	if (expMs <= nowMs) return false;
+	const expected = signExpiringUrl(secret, id, expMs);
+	const a = Buffer.from(expected, "utf8");
+	const b = Buffer.from(sig, "utf8");
+	if (a.length !== b.length) return false;
+	return timingSafeEqual(a, b);
+}
+//#endregion
+//#region src/ha-export/media-url.ts
+/**
+* Signed, expiring media links.
+*
+* Images never cross the push transport. Home Assistant is handed a URL
+* and fetches the bytes itself, on demand, which is what keeps a camera
+* with a `last_image` entity from turning every detection into a
+* multi-megabyte POST.
+*
+* The link is signed rather than protected by a session, because the
+* fetcher is HA's own frontend or a phone — neither of which holds a
+* camstack token.
+*
+* The HMAC itself is NOT restated here. It used to be — this module and the
+* notification artifact plane each carried their own copy, because addons never
+* import each other and neither could reach the other's. That reasoning was
+* right and the conclusion was wrong: both now delegate to the single
+* derivation in `@camstack/types/node`, which every addon may depend on. What
+* stays local is policy — the TTL below, and the id this plane signs.
+*
+* Expiry is checked BEFORE the constant-time compare (in the shared verifier):
+* an expired link is refused whether or not its signature is valid, so a leaked
+* URL stops working on its own.
+*/
+/** How long a minted link stays valid. Long enough for HA to render it. */
+var MEDIA_URL_TTL_MS = 360 * 60 * 1e3;
+function signMedia(secret, id, expMs) {
+	return signExpiringUrl(secret, id, expMs);
+}
+function buildMediaUrl(input) {
+	const base = input.baseUrl.replace(/\/+$/, "");
+	const sig = signMedia(input.secret, input.id, input.expMs);
+	return `${base}${input.routePrefix}/${encodeURIComponent(input.id)}?exp=${input.expMs}&sig=${sig}`;
+}
+function verifyMediaSignature(input) {
+	return verifyExpiringUrl(input);
+}
+//#endregion
+//#region src/ha-export/membership.ts
+function devicesForBroker(membership, brokerId) {
+	return membership[brokerId] ?? [];
+}
+function isExposed(membership, brokerId, deviceId) {
+	return devicesForBroker(membership, brokerId).includes(deviceId);
+}
+/** Every broker a device reaches. Drives the N switches in the panel. */
+function brokersExposing(membership, deviceId) {
+	return Object.keys(membership).filter((brokerId) => isExposed(membership, brokerId, deviceId)).sort();
+}
+/** Every device exported to at least one of the given brokers. */
+function exposedDeviceIds(membership, brokerIds) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const brokerId of brokerIds) for (const deviceId of devicesForBroker(membership, brokerId)) ids.add(deviceId);
+	return [...ids].sort();
+}
+function setExposed(membership, brokerId, deviceId, exposed) {
+	const current = devicesForBroker(membership, brokerId);
+	if (exposed === current.includes(deviceId)) return membership;
+	const next = exposed ? [...current, deviceId].sort() : current.filter((id) => id !== deviceId);
+	return {
+		...membership,
+		[brokerId]: next
+	};
+}
+/**
+* Forget brokers that no longer exist.
+*
+* A removed HA instance must not keep a membership list that reappears if
+* a broker id is ever reused — and a stale key would also inflate
+* `exposedDeviceCount` with devices going nowhere.
+*/
+function pruneBrokers(membership, knownBrokerIds) {
+	const known = new Set(knownBrokerIds);
+	const kept = Object.keys(membership).filter((brokerId) => known.has(brokerId));
+	if (kept.length === Object.keys(membership).length) return membership;
+	const next = {};
+	for (const brokerId of kept) next[brokerId] = membership[brokerId] ?? [];
+	return next;
+}
+//#endregion
+//#region src/ha-export/push-client.ts
+/** How long state updates accumulate before one POST carries them all. */
+var BATCH_FLUSH_MS = 1e3;
+/** Availability cadence. The component's timeout is a multiple of this. */
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var IMAGE_SIGNAL_PREFIX = "__image_updated__:";
+/** Rate limit for the "HA is not answering" warning. */
+var DROP_LOG_INTERVAL_MS = 3e4;
+var PushClient = class {
+	transport;
+	logger;
+	brokerId;
+	onLinkRestored;
+	/** topic → last value SENT. Dropped whenever the link is lost. */
+	stateCache = /* @__PURE__ */ new Map();
+	buffer = [];
+	flushTimer = null;
+	heartbeatTimer = null;
+	available = true;
+	dropped = 0;
+	droppedLoggedAt = 0;
+	disposed = false;
+	constructor(options) {
+		this.transport = options.transport;
+		this.logger = options.logger;
+		this.brokerId = options.brokerId;
+		this.onLinkRestored = options.onLinkRestored;
+	}
+	/** `false` once a POST has failed, `true` again on the next success. */
+	get healthy() {
+		return this.available;
+	}
+	/** Messages discarded because HA did not answer. Never silent. */
+	get droppedCount() {
+		return this.dropped;
+	}
+	start() {
+		if (this.heartbeatTimer !== null) return;
+		this.heartbeatTimer = setInterval(() => {
+			this.send({
+				type: "heartbeat",
+				ts: Date.now()
+			});
+		}, HEARTBEAT_INTERVAL_MS);
+	}
+	async dispose() {
+		this.disposed = true;
+		if (this.heartbeatTimer !== null) clearInterval(this.heartbeatTimer);
+		this.heartbeatTimer = null;
+		if (this.flushTimer !== null) clearTimeout(this.flushTimer);
+		this.flushTimer = null;
+		this.buffer = [];
+	}
+	/**
+	* Queue one state value.
+	*
+	* Deduped per topic, so a camera reporting `online: true` every five
+	* seconds costs nothing after the first.
+	*/
+	publishState(topic, value) {
+		if (this.disposed) return;
+		const payload = value.length > 2048 ? `${IMAGE_SIGNAL_PREFIX}${Date.now()}` : value;
+		if (this.stateCache.get(topic) === payload) return;
+		this.stateCache.set(topic, payload);
+		this.buffer.push({
+			type: "state_update",
+			topic,
+			value: payload
+		});
+		if (this.flushTimer === null) this.flushTimer = setTimeout(() => void this.flush(), BATCH_FLUSH_MS);
+	}
+	/**
+	* Announce a device's COMPLETE component set.
+	*
+	* Never a delta, and re-sent in full on reconnect: an event is
+	* telemetry and may be dropped (D8), so a lost structure message must
+	* not be able to leave HA with half a device. The pending state batch
+	* is flushed first — a value for an entity HA has not built yet is a
+	* value it discards.
+	*/
+	async publishEntityChange(deviceKey, cmps, dev) {
+		if (this.disposed) return;
+		await this.flush();
+		await this.send({
+			type: "entity_change",
+			device_id: deviceKey,
+			cmps,
+			dev
+		});
+	}
+	/** Send everything buffered now. Called before any structure change. */
+	async flush() {
+		if (this.flushTimer !== null) {
+			clearTimeout(this.flushTimer);
+			this.flushTimer = null;
+		}
+		if (this.buffer.length === 0) return;
+		const items = this.buffer;
+		this.buffer = [];
+		await this.send({
+			type: "batch",
+			items
+		});
+	}
+	async send(message) {
+		try {
+			await this.transport(message);
+			this.onReachable();
+		} catch (err) {
+			this.onUnreachable(message, err);
+		}
+	}
+	onReachable() {
+		if (this.available) return;
+		this.available = true;
+		/**
+		* The link came back. Drop the dedup cache so the reconcile that
+		* follows re-pushes every value: HA may have restarted and lost its
+		* state, and a cache that still remembers the old value would
+		* suppress exactly the messages needed to repair it.
+		*/
+		this.stateCache.clear();
+		this.logger.info("ha-export: Home Assistant reachable again, state cache cleared", { meta: {
+			brokerId: this.brokerId,
+			droppedWhileDown: this.dropped
+		} });
+		this.dropped = 0;
+		this.droppedLoggedAt = 0;
+		/**
+		* Signalled AFTER the cache is gone and BEFORE anything else is sent:
+		* the handler re-announces from inside this call, and a cache that
+		* still held the old values would dedup away exactly those messages.
+		* The handler's own failure is its business — it can never take the
+		* transport, or the runner, down with it (D29).
+		*/
+		try {
+			this.onLinkRestored?.(this.brokerId);
+		} catch (err) {
+			this.logger.warn("ha-export: the re-announce handler threw, link is up but not repaired", { meta: {
+				brokerId: this.brokerId,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+	/**
+	* A failed POST discards work, so it may not be silent — an operator
+	* whose entities froze two days ago needs the log to say camstack is
+	* pushing into a wall, not merely that the addon is "running". Rate
+	* limited, because the alternative is a storm that buries the line.
+	*/
+	onUnreachable(message, err) {
+		this.available = false;
+		this.dropped += message.type === "batch" ? message.items.length : 1;
+		const now = Date.now();
+		if (now - this.droppedLoggedAt < DROP_LOG_INTERVAL_MS) return;
+		this.droppedLoggedAt = now;
+		this.logger.warn("ha-export: push to Home Assistant failed, messages dropped", { meta: {
+			brokerId: this.brokerId,
+			dropped: this.dropped,
+			messageType: message.type,
+			error: err instanceof Error ? err.message : String(err)
+		} });
+	}
+};
+var ReachabilityReconciler = class {
+	options;
+	minIntervalMs;
+	timer = null;
+	lastRunAt = null;
+	pending = /* @__PURE__ */ new Set();
+	disposed = false;
+	constructor(options) {
+		this.options = options;
+		this.minIntervalMs = options.minIntervalMs ?? 3e4;
+	}
+	/** One link came back. Ask for a full re-announce. */
+	request(brokerId) {
+		if (this.disposed) return;
+		this.pending.add(brokerId);
+		if (this.timer !== null) return;
+		const sinceLast = this.lastRunAt === null ? Number.POSITIVE_INFINITY : Date.now() - this.lastRunAt;
+		const delayMs = Math.max(0, this.minIntervalMs - sinceLast);
+		this.options.onScheduled?.({
+			brokerId,
+			delayMs
+		});
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.fire();
+		}, delayMs);
+	}
+	dispose() {
+		this.disposed = true;
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		this.pending.clear();
+	}
+	fire() {
+		if (this.disposed) return;
+		const brokerIds = [...this.pending].sort();
+		this.pending.clear();
+		if (brokerIds.length === 0) return;
+		this.lastRunAt = Date.now();
+		this.options.run({ brokerIds });
+	}
+};
+//#endregion
+//#region src/ha-export/state-projector.ts
+/**
+* Pipeline / notification-center output → `{topic, value}`.
+*
+* Pure. This is where `last_detection`, `last_label` and the per-zone
+* counts become state, and it is the half of the export the operator's
+* requirement lands on: **every value has a listener in the addon that
+* publishes it.** Nothing in Home Assistant polls camstack — each
+* function here is the projection of ONE internal source, and the addon
+* subscribes to that source.
+*
+* Every value is a STRING. The component lowercases binary values
+* verbatim; a JSON number or boolean raises inside its state callback,
+* which it swallows — so the entity silently never updates again.
+*/
+/**
+* A detection class → the macro an operator automates on.
+*
+* Returns `null` rather than a fallback: the executor drops classes with
+* no macro upstream (`preserveOriginal: false`), so one arriving here is
+* a contract break, and inventing a macro for it would put a toothbrush
+* on the person sensor.
+*/
+function macroOf(className) {
+	const lower = className.toLowerCase();
+	if (EXPORTED_MACROS.includes(lower)) return lower;
+	const mapped = COCO_TO_MACRO.mapping[lower];
+	return typeof mapped === "string" ? mapped : null;
+}
+function iso(timestamp) {
+	return new Date(timestamp).toISOString();
+}
+function bool(value) {
+	return value ? "true" : "false";
+}
+/**
+* Reachability.
+*
+* `device.sleeping` deliberately does NOT feed this: a battery camera in
+* low-power mode is reachable on demand, and marking it unavailable
+* would break every automation that wakes it.
+*/
+function projectDeviceStatus(deviceKey, online) {
+	return [{
+		topic: stateTopic(deviceKey, "online"),
+		value: bool(online)
+	}];
+}
+function projectMotion(deviceKey, input) {
+	const values = [{
+		topic: stateTopic(deviceKey, "motion_detected"),
+		value: bool(input.detected)
+	}, {
+		topic: stateTopic(deviceKey, "triggered"),
+		value: bool(input.detected)
+	}];
+	/**
+	* A clearing edge carries no timestamp. `last_detection` answers "when
+	* did something last happen", and restamping it when nothing happened
+	* makes an idle camera look permanently busy.
+	*/
+	if (input.detected) values.push({
+		topic: stateTopic(deviceKey, "motion_last_detection"),
+		value: iso(input.timestamp)
+	});
+	return values;
+}
+/**
+* @param mediaUrl a signed, expiring URL for this track's best crop, or
+*   `null` when there is none yet. Images NEVER cross the transport —
+*   camstack mints the URL and HA fetches the bytes on demand.
+*/
+function projectTrackLifecycle(deviceKey, track, mediaUrl) {
+	const className = track.bestClassName ?? track.classes[0];
+	if (className === void 0) return [];
+	const macro = macroOf(className);
+	if (macro === null) return [];
+	const active = track.phase !== "end";
+	const values = [{
+		topic: stateTopic(deviceKey, `${macro}_detected`),
+		value: bool(active)
+	}, {
+		topic: stateTopic(deviceKey, "triggered"),
+		value: bool(active)
+	}];
+	if (active) values.push({
+		topic: stateTopic(deviceKey, `${macro}_last_detection`),
+		value: iso(track.lastSeen)
+	}, {
+		topic: stateTopic(deviceKey, "last_detection"),
+		value: iso(track.lastSeen)
+	});
+	/**
+	* The identification: the recognised face for `person`, the plate for
+	* `vehicle`, the sub-class for `animal`. `package`, `motion` and
+	* `audio` have no label and the entity does not exist for them — so a
+	* label arriving on one of those is dropped rather than published to a
+	* topic nothing is subscribed to.
+	*/
+	const label = track.plateText ?? track.label;
+	if (label !== void 0 && label.length > 0 && LABELLED_MACROS.includes(macro)) values.push({
+		topic: stateTopic(deviceKey, `${macro}_last_label`),
+		value: label
+	});
+	if (mediaUrl !== null) values.push({
+		topic: stateTopic(deviceKey, "last_image"),
+		value: mediaUrl
+	}, {
+		topic: stateTopic(deviceKey, `${macro}_last_image`),
+		value: mediaUrl
+	});
+	if (ZONE_MACROS.includes(macro)) for (const zoneId of track.zonesVisited ?? []) {
+		const slug = toSlug(zoneId);
+		values.push({
+			topic: stateTopic(deviceKey, `${slug}_${macro}_detected`),
+			value: bool(active)
+		});
+		if (active) values.push({
+			topic: stateTopic(deviceKey, `${slug}_${macro}_last_detection`),
+			value: iso(track.lastSeen)
+		});
+		if (mediaUrl !== null) values.push({
+			topic: stateTopic(deviceKey, `${slug}_${macro}_last_image`),
+			value: mediaUrl
+		});
+	}
+	return values;
+}
+/**
+* Per-zone counts.
+*
+* A macro with nobody in the zone publishes `0`, not nothing: an entity
+* that goes silent renders in HA as its last value, so a driveway that
+* emptied would read as still occupied until someone walked through it
+* again.
+*/
+function projectZoneOccupancy(deviceKey, input) {
+	const values = [];
+	for (const zone of input.zones) {
+		const slug = toSlug(zone.zoneId);
+		const totals = new Map(ZONE_MACROS.map((macro) => [macro, 0]));
+		for (const [className, count] of Object.entries(zone.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, `${slug}_${macro}_objects`),
+			value: String(count)
+		});
+	}
+	return values;
+}
+function projectBatterySlice(deviceKey, slice) {
+	const values = [{
+		topic: stateTopic(deviceKey, "charger"),
+		value: bool(slice.charging !== "none")
+	}, {
+		topic: stateTopic(deviceKey, "sleeping"),
+		value: bool(slice.sleeping)
+	}];
+	/**
+	* `binary: true` means the device reports "low" or "not low" and the
+	* percentage is a stand-in. Publishing it would put a fabricated
+	* number on a battery gauge, which is worse than an empty one.
+	*/
+	if (slice.binary !== true) values.push({
+		topic: stateTopic(deviceKey, "battery"),
+		value: String(slice.percentage)
+	});
+	return values;
+}
+/**
+* The per-camera function switches, mirrored 1:1 from
+* `pipelineOrchestrator.getCameraSwitches`.
+*
+* An UNAVAILABLE switch 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)
+	}));
+}
+//#endregion
+//#region src/ha-export/ha-export.addon.ts
+/**
+* Native Home Assistant export — a custom component fed by HTTP push.
+*
+* Contract: `docs/superpowers/specs/2026-08-04-ha-native-export-design.md`.
+* Read it before changing the entity map or the transport.
+*
+* **This addon PUSHES. Home Assistant never polls camstack for a value.**
+* Every entity in the catalog is fed by a listener here, on the authority
+* that already owns the value — device slices, motion, the track
+* lifecycle, zone occupancy, the camera switches. The projector turns
+* each into `{topic, value}` and the push client batches, dedups and
+* heartbeats them out.
+*
+* Where it lives, and why it is not inside the provider's process: it
+* ships in the SAME bundle as `provider-homeassistant` (so the HA URL and
+* token are not duplicated — they are read through the `broker` cap, and
+* addons never import each other even in one bundle), but as a SEPARATE
+* manifest entry with its own runner. D29: a defect in export must not be
+* able to respawn the runner that owns the devices.
+*
+* Three things a future session will want to know:
+*
+*  1. **Push authenticates with Home Assistant's OWN token.** The
+*     component registers its view with HA auth, so the long-lived token
+*     already stored on the broker is the credential. There is no second
+*     shared secret to configure, rotate or leak.
+*  2. **Events optimise; the reconcile is the contract.** Bus events are
+*     telemetry and may be dropped (D8), so a full reconcile runs on
+*     boot, on config change, on a timer, and whenever the link to HA
+*     returns. A dropped event costs one interval of staleness rather
+*     than permanent divergence.
+*  3. **Membership is per broker.** Two Home Assistant instances see
+*     different sets of cameras, and the per-device Export panel shows
+*     one switch per broker over the single membership store.
+*/
+/** The addon that owns the import direction — never export back to it. */
+var HA_PROVIDER_ADDON_ID = "provider-homeassistant";
+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`;
+/** 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. */
+var PTZ_MOVE_BY_DIRECTION = {
+	up: { tilt: .1 },
+	down: { tilt: -.1 },
+	left: { pan: -.1 },
+	right: { pan: .1 },
+	zoom_in: { zoom: .1 },
+	zoom_out: { zoom: -.1 }
+};
+var DEFAULT_CONFIG = {
+	reconcileIntervalSec: 300,
+	membership: {},
+	knownBrokers: [],
+	publicBaseUrl: ""
+};
+var HaExportAddon = class extends BaseAddon {
+	links = /* @__PURE__ */ new Map();
+	/** deviceKey → the device it addresses. Rebuilt on every reconcile. */
+	exported = /* @__PURE__ */ new Map();
+	/** numeric deviceId → deviceKey, for the event path. */
+	keyByDeviceId = /* @__PURE__ */ new Map();
+	mediaSecret = "";
+	mediaBaseUrl = null;
+	reconcileTimer = null;
+	reconcileInFlight = false;
+	/** A reason asked for while one was running. Re-run, never dropped. */
+	reconcilePending = null;
+	lastError;
+	entityCount = 0;
+	unclassified = [];
+	/**
+	* A link that returned repairs NOW, not at the next periodic pass.
+	*
+	* `PushClient` drops its dedup cache the moment Home Assistant answers
+	* again; without this, nothing re-sent anything and every entity sat
+	* blank for up to `reconcileIntervalSec` (300s). Bounded and coalesced,
+	* because the answer is the COMPLETE `cmps` set plus every value for
+	* every exported device — see `reachability-reconcile.ts`.
+	*/
+	reachability = new ReachabilityReconciler({
+		onScheduled: ({ brokerId, delayMs }) => {
+			this.ctx.logger.info("ha-export: Home Assistant link returned, re-announcing everything", { meta: {
+				brokerId,
+				inMs: delayMs
+			} });
+		},
+		run: ({ brokerIds }) => {
+			this.reconcile("link-restored");
+			this.ctx.logger.debug("ha-export: re-announce triggered by a returning link", { meta: { brokers: [...brokerIds] } });
+		}
+	});
+	constructor() {
+		super({ ...DEFAULT_CONFIG });
+	}
+	async onInitialize() {
+		const secret = this.state("haExportMediaSecret", string(), "");
+		const existing = await secret.get();
+		if (existing.length === 0) {
+			const minted = randomSecret();
+			await secret.set(minted);
+			this.mediaSecret = minted;
+		} else this.mediaSecret = existing;
+		this.wireListeners();
+		await this.serveMediaPlane();
+		try {
+			await this.reconcile("boot");
+		} catch (err) {
+			this.lastError = errMsg(err);
+			this.ctx.logger.warn("ha-export: initial reconcile failed", { meta: { error: this.lastError } });
+		}
+		this.startTimer();
+		this.ctx.addDisposer(async () => {
+			this.stopTimer();
+			this.reachability.dispose();
+			for (const link of this.links.values()) await link.client.dispose();
+			this.links.clear();
+		});
+		return [{
+			capability: deviceExportCapability,
+			provider: {
+				getStatus: async () => this.buildStatus(),
+				listSupportedDeviceKinds: async () => [...SUPPORTED_DEVICE_KINDS],
+				listExposedDevices: async () => exposedDeviceIds(this.config.membership, this.enabledBrokerIds()).map((deviceId) => ({
+					deviceId,
+					exposedAs: brokersExposing(this.config.membership, deviceId).map((brokerId) => this.brokerName(brokerId)).join(", ")
+				})),
+				exposeDevice: async ({ deviceId }) => this.setMembershipEverywhere(deviceId, true),
+				unexposeDevice: async ({ deviceId }) => this.setMembershipEverywhere(deviceId, false),
+				getDeviceSettingsContribution: async ({ deviceId }) => this.buildContribution(deviceId),
+				getDeviceLiveContribution: async () => null,
+				applyDeviceSettingsPatch: async ({ deviceId, patch }) => this.applyDeviceSettingsPatch(deviceId, patch)
+			}
+		}, {
+			capability: addonRoutesCapability,
+			provider: buildAddonRouteProvider(ADDON_ID, [{
+				method: "POST",
+				path: "/command",
+				access: "authenticated",
+				description: "Home Assistant → CamStack command: {topic, value}",
+				handler: async (request, reply) => {
+					await this.handleCommandRoute(request.body, reply);
+				}
+			}])
+		}];
+	}
+	async onConfigChanged() {
+		await this.reconcile("config-changed");
+		this.startTimer();
+	}
+	wireListeners() {
+		this.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
+			this.onSliceChanged(event.data);
+		});
+		this.subscribe({ category: EventCategory.DeviceOnline }, (event) => {
+			this.onOnlineChanged(event.data, true);
+		});
+		this.subscribe({ category: EventCategory.DeviceOffline }, (event) => {
+			this.onOnlineChanged(event.data, false);
+		});
+		this.subscribe({ category: EventCategory.MotionOnMotionChanged }, (event) => {
+			this.onMotion(event.data);
+		});
+		this.subscribe({ category: EventCategory.PipelineAnalyticsTrackLifecycle }, (event) => {
+			this.onTrackLifecycle(event.data);
+		});
+		this.subscribe({ category: EventCategory.ZoneAnalyticsOccupancyChanged }, (event) => {
+			this.onZoneOccupancy(event.data);
+		});
+		/**
+		* Structure, not value. A new device, a lost one or a changed
+		* binding changes the `cmps` set, so it needs a full reconcile
+		* rather than a state push.
+		*/
+		for (const category of [
+			EventCategory.DeviceRegistered,
+			EventCategory.DeviceUnregistered,
+			EventCategory.DeviceBindingsChanged,
+			EventCategory.DeviceMetaChanged,
+			EventCategory.BrokerStatusChanged
+		]) this.subscribe({ category }, () => {
+			this.reconcileSoon();
+		});
+	}
+	onSliceChanged(data) {
+		const deviceId = readNumber(data, "deviceId");
+		const capName = readString(data, "capName");
+		const slice = readRecord(data, "slice");
+		if (deviceId === null || capName === null || slice === null) return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		if (capName === "device-status") {
+			const online = slice["online"];
+			if (typeof online === "boolean") this.push(deviceId, projectDeviceStatus(deviceKey, online));
+			return;
+		}
+		if (capName === "battery") {
+			const percentage = readNumber(slice, "percentage");
+			const charging = readString(slice, "charging");
+			const sleeping = slice["sleeping"];
+			if (percentage === null || charging === null || typeof sleeping !== "boolean") return;
+			const binary = slice["binary"];
+			this.push(deviceId, projectBatterySlice(deviceKey, {
+				percentage,
+				charging,
+				sleeping,
+				...typeof binary === "boolean" ? { binary } : {}
+			}));
+			return;
+		}
+		if (capName === "motion") {
+			const detected = slice["detected"];
+			const lastDetectedAt = readNumber(slice, "lastDetectedAt");
+			if (typeof detected !== "boolean") return;
+			this.push(deviceId, projectMotion(deviceKey, {
+				detected,
+				timestamp: lastDetectedAt ?? Date.now()
+			}));
+		}
+	}
+	onOnlineChanged(data, online) {
+		const deviceId = readNumber(data, "deviceId");
+		if (deviceId === null) return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		this.push(deviceId, projectDeviceStatus(deviceKey, online));
+	}
+	onMotion(data) {
+		const deviceId = readNumber(data, "deviceId");
+		const detected = readRecordField(data, "detected");
+		if (deviceId === null || typeof detected !== "boolean") return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		const timestamp = readNumber(data, "timestamp") ?? Date.now();
+		this.push(deviceId, projectMotion(deviceKey, {
+			detected,
+			timestamp
+		}));
+	}
+	/**
+	* The richest source: class, zone, identity, plate and the media key in
+	* one payload. One subscription feeds most of a camera's catalog.
+	*/
+	async onTrackLifecycle(data) {
+		const deviceId = readNumber(data, "deviceId");
+		const trackId = readString(data, "trackId");
+		const phase = readString(data, "phase");
+		if (deviceId === null || trackId === null) return;
+		if (phase !== "start" && phase !== "update" && phase !== "end") return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		const classes = readStringArray(data, "classes");
+		const bestClassName = readString(data, "bestClassName");
+		const label = readString(data, "label");
+		const plateText = readString(data, "plateText");
+		const lastSeen = readNumber(data, "lastSeen") ?? Date.now();
+		const zonesVisited = readStringArray(data, "zonesVisited");
+		const mediaUrl = this.mintTrackMediaUrl(trackId);
+		const values = projectTrackLifecycle(deviceKey, {
+			deviceId,
+			trackId,
+			phase,
+			classes,
+			...bestClassName !== null ? { bestClassName } : {},
+			...label !== null ? { label } : {},
+			...plateText !== null ? { plateText } : {},
+			lastSeen,
+			zonesVisited
+		}, mediaUrl);
+		if (values.length === 0) {
+			this.ctx.logger.debug("ha-export: track produced no exportable state", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					bestClassName,
+					phase
+				}
+			});
+			return;
+		}
+		this.push(deviceId, values);
+	}
+	onZoneOccupancy(data) {
+		const deviceId = readNumber(data, "deviceId");
+		if (deviceId === null) return;
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		const zonesRaw = readRecordField(data, "zones");
+		if (!Array.isArray(zonesRaw)) return;
+		const zones = zonesRaw.flatMap((entry) => {
+			const zoneId = readString(entry, "zoneId");
+			const byClass = readRecord(entry, "byClass");
+			if (zoneId === null) return [];
+			return [{
+				zoneId,
+				byClass: toCountRecord(byClass)
+			}];
+		});
+		if (zones.length === 0) return;
+		this.push(deviceId, projectZoneOccupancy(deviceKey, { zones }));
+	}
+	/**
+	* Send a device's values to every broker it is exported to.
+	*
+	* A failure on one broker's client cannot reach another: each has its
+	* own dedup cache and its own availability, so one unreachable Home
+	* Assistant degrades only its own entities.
+	*/
+	push(deviceId, values) {
+		const deviceKey = this.keyByDeviceId.get(deviceId);
+		if (deviceKey === void 0) return;
+		const exported = this.exported.get(deviceKey);
+		if (exported === void 0) return;
+		for (const brokerId of exported.brokerIds) {
+			const link = this.links.get(brokerId);
+			if (link === void 0) continue;
+			for (const value of values) link.client.publishState(value.topic, value.value);
+		}
+	}
+	reconcileQueued = false;
+	async reconcileSoon() {
+		if (this.reconcileQueued) return;
+		this.reconcileQueued = true;
+		setTimeout(() => {
+			this.reconcileQueued = false;
+			this.reconcile("structure-changed");
+		}, 2e3);
+	}
+	/**
+	* The contract.
+	*
+	* Re-resolves the brokers, rebuilds every plan, re-sends the COMPLETE
+	* `cmps` set for every exported device, and re-pushes every value.
+	* Events are an optimisation over this, never a substitute (D8/D11).
+	*
+	* A reconcile asked for while one is running is RE-RUN after it, never
+	* dropped. It used to be dropped, and silently: a link that returned
+	* mid-pass cleared its dedup cache and then lost the only re-announce
+	* that would have refilled it, which is the exact defect this addon
+	* just fixed, arriving through a different door.
+	*/
+	async reconcile(reason) {
+		if (this.reconcileInFlight) {
+			this.reconcilePending = reason;
+			this.ctx.logger.debug("ha-export: a reconcile is already running, re-running after it", { meta: { reason } });
+			return;
+		}
+		this.reconcileInFlight = true;
+		try {
+			let next = reason;
+			while (next !== null) {
+				const current = next;
+				this.reconcilePending = null;
+				await this.runReconcile(current);
+				next = this.reconcilePending;
+			}
+		} finally {
+			this.reconcileInFlight = false;
+			this.reconcilePending = null;
+		}
+	}
+	/** One pass. Never throws: a failure degrades this pass and no more. */
+	async runReconcile(reason) {
+		const startedAt = Date.now();
+		try {
+			await this.refreshBrokers();
+			await this.refreshMediaBaseUrl();
+			const enabled = this.enabledBrokerIds();
+			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]));
+			const exported = /* @__PURE__ */ new Map();
+			const keyByDeviceId = /* @__PURE__ */ new Map();
+			const allCaps = /* @__PURE__ */ new Set();
+			let entityCount = 0;
+			for (const deviceIdStr of exposedDeviceIds(this.config.membership, enabled)) {
+				const numericId = Number(deviceIdStr);
+				if (!Number.isFinite(numericId)) {
+					this.ctx.logger.warn("ha-export: membership holds a non-numeric device id, skipping", { meta: { deviceId: deviceIdStr } });
+					continue;
+				}
+				const device = byId.get(numericId);
+				if (device === void 0) {
+					this.ctx.logger.warn("ha-export: exported device is not in the registry, skipping", { tags: { deviceId: numericId } });
+					continue;
+				}
+				/**
+				* The echo guard. A device imported FROM Home Assistant is never
+				* exported back to it: HA would mirror its own entity across the
+				* bridge, and any automation touching it would round-trip.
+				*/
+				if (device.addonId === HA_PROVIDER_ADDON_ID) {
+					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)]);
+				for (const cap of catalogDevice.boundCaps) allCaps.add(cap);
+				const plan = buildDevicePlan(catalogDevice);
+				const brokerIds = brokersExposing(this.config.membership, deviceIdStr).filter((id) => enabled.includes(id));
+				exported.set(plan.deviceKey, {
+					plan,
+					deviceId: numericId,
+					target: {
+						deviceId: numericId,
+						type: device.type,
+						boundCaps: catalogDevice.boundCaps
+					},
+					brokerIds
+				});
+				keyByDeviceId.set(numericId, plan.deviceKey);
+				entityCount += Object.keys(plan.cmps).length;
+				/**
+				* The positive branch. Every other line in this loop describes a
+				* device being DROPPED; without this one an operator can see why
+				* a device is missing but cannot confirm which devices were
+				* actually exported, to which Home Assistant, with which
+				* entities. Silence reads as "never happened" both ways.
+				*/
+				this.ctx.logger.info("ha-export: exporting device", {
+					tags: { deviceId: numericId },
+					meta: {
+						deviceType: device.type,
+						deviceKey: plan.deviceKey,
+						brokers: brokerIds,
+						entities: 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);
+			this.ctx.logger.info("ha-export: reconciled", { meta: {
+				reason,
+				brokers: enabled.length,
+				devices: exported.size,
+				entities: entityCount,
+				unclassifiedCaps: this.unclassified.length,
+				durationMs: Date.now() - startedAt
+			} });
+			if (this.unclassified.length > 0) this.ctx.logger.warn("ha-export: capabilities in neither the map nor the exclusion list", { meta: { caps: this.unclassified } });
+			this.lastError = void 0;
+		} catch (err) {
+			this.lastError = errMsg(err);
+			this.ctx.logger.warn("ha-export: reconcile failed", { meta: { error: this.lastError } });
+		}
+	}
+	/**
+	* Send every exported device's COMPLETE component set, per broker.
+	*
+	* Wrapped per device: a device whose plan cannot be announced degrades
+	* that device only and can never take the loop — or the runner — down
+	* with it.
+	*/
+	async announce(exported) {
+		for (const entry of exported.values()) for (const brokerId of entry.brokerIds) {
+			const link = this.links.get(brokerId);
+			if (link === void 0) continue;
+			try {
+				await link.client.publishEntityChange(entry.plan.deviceKey, entry.plan.cmps, entry.plan.dev);
+			} catch (err) {
+				this.ctx.logger.warn("ha-export: could not announce a device, skipping it", {
+					tags: { deviceId: entry.deviceId },
+					meta: {
+						brokerId,
+						error: errMsg(err)
+					}
+				});
+			}
+		}
+	}
+	async pushFullState(exported, snapshots) {
+		for (const entry of exported.values()) try {
+			const values = await this.currentStateFor(entry, snapshots[String(entry.deviceId)]);
+			this.push(entry.deviceId, values);
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read current state for a device", {
+				tags: { deviceId: entry.deviceId },
+				meta: { error: errMsg(err) }
+			});
+		}
+		for (const link of this.links.values()) await link.client.flush();
+	}
+	/** Everything readable without waiting for an event. */
+	async currentStateFor(entry, snapshotRaw) {
+		const key = entry.plan.deviceKey;
+		const values = [];
+		const snapshot = toSnapshot(snapshotRaw);
+		const online = snapshot["device-status"]?.["online"];
+		if (typeof online === "boolean") values.push(...projectDeviceStatus(key, online));
+		const battery = snapshot["battery"];
+		if (battery !== void 0) {
+			const percentage = readNumber(battery, "percentage");
+			const charging = readString(battery, "charging");
+			const sleeping = battery["sleeping"];
+			if (percentage !== null && charging !== null && typeof sleeping === "boolean") {
+				const binary = battery["binary"];
+				values.push(...projectBatterySlice(key, {
+					percentage,
+					charging,
+					sleeping,
+					...typeof binary === "boolean" ? { binary } : {}
+				}));
+			}
+		}
+		if (entry.target.type === "camera") {
+			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
+			}))));
+			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)
+			})) }));
+		}
+		return values;
+	}
+	async buildCatalogDevice(device, snapshotRaw) {
+		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) : [];
+		const ptzPresets = device.type === "camera" && boundCaps.includes("ptz") ? await this.loadPresets(device.id) : [];
+		const manufacturer = readString(device.metadata ?? {}, "manufacturer");
+		const model = readString(device.metadata ?? {}, "model");
+		return {
+			id: device.id,
+			stableId: device.stableId,
+			name: device.name,
+			type: device.type,
+			...manufacturer !== null ? { manufacturer } : {},
+			...model !== null ? { model } : {},
+			features: device.features,
+			boundCaps,
+			zones,
+			switches,
+			ptzPresets,
+			slices: Object.keys(snapshot)
+		};
+	}
+	async loadBoundCaps(deviceId) {
+		try {
+			return (await this.ctx.api.deviceManager.getBindings.query({ deviceId })).entries.map((entry) => entry.capName);
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read bindings, exporting without them", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return [];
+		}
+	}
+	async loadZones(deviceId) {
+		try {
+			const snapshot = await this.ctx.api.zoneAnalytics.getCurrentSnapshot.query({ deviceId });
+			if (snapshot === null) return [];
+			return snapshot.zones.map((zone) => ({
+				id: zone.zoneId,
+				name: zone.zoneName
+			}));
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read zones, exporting no zone entities", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return [];
+		}
+	}
+	async loadSwitches(deviceId) {
+		try {
+			return (await this.ctx.api.pipelineOrchestrator.getCameraSwitches.query({ deviceId })).switches.map((sw) => ({
+				id: sw.id,
+				label: sw.label,
+				available: sw.available
+			}));
+		} 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", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return [];
+		}
+	}
+	async loadPresets(deviceId) {
+		try {
+			const device = await this.ctx.fetchDevice(deviceId);
+			if (device.ptz === void 0) return [];
+			return (await device.ptz.getPresets({})).map((preset) => preset.name);
+		} catch (err) {
+			this.ctx.logger.debug("ha-export: could not probe PTZ presets", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return [];
+		}
+	}
+	/**
+	* Resolve every Home Assistant broker, and open a push client for the
+	* ones the operator ticked.
+	*
+	* Credentials come through the `broker` cap — the sanctioned no-import
+	* path — and the owning `addonId` is sent with the read: `broker` is a
+	* COLLECTION cap, so an unpinned id-keyed call routes to the
+	* first-registered provider, which returns `null` for a broker it does
+	* not own.
+	*/
+	async refreshBrokers() {
+		const haBrokers = (await this.ctx.api.broker.list.query({})).filter((broker) => broker.kind === "home-assistant");
+		const known = haBrokers.map((broker) => ({
+			id: broker.id,
+			name: broker.name
+		}));
+		const pruned = pruneBrokers(this.config.membership, haBrokers.map((broker) => broker.id));
+		if (pruned !== this.config.membership || !sameBrokers(known, this.config.knownBrokers)) await this.updateGlobalSettings({
+			knownBrokers: known,
+			membership: pruned
+		});
+		const wanted = new Set(this.enabledBrokerIds());
+		for (const [brokerId, link] of this.links) {
+			if (wanted.has(brokerId)) continue;
+			await link.client.dispose();
+			this.links.delete(brokerId);
+			this.ctx.logger.info("ha-export: stopped exporting to a broker", { meta: { brokerId } });
+		}
+		for (const broker of haBrokers) {
+			if (!wanted.has(broker.id)) continue;
+			if (this.links.has(broker.id)) continue;
+			const resolved = await this.resolveBrokerConnection(broker.id, broker.addonId);
+			if (resolved === null) continue;
+			const client = new PushClient({
+				transport: (message) => postToHomeAssistant(resolved.baseUrl, resolved.token, message),
+				logger: this.ctx.logger,
+				brokerId: broker.id,
+				onLinkRestored: (brokerId) => this.reachability.request(brokerId)
+			});
+			client.start();
+			this.links.set(broker.id, {
+				brokerId: broker.id,
+				name: broker.name,
+				baseUrl: resolved.baseUrl,
+				token: resolved.token,
+				client
+			});
+			this.ctx.logger.info("ha-export: exporting to Home Assistant", { meta: {
+				brokerId: broker.id,
+				baseUrl: resolved.baseUrl
+			} });
+		}
+	}
+	async resolveBrokerConnection(brokerId, addonId) {
+		try {
+			const raw = await this.ctx.api.broker.getBrokerConfig.query({
+				id: brokerId,
+				addonId
+			});
+			if (raw === null) {
+				this.ctx.logger.warn("ha-export: broker returned no configuration, not exporting to it", { meta: { brokerId } });
+				return null;
+			}
+			const supervisorToken = readString(raw, "supervisorToken");
+			if (supervisorToken !== null)
+ /**
+			* A Home Assistant OS install has no `baseUrl` — the supervisor
+			* proxies Core on a fixed internal address. Handling this branch
+			* is the difference between working and pushing at `undefined`.
+			*/
+			return {
+				baseUrl: "http://supervisor/core",
+				token: supervisorToken
+			};
+			const baseUrl = readString(raw, "baseUrl");
+			const accessToken = readString(raw, "accessToken");
+			if (baseUrl === null || accessToken === null) {
+				this.ctx.logger.warn("ha-export: broker configuration has no URL or token, skipping it", { meta: { brokerId } });
+				return null;
+			}
+			return {
+				baseUrl,
+				token: accessToken
+			};
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read broker configuration", { meta: {
+				brokerId,
+				error: errMsg(err)
+			} });
+			return null;
+		}
+	}
+	enabledBrokerIds() {
+		return this.config.knownBrokers.filter((broker) => this.config[`exportTo:${broker.id}`] === true).map((broker) => broker.id);
+	}
+	brokerName(brokerId) {
+		return this.config.knownBrokers.find((broker) => broker.id === brokerId)?.name ?? brokerId;
+	}
+	async handleCommandRoute(body, reply) {
+		const topic = readString(body, "topic");
+		const value = readString(body, "value");
+		if (topic === null || value === null) {
+			reply.status(422);
+			reply.send({ error: "expected {topic, value}" });
+			return;
+		}
+		const parsed = parseCommandTopic(topic);
+		if (parsed === null) {
+			this.ctx.logger.warn("ha-export: dropping a command on a malformed topic", { meta: { topic } });
+			reply.status(422);
+			reply.send({ error: "malformed topic" });
+			return;
+		}
+		const exported = this.exported.get(parsed.deviceKey);
+		if (exported === void 0) {
+			this.ctx.logger.warn("ha-export: dropping a command for a device that is not exported", { meta: {
+				topic,
+				deviceKey: parsed.deviceKey
+			} });
+			reply.status(422);
+			reply.send({ error: "device not exported" });
+			return;
+		}
+		const command = resolveCommand(exported.target, parsed.entity, value);
+		if (command === null) {
+			this.ctx.logger.warn("ha-export: dropping an unroutable command", {
+				tags: { deviceId: exported.deviceId },
+				meta: {
+					topic,
+					entity: parsed.entity
+				}
+			});
+			reply.status(422);
+			reply.send({ error: "unroutable command" });
+			return;
+		}
+		const applied = await this.dispatch(command);
+		reply.status(applied ? 200 : 422);
+		reply.send(applied ? {} : { error: "command not applied" });
+	}
+	async dispatch(command) {
+		try {
+			switch (command.kind) {
+				case "camera-switch": {
+					const parsed = CameraSwitchIdSchema.safeParse(command.switchId);
+					if (!parsed.success) {
+						this.ctx.logger.warn("ha-export: dropping a command for an unknown camera switch", {
+							tags: { deviceId: command.deviceId },
+							meta: { switchId: command.switchId }
+						});
+						return false;
+					}
+					await this.ctx.api.pipelineOrchestrator.setCameraSwitch.mutate({
+						deviceId: command.deviceId,
+						switchId: parsed.data,
+						enabled: command.enabled
+					});
+					return true;
+				}
+				case "reboot": {
+					const device = await this.ctx.fetchDevice(command.deviceId);
+					if (device.reboot === void 0) return this.noProvider(command.deviceId, "reboot");
+					await device.reboot.reboot({});
+					return true;
+				}
+				case "ptz-move": {
+					const device = await this.ctx.fetchDevice(command.deviceId);
+					if (device.ptz === void 0) return this.noProvider(command.deviceId, "ptz");
+					await device.ptz.move(PTZ_MOVE_BY_DIRECTION[command.direction] ?? {});
+					return true;
+				}
+				case "ptz-preset": {
+					const device = await this.ctx.fetchDevice(command.deviceId);
+					if (device.ptz === void 0) return this.noProvider(command.deviceId, "ptz");
+					const preset = (await device.ptz.getPresets({})).find((entry) => entry.name === command.preset);
+					if (preset === void 0) {
+						this.ctx.logger.warn("ha-export: dropping a preset command, no preset by that name", {
+							tags: { deviceId: command.deviceId },
+							meta: { preset: command.preset }
+						});
+						return false;
+					}
+					await device.ptz.goToPreset({ presetId: preset.id });
+					return true;
+				}
+				case "snooze": return await this.applySnooze(command.deviceId, command.minutes);
+				case "cap-switch": {
+					const device = await this.ctx.fetchDevice(command.deviceId);
+					if (device.switch === void 0) return this.noProvider(command.deviceId, "switch");
+					await device.switch.setState({ on: command.on });
+					return true;
+				}
+				case "cap-button": {
+					const device = await this.ctx.fetchDevice(command.deviceId);
+					if (device.button === void 0) return this.noProvider(command.deviceId, "button");
+					await device.button.press({});
+					return true;
+				}
+			}
+		} catch (err) {
+			/**
+			* No optimistic ack. Every writable entity promises HA that the
+			* state topic is reality; acking a failed call makes that a lie in
+			* the only case that matters. The next reconcile corrects HA's UI.
+			*/
+			this.ctx.logger.warn("ha-export: command not applied", {
+				tags: { deviceId: command.deviceId },
+				meta: {
+					kind: command.kind,
+					error: errMsg(err)
+				}
+			});
+			return false;
+		}
+	}
+	/** A cap the device does not provide. Refused, and never silently. */
+	noProvider(deviceId, capName) {
+		this.ctx.logger.warn("ha-export: dropping a command, the device has no provider for it", {
+			tags: { deviceId },
+			meta: { capName }
+		});
+		return false;
+	}
+	async applySnooze(deviceId, minutes) {
+		if (minutes === null) {
+			const { snoozes } = await this.ctx.api.notificationRules.listSnoozes.query({});
+			const mine = snoozes.filter((snooze) => snooze.deviceId === deviceId);
+			for (const snooze of mine) await this.ctx.api.notificationRules.cancelSnooze.mutate({ snoozeId: snooze.id });
+			this.ctx.logger.info("ha-export: cancelled snoozes from Home Assistant", {
+				tags: { deviceId },
+				meta: { cancelled: mine.length }
+			});
+			return true;
+		}
+		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 }
+		});
+		return true;
+	}
+	/**
+	* A public, signed, expiring route Home Assistant can fetch bytes from.
+	*
+	* Public because the fetcher is HA's frontend or a phone, neither of
+	* which holds a camstack token; signed and expiring so a leaked link
+	* stops working on its own.
+	*/
+	async serveMediaPlane() {
+		const dataPlane = this.ctx.dataPlane;
+		if (dataPlane === void 0) {
+			this.ctx.logger.warn("ha-export: no data plane on this runner — image entities will carry no URL");
+			return;
+		}
+		const served = await dataPlane.serve({
+			prefix: "ha-media",
+			access: "public",
+			handler: async (req, res) => {
+				await this.serveMedia(req, res);
+			}
+		});
+		this.ctx.addDisposer(async () => {
+			await served.dispose();
+		});
+	}
+	async serveMedia(req, res) {
+		const url = new URL(req.url ?? "/", "http://localhost");
+		const segments = url.pathname.split("/").filter((part) => part.length > 0);
+		const id = segments[segments.length - 1];
+		if (id === void 0) {
+			res.statusCode = 400;
+			res.end();
+			return;
+		}
+		const trackId = decodeURIComponent(id);
+		if (!verifyMediaSignature({
+			secret: this.mediaSecret,
+			id: trackId,
+			exp: url.searchParams.get("exp") ?? void 0,
+			sig: url.searchParams.get("sig") ?? void 0,
+			nowMs: Date.now()
+		})) {
+			res.statusCode = 403;
+			res.end();
+			return;
+		}
+		try {
+			const first = (await this.ctx.api.pipelineAnalytics.getTrackMedia.query({
+				trackId,
+				kinds: [
+					"thumbnailSmall",
+					"thumbnail",
+					"crop"
+				]
+			}))[0];
+			if (first === void 0) {
+				res.statusCode = 404;
+				res.end();
+				return;
+			}
+			const bytes = Buffer.from(first.base64, "base64");
+			res.statusCode = 200;
+			res.setHeader("content-type", "image/jpeg");
+			res.setHeader("cache-control", "public, max-age=3600");
+			res.end(bytes);
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: media fetch failed", { meta: {
+				trackId,
+				error: errMsg(err)
+			} });
+			res.statusCode = 502;
+			res.end();
+		}
+	}
+	/**
+	* Mint a link, or `null`.
+	*
+	* `null` when the hub has no reachable base URL: a URL Home Assistant
+	* cannot open is worse than no image, because it renders as a broken
+	* entity rather than an empty one.
+	*/
+	mintTrackMediaUrl(trackId) {
+		if (this.mediaBaseUrl === null || this.mediaSecret.length === 0) return null;
+		return buildMediaUrl({
+			baseUrl: this.mediaBaseUrl,
+			routePrefix: MEDIA_ROUTE_PREFIX,
+			id: trackId,
+			secret: this.mediaSecret,
+			expMs: Date.now() + MEDIA_URL_TTL_MS
+		});
+	}
+	async refreshMediaBaseUrl() {
+		if (this.config.publicBaseUrl.length > 0) {
+			this.mediaBaseUrl = this.config.publicBaseUrl;
+			return;
+		}
+		try {
+			const { endpoints } = await this.ctx.api.localNetwork.getConnectionEndpoints.query({ port: HUB_API_PORT });
+			/**
+			* Lowest priority wins, loopback never: a link Home Assistant
+			* cannot open is worse than no image, because it renders as a
+			* broken entity rather than an empty one.
+			*/
+			const usable = [...endpoints].filter((endpoint) => endpoint.kind !== "loopback" && endpoint.plausible).sort((a, b) => a.priority - b.priority)[0];
+			this.mediaBaseUrl = usable?.baseUrl ?? null;
+		} catch (err) {
+			this.mediaBaseUrl = null;
+			this.ctx.logger.debug("ha-export: could not resolve a media base URL", { meta: { error: errMsg(err) } });
+		}
+		if (this.mediaBaseUrl === null) this.ctx.logger.warn("ha-export: no reachable hub URL — image entities will carry no value until one is set");
+	}
+	/**
+	* The cap-level expose/unexpose applies to EVERY enabled broker.
+	*
+	* The `device-export` cap is the COMMON surface across export targets
+	* and has no notion of a broker; per-broker granularity lives in the
+	* derived Export panel, over the same store. There is exactly one
+	* authority either way.
+	*/
+	async setMembershipEverywhere(deviceId, exposed) {
+		let next = this.config.membership;
+		for (const brokerId of this.enabledBrokerIds()) next = setExposed(next, brokerId, deviceId, exposed);
+		if (next === this.config.membership) {
+			this.ctx.logger.debug("ha-export: membership already in that state, nothing to do", {
+				tags: { deviceId: Number(deviceId) },
+				meta: { exposed }
+			});
+			return;
+		}
+		await this.updateGlobalSettings({ membership: next });
+		this.ctx.logger.info("ha-export: export membership changed", {
+			tags: { deviceId: Number(deviceId) },
+			meta: {
+				exposed,
+				brokers: this.enabledBrokerIds()
+			}
+		});
+		await this.reconcile(exposed ? "expose" : "unexpose");
+	}
+	globalSettingsSchema() {
+		const brokerFields = this.config.knownBrokers.map((broker) => ({
+			type: "boolean",
+			key: `exportTo:${broker.id}`,
+			label: broker.name,
+			description: `Push entities to this Home Assistant instance (${broker.id}).`,
+			style: "switch",
+			default: false
+		}));
+		return { sections: [{
+			id: "ha-export-brokers",
+			title: "Home Assistant instances",
+			description: brokerFields.length > 0 ? "One switch per Home Assistant broker. An instance that is off receives nothing; the devices exported to it are remembered and resume when it is turned back on." : "No Home Assistant broker is registered yet. Add one under External systems → Brokers and it will appear here.",
+			columns: 1,
+			fields: brokerFields.length > 0 ? brokerFields : [{
+				type: "info",
+				key: "ha-export:__no-brokers",
+				label: "No brokers",
+				content: "Register a Home Assistant broker to enable the export.",
+				variant: "warning"
+			}]
+		}, {
+			id: "ha-export-transport",
+			title: "Transport",
+			columns: 1,
+			fields: [{
+				type: "text",
+				key: "publicBaseUrl",
+				label: "Hub URL Home Assistant can reach",
+				description: "Used to build the signed image links Home Assistant fetches. Leave empty to derive one from the network capabilities; a link that cannot be built is never sent.",
+				default: ""
+			}, {
+				type: "number",
+				key: "reconcileIntervalSec",
+				label: "Reconcile interval (s)",
+				description: "Full re-announce and re-push cadence. Bus events are telemetry and may be dropped; this is the contract.",
+				default: DEFAULT_CONFIG.reconcileIntervalSec
+			}]
+		}] };
+	}
+	/**
+	* Per-device Export panel — one switch PER BROKER.
+	*
+	* Field keys are namespaced `haExport:<deviceId>:<brokerId>`: the
+	* device-details form flattens fields by key across every contributing
+	* section, so a bare `enabled` collides with the Alexa and HomeKit
+	* exporters' identically-named fields and the operator sees another
+	* exporter's value in this one's toggle.
+	*/
+	buildContribution(deviceId) {
+		const idStr = String(deviceId);
+		const enabled = this.enabledBrokerIds();
+		const fields = enabled.map((brokerId) => ({
+			type: "boolean",
+			key: `haExport:${deviceId}:${brokerId}`,
+			label: `Export to ${this.brokerName(brokerId)}`,
+			description: "Entities for this device are pushed to that Home Assistant instance.",
+			style: "switch",
+			value: isExposed(this.config.membership, brokerId, idStr),
+			immediate: true
+		}));
+		return {
+			tabs: [{
+				id: "export",
+				label: "Export",
+				icon: "share-2",
+				order: 80
+			}],
+			sections: [{
+				id: "ha-export",
+				title: "Home Assistant",
+				description: enabled.length > 0 ? "Each Home Assistant instance receives only the devices switched on for it." : "No Home Assistant instance is enabled for export. Turn one on in the Home Assistant Export addon settings.",
+				tab: "export",
+				columns: 1,
+				order: 30,
+				fields: fields.length > 0 ? fields : [{
+					type: "info",
+					key: `haExport:${deviceId}:__none`,
+					label: "Not configured",
+					content: "Enable a Home Assistant instance in the addon settings first.",
+					variant: "info"
+				}]
+			}]
+		};
+	}
+	async applyDeviceSettingsPatch(deviceId, patch) {
+		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);
+			touched = true;
+		}
+		if (!touched) return { success: true };
+		await this.updateGlobalSettings({ membership: next });
+		this.ctx.logger.info("ha-export: per-broker export membership changed", {
+			tags: { deviceId },
+			meta: { brokers: brokersExposing(next, idStr) }
+		});
+		await this.reconcile("device-panel");
+		return { success: true };
+	}
+	buildStatus() {
+		const enabled = this.enabledBrokerIds();
+		const healthy = [...this.links.values()].filter((link) => link.client.healthy).length;
+		return {
+			linkState: enabled.length === 0 ? "unlinked" : healthy === this.links.size ? "linked" : "error",
+			exposedDeviceCount: exposedDeviceIds(this.config.membership, enabled).length,
+			...this.lastError !== void 0 ? { error: this.lastError } : {},
+			setup: {
+				fields: [
+					{
+						label: "Home Assistant instances",
+						value: `${healthy} / ${this.links.size} reachable`
+					},
+					{
+						label: "Entities pushed",
+						value: String(this.entityCount)
+					},
+					{
+						label: "Push endpoint",
+						value: PUSH_PATH
+					},
+					{
+						label: "Capabilities unclassified",
+						value: this.unclassified.length === 0 ? "none" : this.unclassified.join(", ")
+					},
+					{
+						label: "Snooze options",
+						value: SNOOZE_OPTIONS.join(", ")
+					}
+				],
+				note: "CamStack pushes to the CamStack custom component in Home Assistant. Home Assistant never polls the hub for a value; when the heartbeat stops, every entity is marked unavailable."
+			}
+		};
+	}
+	startTimer() {
+		this.stopTimer();
+		const ms = Math.max(30, this.config.reconcileIntervalSec) * 1e3;
+		this.reconcileTimer = setInterval(() => void this.reconcile("periodic"), ms);
+	}
+	stopTimer() {
+		if (this.reconcileTimer !== null) clearInterval(this.reconcileTimer);
+		this.reconcileTimer = null;
+	}
+};
+/**
+* Device kinds the picker offers.
+*
+* Every kind camstack models: coverage is decided by a device's
+* CAPABILITIES, not its type, and restricting the picker by type is what
+* confined the previous exporter to cameras.
+*/
+var SUPPORTED_DEVICE_KINDS = [
+	"camera",
+	"light",
+	"siren",
+	"switch",
+	"sensor",
+	"thermostat",
+	"climate",
+	"button",
+	"event-emitter",
+	"update",
+	"generic",
+	"lock",
+	"cover",
+	"valve",
+	"humidifier",
+	"water-heater",
+	"fan",
+	"media-player",
+	"alarm-panel",
+	"control",
+	"presence",
+	"weather",
+	"vacuum",
+	"lawn-mower",
+	"container",
+	"image",
+	"pet-feeder",
+	"hub"
+];
+/**
+* POST one message to Home Assistant's push view.
+*
+* Authenticated with the broker's OWN long-lived token: the component
+* registers its view behind HA auth, so there is no second shared secret
+* to configure or rotate. A non-2xx throws, which is how the push client
+* learns the instance is unreachable.
+*/
+async function postToHomeAssistant(baseUrl, token, message) {
+	const response = await fetch(`${baseUrl.replace(/\/+$/, "")}${PUSH_PATH}`, {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify(message),
+		signal: AbortSignal.timeout(1e4)
+	});
+	if (!response.ok) throw new Error(`Home Assistant answered ${response.status}`);
+}
+function randomSecret() {
+	const bytes = new Uint8Array(32);
+	crypto.getRandomValues(bytes);
+	return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function sameBrokers(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((broker, index) => {
+		const other = b[index];
+		return other !== void 0 && other.id === broker.id && other.name === broker.name;
+	});
+}
+function toSnapshot(raw) {
+	if (raw === null || raw === void 0 || typeof raw !== "object") return {};
+	const out = {};
+	for (const [cap, slice] of Object.entries(raw)) if (slice !== null && typeof slice === "object") out[cap] = { ...slice };
+	return out;
+}
+function toCountRecord(raw) {
+	if (raw === null || typeof raw !== "object") return {};
+	const out = {};
+	for (const [key, value] of Object.entries(raw)) if (typeof value === "number") out[key] = value;
+	return out;
+}
+function readRecordField(source, key) {
+	if (source === null || typeof source !== "object") return void 0;
+	return Reflect.get(source, key);
+}
+function readString(source, key) {
+	const value = readRecordField(source, key);
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readNumber(source, key) {
+	const value = readRecordField(source, key);
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readRecord(source, key) {
+	const value = readRecordField(source, key);
+	if (value === null || typeof value !== "object") return null;
+	return { ...value };
+}
+function readStringArray(source, key) {
+	const value = readRecordField(source, key);
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => typeof entry === "string");
+}
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
+export { HaExportAddon, HaExportAddon as default };