@camstack/addon-provider-homeassistant 1.2.28 → 1.2.30

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

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 //#endregion
-const require_dist = require("../dist-D_Zn5oFS.js");
+const require_dist = require("../dist-XWveotlj.js");
 let node_crypto = require("node:crypto");
 //#region src/ha-export/topics.ts
 /**
@@ -67,11 +67,861 @@ function humanise(entity) {
 function toComponentKey(platform, entity) {
 	return `${platform}-${entity.replace(/_/g, "-").replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 }
+/**
+* The entity id of a DERIVED capability entity — the one expression.
+*
+* The derived half of the catalog names its entity after the capability
+* it comes from, and the projector has to publish to that exact name.
+* They used to be two expressions in two files, and they disagreed:
+* the catalog built `camstack/<key>/motion` while the projector
+* published `motion_detected`, `triggered` and a set of doorbell topics
+* of its own. **Only `battery` and `online` lined up**, so a non-camera
+* motion, contact, smoke, leak or doorbell device got entities that
+* could never receive a value — the same failure the 2026-08-05 audit
+* measured on the old exporter (177 of 293 devices), reproduced on a
+* narrower set.
+*
+* Both sides now come from here, and
+* `__tests__/state-projector.spec.ts` walks every `CAP_ENTITY_MAP` entry
+* asserting the catalog's `state_topic` is the topic the projector
+* publishes to. That test is the guard: it fails the moment either side
+* drifts.
+*/
+function derivedEntityId(capName) {
+	return toSlug(capName);
+}
+/**
+* The entity id of a SECONDARY entity of the same capability.
+*
+* The nine allowed platforms cannot express a cover, a thermostat or a
+* media player as one entity, so a capability may produce several: a
+* `cover` is its state AND its position, a `climate-control` is its mode
+* AND the temperature it measures. They are still ONE capability and one
+* slice, so their ids are built from the same expression as the primary
+* — `<cap>_<suffix>` — rather than invented per row. Two expressions in
+* two files is exactly what left a non-camera contact sensor with an
+* entity that could never receive a value.
+*/
+function derivedExtraEntityId(capName, suffix) {
+	return `${toSlug(capName)}_${toSlug(suffix)}`;
+}
 /** 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/camera-entities.ts
+/**
+* The live `camera` entities — one per STREAM of the camera.
+*
+* ── What was wrong, measured on the operator's Home Assistant ────────────
+*
+* This module used to mint six components per camera (three profiles ×
+* muted/unmuted), each carrying a broker RTSP url on a `state_topic`,
+* behind two url gates: a refusal for a credential in the authority and a
+* refusal for a loopback host. On 2026-08-14 the live registry was read:
+* `platform: camstack` held **165 entities and exactly two `camera` ones**
+* — one per exported camera, `unique_id` `camstack_<stableId>_camera`.
+* None of the twelve announced stream components existed.
+*
+* They never could. `custom_components/camstack/camera.py` builds its
+* cameras from the export MEMBERSHIP, not from `cmps`: a still comes from
+* `snapshot.getSnapshot` and live video from `webrtcSession.handleOffer`,
+* which is native WebRTC and has no use for an RTSP address. The
+* component's platform probe answers `camera` — truthfully, it builds the
+* platform — and the hub read that as "it will build MY camera
+* components". Twelve components, two entities, no warning on either
+* side.
+*
+* ── What this module is now ──────────────────────────────────────────────
+*
+* One component per entry of `webrtcSession.listStreams`, carrying the
+* `target` verbatim so the component hands it back to `handleOffer`. No
+* url crosses, which is why the two gates are gone rather than kept "just
+* in case": there is no address here to leak a password or to point at
+* 127.0.0.1, and a gate guarding a value that no longer exists is the
+* leftover that reads as verification.
+*
+* ── The adaptive stream is announced by NOBODY, on purpose ───────────────
+*
+* The component's membership entity IS the adaptive stream: it negotiates
+* no target, it is the device's primary camera (`_attr_name = None`), and
+* it has carried `camstack_<stableId>_camera` since the integration
+* shipped. Announcing a component for it would claim the same
+* `unique_id` — Home Assistant keys its registry on
+* `(platform, integration, unique_id)` — and one of the two would lose the
+* race and be dropped with a "does not generate unique IDs" error. So the
+* operator's existing `camera.videocamera_ingresso` is left exactly where
+* it is and gains SIBLINGS: one per profile, one per substream, which are
+* the streams membership cannot express.
+*
+* ── Fan-out ──────────────────────────────────────────────────────────────
+*
+* Every remaining stream is announced. What arrives ENABLED is the
+* assigned profiles — the pictures an operator picks between on a
+* dashboard. The raw `cam-stream` sources (the camera's own main/sub
+* substreams) are registered-and-off: they are the same pictures the
+* profiles already serve, one layer below the slot the rest of camstack
+* dials, and an operator who wants one switches it on per camera.
+*/
+/** Profile slots, in the order an operator reads them. */
+var CAMERA_PROFILE_ORDER = [
+	"high",
+	"mid",
+	"low"
+];
+/** `high` → 0. An unknown profile sorts after the known ones, stably. */
+function profileRank(profile) {
+	const index = CAMERA_PROFILE_ORDER.indexOf(profile);
+	return index === -1 ? CAMERA_PROFILE_ORDER.length : index;
+}
+/**
+* Reading order: adaptive, then the profile slots high → mid → low, then
+* whatever raw sources the camera reports, in the hub's own order.
+*
+* Rank only. The one stream that does NOT become a component is the
+* adaptive one, and it is filtered by {@link isAnnounced} rather than
+* here, because it is not a drop: it reaches Home Assistant on the
+* membership entity. Every other slot the hub reports becomes an entity —
+* "include all the streams of a camera" is the request this module exists
+* to answer, and a slot silently dropped is a loss the operator cannot see
+* from Home Assistant.
+*/
+function streamRank(target) {
+	switch (target.kind) {
+		case "adaptive": return 0;
+		case "profile": return 1 + profileRank(target.profile);
+		case "cam-stream": return 1 + CAMERA_PROFILE_ORDER.length;
+	}
+}
+/**
+* The adaptive stream is the component's own entity and gets no component.
+*
+* The one filter in this file, and the reason it is not the "drop a slot"
+* kind: the stream still reaches Home Assistant, on the entity that has
+* always carried it. See the identity note above.
+*/
+function isAnnounced(target) {
+	return target.kind !== "adaptive";
+}
+/**
+* The entity id of one stream.
+*
+* Derived from the TARGET rather than from `choice.id`, so the ids stay
+* `stream_high` / `stream_mid` / `stream_low` — what this file already
+* announced — instead of following the picker's `profile:high` spelling.
+* An entity id is identity; the picker's id is a React key.
+*/
+function entityIdFor(target) {
+	switch (target.kind) {
+		case "adaptive":
+ /* c8 ignore next -- filtered by isAnnounced before it can be reached */
+		return "stream_adaptive";
+		case "profile": return `stream_${toSlug(target.profile)}`;
+		case "cam-stream": return `stream_${toSlug(target.camStreamId)}`;
+	}
+}
+/**
+* Enabled by default: the assigned profiles.
+*
+* A raw `cam-stream` is the source a profile slot already points at. It
+* is announced so an operator who wants the camera's own substream can
+* have it, and it is off so that a camera does not arrive with six
+* pictures of the same doorway switched on.
+*/
+function enabledByDefaultFor(target) {
+	return target.kind !== "cam-stream";
+}
+/**
+* The label an operator reads on a card.
+*
+* The hub's own label plus the vertical resolution, because that is the
+* one thing that distinguishes three pictures of the same doorway —
+* "Stream high (2160p)" answers "which of these do I put on the wall
+* tablet" and "Stream high" does not. The resolution is only in the label
+* (never in the id), so a re-encoded profile renames an entity and never
+* orphans one.
+*/
+function labelFor(choice) {
+	const base = `Stream ${choice.label.toLowerCase()}`;
+	return choice.height === void 0 ? base : `${base} (${choice.height}p)`;
+}
+/**
+* Stream list → the `camera` entities the catalog builds.
+*
+* Pure, and value-free: a `camera` entity has no state on the push plane
+* at all. It exists because the hub lists the stream, and everything the
+* component needs to show it travels in `stream_target`.
+*/
+function cameraStreamEntities(choices) {
+	return [...choices].filter((choice) => isAnnounced(choice.target)).sort((a, b) => streamRank(a.target) - streamRank(b.target)).map((choice) => ({
+		entity: entityIdFor(choice.target),
+		platform: "camera",
+		label: labelFor(choice),
+		enabledByDefault: enabledByDefaultFor(choice.target),
+		target: choice.target
+	}));
+}
+//#endregion
+//#region src/ha-export/component-support.ts
+/** Where the component publishes what it builds. A wire format. */
+var COMPONENT_VERSION_PATH = "/api/camstack/version";
+/**
+* The platforms every released component builds.
+*
+* Assumed when the component does not answer the probe at all, which is
+* exactly what 0.3.x and older do: the endpoint arrived with the native
+* platforms. `alarm_control_panel` is deliberately ABSENT — the export has
+* been emitting it since T1 and the 0.3.x component never built it, so
+* assuming it here would keep an alarm panel invisible on the very
+* installations this list exists to protect.
+*/
+var LEGACY_PLATFORMS = [
+	"binary_sensor",
+	"sensor",
+	"image",
+	"switch",
+	"button",
+	"select",
+	"camera",
+	"number"
+];
+var LEGACY_SUPPORT = new Set(LEGACY_PLATFORMS);
+/**
+* What the catalog assumes when NOBODY asked.
+*
+* Deliberately not {@link LEGACY_SUPPORT}: the platforms the degraded
+* tables themselves name, which is exactly the behaviour the export had
+* before any of this existed. A caller that does not negotiate therefore
+* gets what it always got — no native platforms, and no degradation
+* either. Both changes are decisions the NEGOTIATION makes, on an answer
+* from the Home Assistant that has to build them, and neither is a
+* default a test fixture or a future caller can trip over by accident.
+*/
+var UNNEGOTIATED_SUPPORT = new Set([...LEGACY_PLATFORMS, "alarm_control_panel"]);
+var KNOWN_PLATFORMS = new Set([
+	"binary_sensor",
+	"sensor",
+	"image",
+	"switch",
+	"button",
+	"select",
+	"camera",
+	"alarm_control_panel",
+	"number",
+	"cover",
+	"climate",
+	"lock",
+	"fan",
+	"vacuum",
+	"valve",
+	"humidifier",
+	"water_heater",
+	"media_player"
+]);
+function isKnownPlatform(value) {
+	return KNOWN_PLATFORMS.has(value);
+}
+/**
+* Parse the component's answer.
+*
+* A platform this hub does not know is DROPPED rather than refused: the
+* component ships on its own train and may well build something newer
+* than this hub can emit, and refusing the whole report over one unknown
+* name would downgrade every entity on that installation.
+*/
+function parseComponentReport(body) {
+	if (body === null || typeof body !== "object") return null;
+	const raw = Reflect.get(body, "platforms");
+	if (!Array.isArray(raw)) return null;
+	const platforms = /* @__PURE__ */ new Set();
+	for (const entry of raw) if (typeof entry === "string" && isKnownPlatform(entry)) platforms.add(entry);
+	if (platforms.size === 0) return null;
+	const version = Reflect.get(body, "version");
+	return {
+		version: typeof version === "string" ? version : null,
+		platforms
+	};
+}
+/** Stable, comparable text for a support set. Used for change detection. */
+function supportSignature(support) {
+	return [...support].sort().join(",");
+}
+/**
+* The platforms every one of these components builds.
+*
+* A device exported to two Home Assistant instances is announced ONCE, so
+* a platform only one of them builds cannot be used: the other would
+* receive a component it drops on the floor. Two instances on different
+* component versions is the case this exists for, and the cost is that
+* the newer one waits for the older to be updated — visible in the log,
+* and never an entity that silently does not arrive.
+*/
+function intersectSupport(supports) {
+	const [first, ...rest] = supports;
+	if (first === void 0) return LEGACY_SUPPORT;
+	const out = /* @__PURE__ */ new Set();
+	for (const platform of first) if (rest.every((other) => other.has(platform))) out.add(platform);
+	return out;
+}
+/**
+* Per-broker negotiated support, with the downgrade rule.
+*
+* Pure and injectable-free: the probe is somebody else's job, this only
+* decides what a sequence of answers means.
+*/
+var ComponentSupportTracker = class {
+	current = /* @__PURE__ */ new Map();
+	/** brokerId → the signature of the downgrade that has been seen once. */
+	pendingDowngrade = /* @__PURE__ */ new Map();
+	/** The support in force for a broker. Legacy until something says otherwise. */
+	supportFor(brokerId) {
+		return this.current.get(brokerId) ?? LEGACY_SUPPORT;
+	}
+	/** The support in force for a set of brokers, intersected. */
+	supportForAll(brokerIds) {
+		if (brokerIds.length === 0) return LEGACY_SUPPORT;
+		return intersectSupport(brokerIds.map((id) => this.supportFor(id)));
+	}
+	forget(brokerId) {
+		this.current.delete(brokerId);
+		this.pendingDowngrade.delete(brokerId);
+	}
+	observe(brokerId, probe) {
+		const before = this.supportFor(brokerId);
+		if (probe.kind === "unknown") return {
+			support: before,
+			changed: false,
+			withheldDowngrade: false
+		};
+		const next = probe.kind === "absent" ? LEGACY_SUPPORT : probe.report.platforms;
+		const signature = supportSignature(next);
+		if (signature === supportSignature(before)) {
+			this.pendingDowngrade.delete(brokerId);
+			this.current.set(brokerId, next);
+			return {
+				support: before,
+				changed: false,
+				withheldDowngrade: false
+			};
+		}
+		if ([...before].some((platform) => !next.has(platform)) && this.pendingDowngrade.get(brokerId) !== signature) {
+			this.pendingDowngrade.set(brokerId, signature);
+			return {
+				support: before,
+				changed: false,
+				withheldDowngrade: true
+			};
+		}
+		this.pendingDowngrade.delete(brokerId);
+		this.current.set(brokerId, next);
+		return {
+			support: next,
+			changed: true,
+			withheldDowngrade: false
+		};
+	}
+};
+//#endregion
+//#region src/ha-export/native-platforms.ts
+/**
+* The NATIVE half of the Home Assistant export.
+*
+* A `cover` in Home Assistant is one entity with an open/close/stop
+* surface, a position slider and a tilt slider. Exported through the nine
+* platforms the 0.3.x component builds it is a `sensor` plus two more
+* `sensor`s plus three `button`s — automatable, but not a cover: no
+* `cover.open_cover`, no position in the more-info dialog, no
+* `device_class: garage`, and every dashboard card that expects a cover
+* refuses it. Same for a lock (`jammed` is not a boolean), a thermostat,
+* a vacuum and a media player.
+*
+* From component 0.4.0 those platforms exist, and this table says which
+* capability becomes which one. It is **structure only**: the topics a
+* native component names are the topics the DEGRADED entities already
+* used, so `state-projector.ts` is untouched and the value plane cannot
+* disagree with the entity plane. Nothing here publishes a value.
+*
+* ── Three rules, each with a cost behind it ──────────────────────────────
+*
+* 1. **A control appears only when its descriptor is writable.** The
+*    authority is `CAP_ENTITY_MAP` — the same flag that decides whether the
+*    degraded entity gets a command topic, and therefore the same flag that
+*    tracks `CAP_COMMAND_ROUTES`. A native cover on a hub whose route table
+*    cannot move a cover is a READ-ONLY cover: it shows state, position and
+*    tilt and offers no buttons. A control that calls nothing is the defect
+*    this repo has shipped twice (D62), and a prettier platform is not a
+*    reason to ship it a third time.
+*
+* 2. **A binding whose entity does not exist is skipped.** The degraded
+*    table is being widened in parallel (verb buttons, writable numbers).
+*    Every binding below is resolved against `CAP_ENTITY_MAP` at build
+*    time, so a control lights up the moment its descriptor appears and
+*    costs nothing until then. This is what lets the two halves land in
+*    either order.
+*
+* 3. **What the native entity reads, it OWNS — and only that.** A bound
+*    entity is not announced separately: a native cover plus a `sensor`
+*    reporting the same position is two readings of one value, and a native
+*    cover plus a `number` writing the same position is two knobs (D62).
+*    Everything NOT bound stays exactly as it was, and that is the property
+*    that makes widening safe in both directions: a vacuum's error label is
+*    still a diagnostic sensor because HA's vacuum cannot show one, and a
+*    thermostat's vertical-swing toggle is still a `switch` because HA's
+*    climate expresses swing as a mode vocabulary the capability does not
+*    have. A control this table has no binding for is never silently lost —
+*    it is simply not absorbed.
+*/
+/**
+* capability → the native Home Assistant platform it becomes.
+*
+* Every capability here also has a row in `CAP_ENTITY_MAP`, which stays
+* the fallback for a component that does not build the platform. The two
+* are never both announced.
+*/
+var NATIVE_CAP_PLATFORMS = {
+	/**
+	* `CoverStatusSchema`: `state` is the HA lifecycle verbatim
+	* (`open`/`opening`/`closing`/`closed`/`stopped`), `position` and
+	* `tiltPosition` are 0..100 or null. The three verbs are bound BOTH ways:
+	* to the primary command topic (one topic, `OPEN`/`CLOSE`/`STOP`) and to
+	* the per-verb buttons, so whichever the degraded table grows, the
+	* native cover can drive it.
+	*/
+	cover: {
+		platform: "cover",
+		primary: { from: null },
+		controls: {
+			position: {
+				from: "position",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			tilt: {
+				from: "tilt",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			open: {
+				from: "open",
+				commandOnly: true
+			},
+			close: {
+				from: "close",
+				commandOnly: true
+			},
+			stop: {
+				from: "stop",
+				commandOnly: true
+			}
+		}
+	},
+	/** `ValveStatusSchema` — the cover lifecycle without tilt. */
+	valve: {
+		platform: "valve",
+		primary: { from: null },
+		controls: {
+			position: {
+				from: "position",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			open: {
+				from: "open",
+				commandOnly: true
+			},
+			close: {
+				from: "close",
+				commandOnly: true
+			},
+			stop: {
+				from: "stop",
+				commandOnly: true
+			}
+		}
+	},
+	/**
+	* The reason this platform exists. `LockStateSchema` is
+	* `locked | unlocked | locking | unlocking | jammed`, and every one of
+	* those is a state Home Assistant's `lock` has — including the one a
+	* `switch` silently reports as "unlocked".
+	*
+	* It READS the enum extra and WRITES the switch. The degraded primary
+	* publishes a boolean derived from the same field, so binding the state
+	* to it would throw away exactly the distinction the platform is for.
+	*/
+	"lock-control": {
+		platform: "lock",
+		primary: {
+			from: "state",
+			commandFrom: null
+		},
+		controls: { open: {
+			from: "open",
+			commandOnly: true
+		} }
+	},
+	/**
+	* `AlarmStateSchema` IS Home Assistant's alarm vocabulary, and
+	* `availableModes` is the subset this panel accepts — a panel that
+	* cannot arm `vacation` must not offer the button. `requiresCode` is the
+	* panel's own answer about a PIN.
+	*
+	* This is also the only row here whose degraded form is a REGRESSION
+	* rather than the status quo: `CAP_ENTITY_MAP` already names
+	* `alarm_control_panel`, which the 0.3.x component does not build, so an
+	* alarm panel exported to it produces NO entity at all. The fallback
+	* below gives those installations the state as a sensor.
+	*/
+	"alarm-panel": {
+		platform: "alarm_control_panel",
+		primary: {
+			from: null,
+			optionsField: "availableModes"
+		},
+		flagFields: { code_arm_required: "requiresCode" }
+	},
+	/**
+	* `ClimateControlStatusSchema`. Every temperature is Celsius by the
+	* cap's own doc comment, and the mode/fan-mode/preset vocabularies are
+	* `available*` arrays on the DEVICE — which is exactly why they cannot be
+	* a static `select` in the degraded table and can be a native climate
+	* here: the component receives the list with the entity.
+	*/
+	"climate-control": {
+		platform: "climate",
+		primary: {
+			from: null,
+			optionsField: "availableModes"
+		},
+		constants: { temperature_unit: "°C" },
+		controls: {
+			current_temperature: { from: "current-temp" },
+			current_humidity: { from: "current-humidity" },
+			target_humidity: {
+				from: "target-humidity",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			target: {
+				from: "target",
+				min: -20,
+				max: 90,
+				step: .5
+			},
+			target_low: {
+				from: "target-low",
+				min: -20,
+				max: 90,
+				step: .5
+			},
+			target_high: {
+				from: "target-high",
+				min: -20,
+				max: 90,
+				step: .5
+			},
+			fan_mode: {
+				from: "fan-mode",
+				optionsField: "availableFanModes"
+			},
+			preset: {
+				from: "preset",
+				optionsField: "availablePresets"
+			}
+		}
+	},
+	/**
+	* A fan has no `on` field: `percentage` IS its state and 0 is off, which
+	* is what Home Assistant's fan does too (`turn_off` writes 0).
+	* `percentageStep` is the device's own granularity — a 4-speed fan
+	* reports 25, and a step of 1 would offer 37% to hardware that rounds it.
+	*/
+	"fan-control": {
+		platform: "fan",
+		primary: {
+			from: null,
+			min: 0,
+			max: 100,
+			step: 1,
+			stepField: "percentageStep"
+		},
+		controls: {
+			preset: {
+				from: "preset",
+				optionsField: "availablePresets"
+			},
+			oscillation: { from: "oscillating" },
+			direction: { from: "direction" }
+		}
+	},
+	/** `HumidifierStatusSchema`. `minHumidity`/`maxHumidity` are per device. */
+	humidifier: {
+		platform: "humidifier",
+		deviceClass: "humidifier",
+		primary: { from: null },
+		controls: {
+			current_humidity: { from: "current-humidity" },
+			target_humidity: {
+				from: "target-humidity",
+				minField: "minHumidity",
+				maxField: "maxHumidity",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			mode: {
+				from: "mode",
+				optionsField: "availableModes"
+			},
+			action: { from: "action" }
+		}
+	},
+	/**
+	* Home Assistant's water heater IS its operation mode — the entity state
+	* is `eco`/`performance`/`off`, not a temperature. The capability's
+	* primary entity is the MEASURED temperature, so the primary binding
+	* names the mode extra and the measurement becomes a control.
+	*/
+	"water-heater": {
+		platform: "water_heater",
+		primary: {
+			from: "mode",
+			optionsField: "availableModes"
+		},
+		constants: { temperature_unit: "°C" },
+		controls: {
+			current_temperature: { from: null },
+			target: {
+				from: "target",
+				minField: "minTemp",
+				maxField: "maxTemp",
+				min: -20,
+				max: 90,
+				step: .5
+			},
+			away: { from: "away" }
+		}
+	},
+	/**
+	* `VacuumStateSchema` is `idle|cleaning|paused|returning|docked|drying|error`;
+	* Home Assistant has every one but `drying`, which the component folds
+	* into `cleaning` rather than dropping the update.
+	*
+	* Battery, progress and the error label are deliberately NOT absorbed.
+	* Home Assistant deprecated the vacuum battery attribute in favour of a
+	* separate `sensor`, and it has nowhere to show a progress percentage or
+	* a vendor error string at all — as sensors they stay automatable.
+	*/
+	"vacuum-control": {
+		platform: "vacuum",
+		primary: { from: null },
+		controls: {
+			fan_speed: {
+				from: "fan-speed",
+				optionsField: "availableFanSpeeds"
+			},
+			start: {
+				from: "start",
+				commandOnly: true
+			},
+			pause: {
+				from: "pause",
+				commandOnly: true
+			},
+			stop: {
+				from: "stop",
+				commandOnly: true
+			},
+			return_to_base: {
+				from: "return-to-base",
+				commandOnly: true
+			},
+			locate: {
+				from: "locate",
+				commandOnly: true
+			}
+		}
+	},
+	/**
+	* `MediaPlayerStatusSchema`. `volumeLevel` is 0..100 in the cap and
+	* 0..1 in Home Assistant — the component converts, in one place, because
+	* a factor of 100 applied on the wrong side is a player that jumps to
+	* full volume.
+	*
+	* `currentMedia` is an object and stays unexported: title and artist
+	* would need a projector that walks into a sub-object, and an entity
+	* that reports `unrenderable` on every delivery is worse than one that
+	* does not exist.
+	*/
+	"media-player": {
+		platform: "media_player",
+		primary: { from: null },
+		controls: {
+			volume: {
+				from: "volume",
+				min: 0,
+				max: 100,
+				step: 1
+			},
+			mute: { from: "muted" },
+			source: {
+				from: "source",
+				optionsField: "availableSources"
+			},
+			shuffle: { from: "shuffle" },
+			repeat: { from: "repeat" },
+			play: {
+				from: "play",
+				commandOnly: true
+			},
+			pause: {
+				from: "pause",
+				commandOnly: true
+			},
+			stop: {
+				from: "stop",
+				commandOnly: true
+			},
+			next: {
+				from: "next",
+				commandOnly: true
+			},
+			previous: {
+				from: "previous",
+				commandOnly: true
+			}
+		}
+	}
+};
+/**
+* What a platform becomes when the component on the other end cannot
+* build it.
+*
+* The native platforms never reach this: `buildDerivedPlan` asks about
+* support BEFORE choosing one, and falls back to the capability's own
+* degraded row. This is for the other direction — a platform the DEGRADED
+* table already names that an older component still does not build.
+*
+* There is exactly one, and it is a live defect rather than a
+* hypothetical: the export has been announcing `alarm_control_panel`
+* since the native export shipped, and the 0.3.x component builds eight
+* platforms not including it. Every alarm panel exported to one of those
+* installations produced a warning line and no entity at all. A `sensor`
+* carrying the panel state is not an alarm card, but it is a value an
+* operator can automate on, which is strictly more than nothing.
+*/
+var DEGRADED_PLATFORM = { alarm_control_panel: "sensor" };
+/** Whether a capability has a native platform at all. */
+function nativePlatformFor(capName) {
+	return NATIVE_CAP_PLATFORMS[capName]?.platform ?? null;
+}
+function readStringArray$1(slice, field) {
+	const raw = slice?.[field];
+	if (!Array.isArray(raw)) return void 0;
+	const values = raw.filter((entry) => typeof entry === "string");
+	return values.length > 0 ? values : void 0;
+}
+function readNumber$1(slice, field) {
+	const raw = slice?.[field];
+	return typeof raw === "number" && Number.isFinite(raw) ? raw : void 0;
+}
+function resolveEntity(input, suffix) {
+	const { capName, mapping } = input;
+	const descriptor = suffix === null ? mapping : mapping.extras?.[suffix];
+	const isCommandEntity = suffix !== null && descriptor === void 0 && mapping.commands?.[suffix] !== void 0;
+	if (descriptor === void 0 && !isCommandEntity) return null;
+	return {
+		entity: suffix === null ? derivedEntityId(capName) : derivedExtraEntityId(capName, suffix),
+		writable: isCommandEntity || descriptor?.writable === true,
+		descriptor
+	};
+}
+function resolveBinding(input, binding) {
+	const { deviceKey } = input;
+	const source = resolveEntity(input, binding.from);
+	if (source === null) return null;
+	/**
+	* The written entity, when it is not the read one. Absent rather than
+	* refused: a control whose command entity does not exist is still a
+	* READING worth announcing.
+	*/
+	const target = binding.commandFrom === void 0 ? source : resolveEntity(input, binding.commandFrom);
+	const entity = source.entity;
+	const descriptor = source.descriptor;
+	const writable = target?.writable === true;
+	const options = binding.optionsField === void 0 ? void 0 : readStringArray$1(input.slice, binding.optionsField);
+	/**
+	* The DEVICE's own bounds win over the static ones. A heat-pump water
+	* heater that reports `maxTemp: 60` must not offer 90, and a static
+	* range is only ever the backstop for hardware that reports none.
+	*/
+	const min = (binding.minField === void 0 ? void 0 : readNumber$1(input.slice, binding.minField)) ?? descriptor?.range?.min ?? binding.min;
+	const max = (binding.maxField === void 0 ? void 0 : readNumber$1(input.slice, binding.maxField)) ?? descriptor?.range?.max ?? binding.max;
+	const step = (binding.stepField === void 0 ? void 0 : readNumber$1(input.slice, binding.stepField)) ?? descriptor?.range?.step ?? binding.step;
+	const control = {
+		...binding.commandOnly === true ? {} : { state_topic: stateTopic(deviceKey, entity) },
+		...writable && target !== null ? { command_topic: commandTopic(deviceKey, target.entity) } : {},
+		...options !== void 0 ? { options } : {},
+		...min !== void 0 ? { min } : {},
+		...max !== void 0 ? { max } : {},
+		...step !== void 0 ? { step } : {}
+	};
+	return {
+		entities: target === null || target.entity === entity ? [entity] : [entity, target.entity],
+		control
+	};
+}
+/**
+* Build one native component, or `null` when the capability has none.
+*
+* The component's identity — its `unique_id` and therefore the component
+* key — is the capability's PRIMARY entity id, the same one the degraded
+* `sensor` used. Home Assistant keys its registry on
+* `(platform, integration, unique_id)`, so this is a NEW entity even
+* though the id is unchanged, and the old one is removed by the
+* component's own diff rather than left orphaned. That is the whole
+* migration, and `docs/design/ecosystem-export-plan.md` records why an
+* in-place one is not possible.
+*/
+function buildNativeComponent(input) {
+	const native = NATIVE_CAP_PLATFORMS[input.capName];
+	if (native === void 0) return null;
+	const primary = resolveBinding(input, native.primary);
+	if (primary === null) return null;
+	const absorbed = new Set([derivedEntityId(input.capName), ...primary.entities]);
+	const controls = {};
+	for (const [name, binding] of Object.entries(native.controls ?? {})) {
+		const resolved = resolveBinding(input, binding);
+		if (resolved === null) continue;
+		controls[name] = resolved.control;
+		for (const entity of resolved.entities) absorbed.add(entity);
+	}
+	const flags = {};
+	for (const [key, field] of Object.entries(native.flagFields ?? {})) {
+		const raw = input.slice?.[field];
+		if (typeof raw === "boolean") flags[key] = raw;
+	}
+	return {
+		component: {
+			platform: native.platform,
+			unique_id: `${input.stableId}_${derivedEntityId(input.capName)}`,
+			name: input.label,
+			...primary.control,
+			...native.deviceClass !== void 0 ? { device_class: native.deviceClass } : {},
+			...native.icon !== void 0 ? { icon: native.icon } : {},
+			...Object.keys(controls).length > 0 ? { controls } : {},
+			...native.constants,
+			...flags
+		},
+		absorbed
+	};
+}
+//#endregion
 //#region src/ha-export/entity-catalog.ts
 /**
 * The entity catalog — pure. Device + zones + macros → the `cmps` set.
@@ -97,6 +947,11 @@ function toSlug(value) {
 * nothing produces is the failure this repo keeps paying for.
 */
 /**
+* The enums a `select` offers come from the CAP, never from a list here: a
+* second copy of `HvacModeSchema` would be one rename away from offering an
+* operator a mode their thermostat has never heard of.
+*/
+/**
 * The macro classes an operator automates on.
 *
 * Deliberately the macros and NOT the 21 fine classes: those include
@@ -158,6 +1013,29 @@ var ZONE_MACROS = [
 * what the export is for. The three `*_last_image` entities — camera,
 * per macro, per zone × macro — therefore ship enabled. They cost one
 * entity each and carry a signed URL, not bytes.
+*
+* **So are the three things the operator asked for on 2026-08-14**, and
+* each has a reason that is a property of the value rather than a taste:
+*
+*   - **`<macro>_last_detection`, and the camera's own.** "When was a
+*     person last seen" is a timestamp, and half of what an operator
+*     builds on a camera is a duration since one — a `for:` in a
+*     template, a "nobody has been at the door since" notification. A
+*     boolean that is `off` right now cannot answer it.
+*   - **`<macro>_last_label`.** This is where the RECOGNISED FACE and the
+*     read PLATE arrive. It was the single highest-value item in the gap
+*     against the reference integration and it shipped switched off, so
+*     the name camstack worked out was in Home Assistant and invisible.
+*   - **`battery` and `charger` on a battery camera.** A battery
+*     percentage is the headline of a battery device, not a diagnostic
+*     detail about one; `sleeping` stays off because it describes the
+*     power state machine rather than the charge.
+*
+* What stays off is what the valve was built for: the per-macro and
+* per-zone `*_objects` COUNTERS (a count of what is on screen right now,
+* which the `_detected` boolean and the camera-wide `objects` total
+* already answer for automation), the per-zone timestamps, and the
+* doorbell's since-restart counter.
 */
 /**
 * The snooze surface, as a `select`.
@@ -192,25 +1070,96 @@ var PTZ_BUTTONS = [
 	"ptz_zoom_in",
 	"ptz_zoom_out"
 ];
+/**
+* Platforms whose entity carries no value on the push plane.
+*
+* A `button` is a command. A `camera` is a stream the component fetches
+* for itself (`snapshot.getSnapshot` + `webrtcSession.handleOffer`) from
+* the target it is given. Announcing a `state_topic` for either would
+* declare a value nothing ever publishes — which is precisely how twelve
+* camera components came to sit in an announce that produced no entity.
+*/
+var STATELESS_PLATFORMS = new Set(["button", "camera"]);
+/**
+* Platforms that can carry a command topic.
+*
+* `writable` on a descriptor means "the route table writes exactly this
+* value" — a fact about the CAPABILITY. Whether Home Assistant can offer
+* a control for it is a fact about the PLATFORM, and the two are not the
+* same: `climate-control.fanMode` is written by `setFanMode` and has no
+* closed vocabulary, so its degraded form is a `sensor` and its native
+* form is the climate entity's fan-mode control. Announcing a command
+* topic on the degraded `sensor` would describe a control Home Assistant
+* cannot render — a leftover that reads as verification.
+*/
+var COMMANDABLE_PLATFORMS = new Set([
+	"switch",
+	"button",
+	"select",
+	"number",
+	"alarm_control_panel",
+	"cover",
+	"climate",
+	"lock",
+	"fan",
+	"vacuum",
+	"valve",
+	"humidifier",
+	"water_heater",
+	"media_player"
+]);
+/** 0..100, the shape every camstack percentage declares in its own schema. */
+var PERCENT_RANGE = {
+	min: 0,
+	max: 100,
+	step: 1
+};
+/**
+* A temperature setpoint, in Celsius.
+*
+* Deliberately WIDER than any one device: a heat-pump water heater runs to
+* 80 °C, a freezer setpoint is negative, and the per-device truth
+* (`climate-control`'s `getOptions`, `water-heater`'s `minTemp`/`maxTemp`)
+* is on the provider and the slice, not in this static table. Half-degree
+* steps because every thermostat this repo has met accepts them and a step of
+* 1 would make 20.5 unreachable.
+*/
+var TEMPERATURE_RANGE = {
+	min: -20,
+	max: 90,
+	step: .5
+};
+/** `ColorInputSchema` declares mireds as `int().min(50).max(1000)`. */
+var MIRED_RANGE = {
+	min: 50,
+	max: 1e3,
+	step: 1
+};
 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) } : {},
+		...STATELESS_PLATFORMS.has(spec.platform) ? {} : { state_topic: stateTopic(deviceKey, spec.entity) },
+		...spec.writable === true && COMMANDABLE_PLATFORMS.has(spec.platform) ? { 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.range !== void 0 ? {
+			min: spec.range.min,
+			max: spec.range.max,
+			step: spec.range.step
+		} : {},
 		...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" } : {}
+		...spec.platform === "button" ? { payload_press: "PRESS" } : {},
+		...spec.streamTarget !== void 0 ? { stream_target: spec.streamTarget } : {}
 	};
 }
 function deviceBlock(device) {
@@ -363,7 +1312,7 @@ function cameraSpecs(device) {
 			label: "Last detection",
 			deviceClass: "timestamp",
 			icon: "mdi:clock",
-			enabledByDefault: false
+			enabledByDefault: true
 		}
 	];
 	if (device.slices.includes("battery")) specs.push({
@@ -373,14 +1322,14 @@ function cameraSpecs(device) {
 		deviceClass: "battery",
 		unit: "%",
 		entityCategory: "diagnostic",
-		enabledByDefault: false
+		enabledByDefault: true
 	}, {
 		entity: "charger",
 		platform: "binary_sensor",
 		label: "Charging",
 		deviceClass: "battery_charging",
 		entityCategory: "diagnostic",
-		enabledByDefault: false
+		enabledByDefault: true
 	}, {
 		entity: "sleeping",
 		platform: "binary_sensor",
@@ -512,7 +1461,7 @@ function cameraSpecs(device) {
 			platform: "sensor",
 			label: `${label} last detection`,
 			deviceClass: "timestamp",
-			enabledByDefault: false
+			enabledByDefault: true
 		}, {
 			entity: `${macro}_objects`,
 			platform: "sensor",
@@ -525,9 +1474,36 @@ function cameraSpecs(device) {
 			platform: "sensor",
 			label: `${label} last label`,
 			icon: "mdi:tag",
-			enabledByDefault: false
+			enabledByDefault: true
 		});
 	}
+	/**
+	* The live picture — every stream the hub lists EXCEPT the adaptive one,
+	* which the component's own entity already is. See `camera-entities.ts`
+	* for why the entity carries a WebRTC target and not a url, and why
+	* announcing the adaptive stream would collide on an identity that has
+	* shipped.
+	*/
+	for (const stream of cameraStreamEntities(device.streams ?? [])) specs.push({
+		entity: stream.entity,
+		platform: stream.platform,
+		label: stream.label,
+		enabledByDefault: stream.enabledByDefault,
+		streamTarget: stream.target
+	});
+	/**
+	* The two capability-derived entities a camera carries.
+	*
+	* `buildDerivedPlan` is the NON-camera path, so a camera-scoped
+	* capability reaches Home Assistant only if the camera catalog builds
+	* it — and it is built from the same descriptor and the same entity id
+	* as the derived half, so `projectCapSlice` publishes to the topic
+	* this component declares without a second expression anywhere.
+	*/
+	for (const cap of CAMERA_DERIVED_CAPS) {
+		if (!device.boundCaps.includes(cap)) continue;
+		specs.push(...capEntitySpecs(cap));
+	}
 	for (const zone of device.zones) specs.push(...zoneSpecs(zone));
 	return specs;
 }
@@ -545,36 +1521,128 @@ function assemble(device, specs) {
 function buildCameraPlan(device) {
 	return assemble(device, cameraSpecs(device));
 }
+/**
+* capability → the entities it produces.
+*
+* ── What decides read-only ──────────────────────────────────────────────
+*
+* The plan's rule, and D62's rule generalised: **a writable descriptor
+* must name a route `CAP_COMMAND_ROUTES` can resolve, or ship read-only.**
+* The route table now covers every Tier A family, so the rows below are
+* writable wherever the capability declares a method that writes exactly
+* the value the entity carries.
+*
+* ── `writable` is about the CAPABILITY, not about the platform ───────────
+*
+* Six values are written by a real method and have no Home Assistant
+* control in the DEGRADED shape: `climate-control.fanMode`, `.preset`,
+* `fan-control.preset`, `water-heater.operationMode`, `humidifier.mode`,
+* `media-player.source` and `vacuum-control.fanSpeed` are free-form
+* strings whose accepted values are `available*` arrays on the DEVICE. A
+* static `select` cannot hold them — it would offer values the device
+* rejects while hiding the ones it takes — so their degraded platform is
+* a `sensor`.
+*
+* They are still marked `writable`, and that is the point: the flag means
+* "`CAP_COMMAND_ROUTES` writes exactly this value", which is what
+* `native-platforms.ts` asks before giving a native climate its fan-mode
+* control or a native vacuum its fan-speed control. `buildComponent`
+* announces a `command_topic` only on a platform that can carry one
+* (`COMMANDABLE_PLATFORMS`), so the degraded `sensor` stays a reading and
+* the native entity gains the control. They were read-only until
+* 2026-08-14 and the native controls silently did not appear, because the
+* one flag was answering two different questions.
+*
+* **`setTargetRange` is the one setter that needs two values at once**,
+* and it is routed by READING the other half first — see the note on
+* `target-high` below. Everything else in this table names one method
+* with one value.
+*
+* Only **a value that is not flat** still ships read-only. See below.
+*
+* ── Why a nested object is never a field ────────────────────────────────
+*
+* `renderCapValue` carries strings, numbers and booleans. `color.rgb`,
+* `vacuum-control.dustBin`, `event-emitter.lastEvent` and
+* `consumables.items` are objects and arrays: mapping one would publish
+* an entity that reports `unrenderable` on every single delivery. Where a
+* capability's headline value is only expressible as an object, the flat
+* neighbours are exported and the object is named in the doc comment
+* rather than mapped.
+*/
 var CAP_ENTITY_MAP = {
 	switch: {
 		platform: "switch",
 		field: "on",
 		writable: true
 	},
+	/**
+	* The lock is BOTH: a switch, because that is what an operator
+	* automates on and `lockControl.lock` / `.unlock` is a route that
+	* works — and a sensor, because `LockStateSchema` is
+	* `locked | unlocked | locking | unlocking | jammed` and a boolean
+	* silently reports a JAMMED door as unlocked. The boolean is derived
+	* from the same field, so the two can never disagree.
+	*/
 	"lock-control": {
 		platform: "switch",
-		field: "locked",
+		field: "state",
 		deviceClass: "lock",
-		writable: true
-	},
-	siren: {
-		platform: "switch",
-		field: "active",
-		writable: true
+		writable: true,
+		derive: {
+			kind: "equals",
+			value: "locked"
+		},
+		extras: { state: {
+			platform: "sensor",
+			field: "state",
+			label: "Lock state",
+			icon: "mdi:lock-question"
+		} },
+		/**
+		* `lockControl.open` — the LATCH, which is not `unlock`.
+		*
+		* Home Assistant spells it `LockEntityFeature.OPEN` and its native lock
+		* offers it as a third button; the cap has declared the method since it
+		* was written and nothing routed it, so `NATIVE_CAP_PLATFORMS`'
+		* `open` control resolved to no entity and was skipped every time.
+		* Registered and off in the degraded table for the same reason `stop`
+		* is: a lock without a latch answers the press with the provider's own
+		* refusal, and that is a button most operators never want to see.
+		*/
+		commands: { open: {
+			label: "Open latch",
+			icon: "mdi:door-open",
+			enabledByDefault: false
+		} }
 	},
 	button: {
 		platform: "button",
 		field: "pressed",
 		writable: true
 	},
+	/**
+	* The range is not decoration. `brightness.setBrightness` declares
+	* `0..100` and the entity carried no bounds, so Home Assistant applied its
+	* own default of min 1 — an operator could not send `0` and could not turn
+	* the light off from the number. It has been that way since the entity
+	* existed.
+	*/
 	brightness: {
 		platform: "number",
-		field: "brightness",
+		field: "percentage",
+		unit: "%",
+		writable: true,
+		range: PERCENT_RANGE
+	},
+	"alarm-panel": {
+		platform: "alarm_control_panel",
+		field: "state",
 		writable: true
 	},
 	binary: {
 		platform: "binary_sensor",
-		field: "state"
+		field: "on"
 	},
 	motion: {
 		platform: "binary_sensor",
@@ -583,22 +1651,39 @@ var CAP_ENTITY_MAP = {
 	},
 	contact: {
 		platform: "binary_sensor",
-		field: "open",
+		field: "entryOpen",
 		deviceClass: "door"
 	},
+	/**
+	* `state` is a STRING — `home`, `not_home`, or the name of any zone the
+	* operator defined. The binary answers "is anybody in", which is what
+	* an automation triggers on; the extra carries the zone NAME, which is
+	* the whole reason a presence device is not a contact sensor. A native
+	* `device_tracker` (which carries both at once) is Tier B.
+	*/
 	presence: {
 		platform: "binary_sensor",
-		field: "present",
-		deviceClass: "presence"
+		field: "state",
+		deviceClass: "presence",
+		derive: {
+			kind: "not-equals",
+			value: "not_home"
+		},
+		extras: { zone: {
+			platform: "sensor",
+			field: "state",
+			label: "Presence zone",
+			icon: "mdi:map-marker-account"
+		} }
 	},
 	connectivity: {
 		platform: "binary_sensor",
-		field: "online",
+		field: "connected",
 		deviceClass: "connectivity"
 	},
 	flood: {
 		platform: "binary_sensor",
-		field: "detected",
+		field: "flooded",
 		deviceClass: "moisture"
 	},
 	smoke: {
@@ -618,7 +1703,7 @@ var CAP_ENTITY_MAP = {
 	},
 	tamper: {
 		platform: "binary_sensor",
-		field: "detected",
+		field: "tampered",
 		deviceClass: "tamper"
 	},
 	vibration: {
@@ -633,25 +1718,25 @@ var CAP_ENTITY_MAP = {
 	},
 	"temperature-sensor": {
 		platform: "sensor",
-		field: "temperature",
+		field: "celsius",
 		deviceClass: "temperature",
 		unit: "°C"
 	},
 	"humidity-sensor": {
 		platform: "sensor",
-		field: "humidity",
+		field: "percent",
 		deviceClass: "humidity",
 		unit: "%"
 	},
 	"pressure-sensor": {
 		platform: "sensor",
-		field: "pressure",
+		field: "hpa",
 		deviceClass: "pressure",
 		unit: "hPa"
 	},
 	"ambient-light-sensor": {
 		platform: "sensor",
-		field: "illuminance",
+		field: "lux",
 		deviceClass: "illuminance",
 		unit: "lx"
 	},
@@ -680,12 +1765,926 @@ var CAP_ENTITY_MAP = {
 		field: "aqi",
 		deviceClass: "aqi"
 	},
-	"alarm-panel": {
-		platform: "alarm_control_panel",
+	/**
+	* A cover is its state, its two positions and its three verbs.
+	*
+	* `state` stays a `sensor`: `opening`/`closing` are transitions, not
+	* commands, and there is no cap method that writes the lifecycle directly.
+	* The positions are `number`s because `setPosition` / `setTiltPosition`
+	* write exactly them, and the verbs are buttons because `open`, `close` and
+	* `stop` take no value at all.
+	*/
+	cover: {
+		platform: "sensor",
 		field: "state",
-		writable: true
+		icon: "mdi:window-shutter",
+		extras: {
+			position: {
+				platform: "number",
+				field: "position",
+				label: "Position",
+				unit: "%",
+				icon: "mdi:arrow-up-down",
+				writable: true,
+				range: PERCENT_RANGE
+			},
+			tilt: {
+				platform: "number",
+				field: "tiltPosition",
+				label: "Tilt position",
+				unit: "%",
+				icon: "mdi:angle-acute",
+				writable: true,
+				range: PERCENT_RANGE,
+				enabledByDefault: false
+			}
+		},
+		commands: {
+			open: {
+				label: "Open",
+				icon: "mdi:arrow-up-box"
+			},
+			close: {
+				label: "Close",
+				icon: "mdi:arrow-down-box"
+			},
+			stop: {
+				label: "Stop",
+				icon: "mdi:stop",
+				enabledByDefault: false
+			}
+		}
+	},
+	/**
+	* Every temperature here is CELSIUS by the cap's own doc comment
+	* ("Single setpoint in Celsius", "Current measured temperature in
+	* Celsius"), so the unit is declared rather than guessed.
+	*/
+	"climate-control": {
+		platform: "select",
+		field: "mode",
+		icon: "mdi:thermostat",
+		writable: true,
+		/**
+		* The one closed list on this capability, and it is closed because
+		* `HvacModeSchema` is an enum. `availableModes` narrows it PER DEVICE and
+		* a static descriptor cannot read a slice, so an operator can select a
+		* mode their unit rejects — the provider refuses it and the refusal
+		* surfaces as a 422 with the device's own message, which is the honest
+		* failure. `fanMode` and `preset` get no such list at all: they are
+		* free-form strings, so they stay sensors.
+		*/
+		options: require_dist.HvacModeSchema.options,
+		extras: {
+			"current-temp": {
+				platform: "sensor",
+				field: "currentTemp",
+				label: "Current temperature",
+				deviceClass: "temperature",
+				unit: "°C"
+			},
+			target: {
+				platform: "number",
+				field: "target",
+				label: "Target temperature",
+				deviceClass: "temperature",
+				unit: "°C",
+				writable: true,
+				range: TEMPERATURE_RANGE
+			},
+			"current-humidity": {
+				platform: "sensor",
+				field: "currentHumidity",
+				label: "Current humidity",
+				deviceClass: "humidity",
+				unit: "%",
+				enabledByDefault: false
+			},
+			"target-humidity": {
+				platform: "number",
+				field: "targetHumidity",
+				label: "Target humidity",
+				deviceClass: "humidity",
+				unit: "%",
+				writable: true,
+				range: PERCENT_RANGE,
+				enabledByDefault: false
+			},
+			/**
+			* Free-form: the accepted values are `availableFanModes` on the slice,
+			* so the degraded platform is a `sensor` and only the native climate
+			* renders the control. `setFanMode` is the route.
+			*/
+			"fan-mode": {
+				platform: "sensor",
+				field: "fanMode",
+				label: "Fan mode",
+				icon: "mdi:fan",
+				writable: true,
+				enabledByDefault: false
+			},
+			/** Free-form: the accepted values are `availablePresets` on the slice. */
+			preset: {
+				platform: "sensor",
+				field: "preset",
+				label: "Preset",
+				writable: true,
+				enabledByDefault: false
+			},
+			/**
+			* The dual setpoint — and the one route in this export that READS
+			* before it writes.
+			*
+			* `setTargetRange` takes `targetLow` AND `targetHigh` together, while
+			* Home Assistant's climate sends the two halves on two topics, so a
+			* command carrying one of them has to learn the other before it can
+			* make the call. `applyCapCommand` therefore reads
+			* `climateControl.getStatus`, substitutes the half it was given, and
+			* calls once. A device reporting `null` for the other half is REFUSED
+			* rather than defaulted: inventing the missing bound is how a
+			* thermostat comes to be told to hold 20 °C to 20 °C.
+			*/
+			"target-high": {
+				platform: "sensor",
+				field: "targetHigh",
+				label: "Target high",
+				deviceClass: "temperature",
+				unit: "°C",
+				writable: true,
+				enabledByDefault: false
+			},
+			"target-low": {
+				platform: "sensor",
+				field: "targetLow",
+				label: "Target low",
+				deviceClass: "temperature",
+				unit: "°C",
+				writable: true,
+				enabledByDefault: false
+			},
+			/**
+			* Two INDEPENDENT axes, each with its own setter and its own
+			* `DeviceFeature`. A device with neither reports `null` on both, and a
+			* null renders as `unknown` rather than as a switch stuck off.
+			*/
+			"swing-vertical": {
+				platform: "switch",
+				field: "swingVertical",
+				label: "Vertical swing",
+				icon: "mdi:arrow-up-down",
+				writable: true,
+				enabledByDefault: false
+			},
+			"swing-horizontal": {
+				platform: "switch",
+				field: "swingHorizontal",
+				label: "Horizontal swing",
+				icon: "mdi:arrow-left-right",
+				writable: true,
+				enabledByDefault: false
+			}
+		}
+	},
+	/** A fan has no `on` field — `percentage` IS its state, and 0 is off. */
+	"fan-control": {
+		platform: "number",
+		field: "percentage",
+		unit: "%",
+		icon: "mdi:fan",
+		writable: true,
+		/**
+		* `percentageStep` on the slice is the device's own granularity (25 for a
+		* four-speed fan). A static step of 1 is the WIDER choice: a value the
+		* device rounds is recoverable, a step that hides three of its four speeds
+		* is not.
+		*/
+		range: PERCENT_RANGE,
+		extras: {
+			/**
+			* Free-form: the accepted values are `availablePresets` on the slice.
+			* `fanControl.setPreset` is the route; the native fan renders it.
+			*/
+			preset: {
+				platform: "sensor",
+				field: "preset",
+				label: "Preset",
+				writable: true,
+				enabledByDefault: false
+			},
+			oscillating: {
+				platform: "switch",
+				field: "oscillating",
+				label: "Oscillating",
+				icon: "mdi:arrow-oscillating",
+				writable: true,
+				enabledByDefault: false
+			},
+			direction: {
+				platform: "select",
+				field: "direction",
+				label: "Direction",
+				writable: true,
+				options: require_dist.FanDirectionSchema.options,
+				enabledByDefault: false
+			}
+		}
+	},
+	humidifier: {
+		platform: "switch",
+		field: "on",
+		icon: "mdi:air-humidifier",
+		writable: true,
+		extras: {
+			"current-humidity": {
+				platform: "sensor",
+				field: "currentHumidity",
+				label: "Current humidity",
+				deviceClass: "humidity",
+				unit: "%"
+			},
+			/**
+			* `minHumidity`/`maxHumidity` on the slice are the device's own bounds;
+			* the static range is the full percentage for the reason on
+			* {@link HaNumberRange}.
+			*/
+			"target-humidity": {
+				platform: "number",
+				field: "targetHumidity",
+				label: "Target humidity",
+				deviceClass: "humidity",
+				unit: "%",
+				writable: true,
+				range: PERCENT_RANGE
+			},
+			/**
+			* Free-form: the accepted values are `availableModes` on the slice.
+			* `humidifier.setMode` is the route; the native humidifier renders it.
+			*/
+			mode: {
+				platform: "sensor",
+				field: "mode",
+				label: "Mode",
+				writable: true,
+				enabledByDefault: false
+			},
+			action: {
+				platform: "sensor",
+				field: "action",
+				label: "Action",
+				enabledByDefault: false
+			}
+		}
+	},
+	"water-heater": {
+		platform: "sensor",
+		field: "currentTemp",
+		deviceClass: "temperature",
+		unit: "°C",
+		extras: {
+			target: {
+				platform: "number",
+				field: "targetTemp",
+				label: "Target temperature",
+				deviceClass: "temperature",
+				unit: "°C",
+				writable: true,
+				range: TEMPERATURE_RANGE
+			},
+			/**
+			* Free-form: the accepted values are `availableModes` on the slice, and
+			* this is the entity Home Assistant's water heater uses as its STATE —
+			* `setOperationMode` is what a native water_heater writes when the
+			* operator picks `eco`. Read-only here left that platform with no
+			* command at all.
+			*/
+			mode: {
+				platform: "sensor",
+				field: "operationMode",
+				label: "Operation mode",
+				writable: true,
+				enabledByDefault: false
+			},
+			away: {
+				platform: "switch",
+				field: "away",
+				label: "Away mode",
+				writable: true,
+				enabledByDefault: false
+			}
+		}
+	},
+	valve: {
+		platform: "sensor",
+		field: "state",
+		icon: "mdi:valve",
+		extras: { position: {
+			platform: "number",
+			field: "position",
+			label: "Position",
+			unit: "%",
+			icon: "mdi:arrow-up-down",
+			writable: true,
+			range: PERCENT_RANGE
+		} },
+		commands: {
+			open: {
+				label: "Open",
+				icon: "mdi:valve-open"
+			},
+			close: {
+				label: "Close",
+				icon: "mdi:valve-closed"
+			},
+			stop: {
+				label: "Stop",
+				icon: "mdi:stop",
+				enabledByDefault: false
+			}
+		}
+	},
+	"vacuum-control": {
+		platform: "sensor",
+		field: "state",
+		icon: "mdi:robot-vacuum",
+		extras: {
+			battery: {
+				platform: "sensor",
+				field: "batteryLevel",
+				label: "Battery",
+				deviceClass: "battery",
+				unit: "%"
+			},
+			/**
+			* Free-form: the accepted values are `availableFanSpeeds` on the slice.
+			* `vacuumControl.setFanSpeed` is the route; the native vacuum renders it.
+			*/
+			"fan-speed": {
+				platform: "sensor",
+				field: "fanSpeed",
+				label: "Fan speed",
+				writable: true,
+				enabledByDefault: false
+			},
+			progress: {
+				platform: "sensor",
+				field: "progressPercent",
+				label: "Progress",
+				unit: "%",
+				enabledByDefault: false
+			},
+			error: {
+				platform: "sensor",
+				field: "errorLabel",
+				label: "Error",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		},
+		commands: {
+			start: {
+				label: "Start",
+				icon: "mdi:play"
+			},
+			pause: {
+				label: "Pause",
+				icon: "mdi:pause"
+			},
+			stop: {
+				label: "Stop",
+				icon: "mdi:stop",
+				enabledByDefault: false
+			},
+			"return-to-base": {
+				label: "Return to base",
+				icon: "mdi:home-import-outline"
+			},
+			locate: {
+				label: "Locate",
+				icon: "mdi:map-marker-radius",
+				enabledByDefault: false
+			}
+		}
+	},
+	"lawn-mower-control": {
+		platform: "sensor",
+		field: "activity",
+		icon: "mdi:robot-mower",
+		extras: {
+			battery: {
+				platform: "sensor",
+				field: "batteryLevel",
+				label: "Battery",
+				deviceClass: "battery",
+				unit: "%"
+			},
+			progress: {
+				platform: "sensor",
+				field: "progressPercent",
+				label: "Progress",
+				unit: "%",
+				enabledByDefault: false
+			},
+			error: {
+				platform: "sensor",
+				field: "currentCodeLabel",
+				label: "Status code",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		},
+		commands: {
+			start: {
+				label: "Start mowing",
+				icon: "mdi:play"
+			},
+			pause: {
+				label: "Pause",
+				icon: "mdi:pause"
+			},
+			dock: {
+				label: "Dock",
+				icon: "mdi:home-import-outline"
+			}
+		}
+	},
+	/** `currentMedia` is an object; the flat fields around it are exported. */
+	"media-player": {
+		platform: "sensor",
+		field: "state",
+		icon: "mdi:play-circle",
+		extras: {
+			volume: {
+				platform: "number",
+				field: "volumeLevel",
+				label: "Volume",
+				icon: "mdi:volume-high",
+				writable: true,
+				range: PERCENT_RANGE
+			},
+			muted: {
+				platform: "switch",
+				field: "isMuted",
+				label: "Muted",
+				icon: "mdi:volume-off",
+				writable: true
+			},
+			/**
+			* Free-form: the accepted values are `availableSources` on the slice.
+			* `mediaPlayer.selectSource` is the route; the native media_player
+			* renders it as its source list.
+			*/
+			source: {
+				platform: "sensor",
+				field: "source",
+				label: "Source",
+				writable: true,
+				enabledByDefault: false
+			},
+			repeat: {
+				platform: "select",
+				field: "repeat",
+				label: "Repeat",
+				writable: true,
+				options: require_dist.MediaPlayerRepeatSchema.options,
+				enabledByDefault: false
+			},
+			shuffle: {
+				platform: "switch",
+				field: "shuffle",
+				label: "Shuffle",
+				writable: true,
+				enabledByDefault: false
+			}
+		},
+		commands: {
+			play: {
+				label: "Play",
+				icon: "mdi:play"
+			},
+			pause: {
+				label: "Pause",
+				icon: "mdi:pause"
+			},
+			stop: {
+				label: "Stop",
+				icon: "mdi:stop",
+				enabledByDefault: false
+			},
+			next: {
+				label: "Next",
+				icon: "mdi:skip-next"
+			},
+			previous: {
+				label: "Previous",
+				icon: "mdi:skip-previous"
+			}
+		}
+	},
+	/**
+	* `rgb` and `hsv` are nested objects, so hue and saturation cannot be
+	* two flat `number` entities without a projector that walks into a
+	* sub-object — and a `light` platform that carries the whole colour is
+	* Tier B. What IS flat is the colour MODE and the colour temperature,
+	* and both are automatable.
+	*/
+	color: {
+		platform: "sensor",
+		field: "mode",
+		icon: "mdi:palette",
+		extras: { 
+		/**
+		* The one writable surface `setColor` has that is a single number: its
+		* input is a discriminated union and `{ mode: 'mired', mireds }` is the
+		* only arm with exactly one scalar in it. `mode` itself stays read-only
+		* — writing it alone would be a call with no colour in it.
+		*/
+mireds: {
+			platform: "number",
+			field: "mireds",
+			label: "Colour temperature",
+			unit: "mired",
+			writable: true,
+			range: MIRED_RANGE,
+			enabledByDefault: false
+		} }
+	},
+	update: {
+		platform: "binary_sensor",
+		field: "updatable",
+		deviceClass: "update",
+		extras: {
+			available: {
+				platform: "sensor",
+				field: "availableVersion",
+				label: "Available version",
+				entityCategory: "diagnostic"
+			},
+			current: {
+				platform: "sensor",
+				field: "currentVersion",
+				label: "Installed version",
+				entityCategory: "diagnostic"
+			},
+			installing: {
+				platform: "binary_sensor",
+				field: "inProgress",
+				label: "Installing",
+				deviceClass: "running",
+				enabledByDefault: false
+			}
+		}
+	},
+	image: {
+		platform: "image",
+		field: "url",
+		extras: { updated: {
+			platform: "sensor",
+			field: "lastUpdated",
+			label: "Last updated",
+			deviceClass: "timestamp",
+			enabledByDefault: false
+		} }
+	},
+	"script-runner": {
+		platform: "binary_sensor",
+		field: "isRunning",
+		deviceClass: "running",
+		icon: "mdi:script-text-play",
+		extras: {
+			"last-run": {
+				platform: "sensor",
+				field: "lastRunAt",
+				label: "Last run",
+				deviceClass: "timestamp"
+			},
+			"last-error": {
+				platform: "sensor",
+				field: "lastError",
+				label: "Last error",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		},
+		commands: {
+			run: {
+				label: "Run",
+				icon: "mdi:play"
+			},
+			stop: {
+				label: "Stop",
+				icon: "mdi:stop"
+			}
+		}
+	},
+	/**
+	* `enabled` is a switch because `enable`/`disable` write exactly it;
+	* `trigger` is a button because firing the action block is a verb, and it
+	* works on a DISABLED automation — which is why it is not folded into the
+	* switch.
+	*/
+	"automation-control": {
+		platform: "switch",
+		field: "enabled",
+		icon: "mdi:robot",
+		writable: true,
+		commands: { trigger: {
+			label: "Trigger",
+			icon: "mdi:flash"
+		} },
+		extras: {
+			running: {
+				platform: "binary_sensor",
+				field: "isRunning",
+				label: "Running",
+				deviceClass: "running",
+				enabledByDefault: false
+			},
+			"last-triggered": {
+				platform: "sensor",
+				field: "lastTriggeredAt",
+				label: "Last triggered",
+				deviceClass: "timestamp"
+			},
+			"last-error": {
+				platform: "sensor",
+				field: "lastError",
+				label: "Last error",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		}
+	},
+	/**
+	* `lastEvent` is an object and `eventTypes` an array, so the plan's
+	* "last-event + last-event-at" pair has nothing flat to read. The COUNT
+	* is flat, monotonic and the thing an automation can trigger on ("it
+	* went up") — a native `event` platform, which carries the payload, is
+	* Tier B.
+	*/
+	"event-emitter": {
+		platform: "sensor",
+		field: "eventCountSinceStart",
+		icon: "mdi:counter"
+	},
+	"pet-feeder": {
+		platform: "sensor",
+		field: "foodLevel",
+		unit: "%",
+		icon: "mdi:food-drumstick",
+		extras: {
+			"low-food": {
+				platform: "binary_sensor",
+				field: "lowFood",
+				label: "Low food",
+				deviceClass: "problem"
+			},
+			feeding: {
+				platform: "binary_sensor",
+				field: "feeding",
+				label: "Feeding",
+				deviceClass: "running",
+				enabledByDefault: false
+			},
+			desiccant: {
+				platform: "sensor",
+				field: "desiccantLeftDays",
+				label: "Desiccant remaining",
+				unit: "d",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			},
+			status: {
+				platform: "sensor",
+				field: "status",
+				label: "Status",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		}
+	},
+	/**
+	* The cap carries its OWN unit next to each measurement
+	* (`temperatureUnit`, `pressureUnit`, `windSpeedUnit`), so no static
+	* `unit_of_measurement` can be honest for a provider reporting °F.
+	* Declaring one anyway is how a dashboard comes to say 71 °C. Humidity
+	* is the exception: a percentage is a percentage.
+	*/
+	weather: {
+		platform: "sensor",
+		field: "condition",
+		icon: "mdi:weather-partly-cloudy",
+		extras: {
+			temperature: {
+				platform: "sensor",
+				field: "temperature",
+				label: "Temperature",
+				icon: "mdi:thermometer"
+			},
+			humidity: {
+				platform: "sensor",
+				field: "humidity",
+				label: "Humidity",
+				deviceClass: "humidity",
+				unit: "%"
+			},
+			pressure: {
+				platform: "sensor",
+				field: "pressure",
+				label: "Pressure",
+				icon: "mdi:gauge",
+				enabledByDefault: false
+			},
+			wind: {
+				platform: "sensor",
+				field: "windSpeed",
+				label: "Wind speed",
+				icon: "mdi:weather-windy",
+				enabledByDefault: false
+			},
+			bearing: {
+				platform: "sensor",
+				field: "windBearing",
+				label: "Wind bearing",
+				unit: "°",
+				enabledByDefault: false
+			}
+		}
+	},
+	/**
+	* The generic user-settable input. `value` is `number | string` and
+	* `kind` says which of the four shapes it is — a `number`, a `select`
+	* or a text box, all three of which would need `control.setValue` in
+	* the route table before they could be anything but a reading.
+	*/
+	control: {
+		platform: "sensor",
+		field: "value",
+		extras: { kind: {
+			platform: "sensor",
+			field: "kind",
+			label: "Input kind",
+			entityCategory: "diagnostic",
+			enabledByDefault: false
+		} }
+	},
+	"motion-trigger": {
+		platform: "binary_sensor",
+		field: "enabled",
+		icon: "mdi:motion-sensor"
+	},
+	/**
+	* Three capabilities a camera carries that an operator automates on. They
+	* are in this table because the descriptor and the push path are the
+	* derived half's; they reach a camera through {@link CAMERA_DERIVED_CAPS}
+	* because `buildDerivedPlan` never runs for one.
+	*/
+	/**
+	* Talk-back, exported on the operator's decision and READ-ONLY.
+	*
+	* It was excluded until 2026-08-14 for a measured reason: the cap declared
+	* `status` and no `runtimeState`, and the export's only two sources of a
+	* value — the `device.state-changed` slice and the
+	* `deviceState.getAllSnapshots` snapshot — are both built from runtime
+	* state. The entity would have been published and never received a value.
+	* `intercom.cap.ts` now declares the slice and the Reolink and Hikvision
+	* providers write it at the four points that open and close a session, so
+	* the entity has a feed before it has a row here.
+	*
+	* Read-only, and that is not a missing route: talk-back is an AUDIO
+	* STREAM. `startTalkSession` opens a channel that `pushTalkAudio` feeds
+	* frame by frame, and Home Assistant's switch carries `true`. A switch
+	* that opened a session nobody could speak into is the control that lies.
+	*/
+	intercom: {
+		platform: "binary_sensor",
+		field: "talking",
+		icon: "mdi:account-voice",
+		extras: { "last-session": {
+			platform: "sensor",
+			field: "lastSessionAt",
+			label: "Last talk session",
+			deviceClass: "timestamp",
+			enabledByDefault: false
+		} }
+	},
+	"day-night": {
+		platform: "sensor",
+		field: "mode",
+		icon: "mdi:theme-light-dark",
+		extras: {
+			sensitivity: {
+				platform: "sensor",
+				field: "sensitivity",
+				label: "IR-cut sensitivity",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			},
+			"switch-delay": {
+				platform: "sensor",
+				field: "switchDelaySec",
+				label: "IR-cut switch delay",
+				unit: "s",
+				entityCategory: "diagnostic",
+				enabledByDefault: false
+			}
+		}
+	},
+	"ptz-autotrack": {
+		platform: "binary_sensor",
+		field: "enabled",
+		icon: "mdi:crosshairs-gps"
 	}
 };
+/**
+* Capabilities exported on a CAMERA rather than through
+* `buildDerivedPlan`, which only ever runs for a non-camera device.
+*/
+var CAMERA_DERIVED_CAPS = [
+	"day-night",
+	"ptz-autotrack",
+	"intercom"
+];
+/**
+* The command buttons a capability produces.
+*
+* Separate from {@link capEntities} on purpose: that list is what the
+* PROJECTOR walks, and a button has nothing to project. Keeping them in one
+* list would put an entity with no `field` in front of code whose whole job is
+* to read one.
+*/
+function capCommandEntities(capName) {
+	const mapping = CAP_ENTITY_MAP[capName];
+	if (mapping === void 0) return [];
+	return Object.entries(mapping.commands ?? {}).map(([suffix, command]) => ({
+		entity: derivedExtraEntityId(capName, suffix),
+		suffix,
+		label: command.label,
+		command
+	}));
+}
+/**
+* The one expression that turns a descriptor into entities.
+*
+* Both halves of the catalog and the projector call it, so a capability
+* cannot build a component under one id and publish under another — the
+* failure `derivedEntityId` was extracted to end, now that a capability
+* can produce more than one entity.
+*/
+function capEntities(capName) {
+	const mapping = CAP_ENTITY_MAP[capName];
+	if (mapping === void 0) return [];
+	const refs = [{
+		entity: derivedEntityId(capName),
+		label: humanise(capName),
+		descriptor: mapping
+	}];
+	for (const [suffix, extra] of Object.entries(mapping.extras ?? {})) refs.push({
+		entity: derivedExtraEntityId(capName, suffix),
+		label: extra.label,
+		descriptor: extra
+	});
+	return refs;
+}
+/**
+* Apply a descriptor's derivation.
+*
+* Returns `null` — which renders as `unrenderable` and is LOGGED — when
+* the slice carried something a comparison cannot be made against. A
+* derivation that quietly answered `false` for a non-string would report
+* a jammed lock as unlocked, which is the failure the derivation exists
+* to avoid.
+*/
+function deriveCapValue(derivation, raw) {
+	if (derivation === void 0) return raw;
+	if (typeof raw !== "string") return null;
+	return derivation.kind === "equals" ? raw === derivation.value : raw !== derivation.value;
+}
+/** A capability's entities as the catalog builders consume them. */
+function capEntitySpecs(capName) {
+	const specs = capEntities(capName).map((ref) => ({
+		entity: ref.entity,
+		platform: ref.descriptor.platform,
+		label: ref.label,
+		enabledByDefault: ref.descriptor.enabledByDefault ?? true,
+		...ref.descriptor.deviceClass !== void 0 ? { deviceClass: ref.descriptor.deviceClass } : {},
+		...ref.descriptor.unit !== void 0 ? { unit: ref.descriptor.unit } : {},
+		...ref.descriptor.icon !== void 0 ? { icon: ref.descriptor.icon } : {},
+		...ref.descriptor.options !== void 0 ? { options: ref.descriptor.options } : {},
+		...ref.descriptor.range !== void 0 ? { range: ref.descriptor.range } : {},
+		...ref.descriptor.entityCategory !== void 0 ? { entityCategory: ref.descriptor.entityCategory } : {},
+		...ref.descriptor.writable === true ? { writable: true } : {}
+	}));
+	for (const ref of capCommandEntities(capName)) specs.push({
+		entity: ref.entity,
+		platform: "button",
+		label: ref.label,
+		enabledByDefault: ref.command.enabledByDefault ?? true,
+		writable: true,
+		...ref.command.icon !== void 0 ? { icon: ref.command.icon } : {},
+		...ref.command.entityCategory !== void 0 ? { entityCategory: ref.command.entityCategory } : {}
+	});
+	return specs;
+}
 var CAPS_NOT_EXPORTED = [
 	{
 		cap: "snapshot",
@@ -726,8 +2725,116 @@ var CAPS_NOT_EXPORTED = [
 	{
 		cap: "device-discovery",
 		reason: "Adoption-time only — it describes candidates, never the state of an adopted device."
+	},
+	{
+		cap: "camera-credentials",
+		reason: "It carries the camera's host, port and password. An entity would write that password into Home Assistant's registry and into every debug log it keeps, on a host camstack does not own. Never an entity, at any tier."
+	},
+	{
+		cap: "stream-catalog",
+		reason: "Transport — and it returns the camera's native URL with the password inline, so exporting it leaks the credential exactly as camera-credentials would. The streams reach HA as `camera` entities built from the broker restream instead (camera-entities.ts)."
+	},
+	{
+		cap: "audio-analysis",
+		reason: "Pipeline configuration. The audio DETECTIONS it drives already reach HA as the camera catalog's `audio_last_sound` / `audio_volume` entities, from the analyzer's own event."
+	},
+	{
+		cap: "camera-pipeline-config",
+		reason: "Transport/pipeline configuration — it selects the road, it is not a state."
+	},
+	{
+		cap: "camera-streams",
+		reason: "Transport. Its profile slots become the live `camera` entities (T4), which is the exported form; the slot configuration itself is not something an automation reads."
+	},
+	{
+		cap: "detection-pipeline",
+		reason: "Pipeline configuration. Its output is the per-macro camera entities, which are exported and which would disagree with a second set derived from the config."
+	},
+	{
+		cap: "image-settings",
+		reason: "Firmware image tuning — encoder brightness/contrast/saturation. A rendering setting with no state an automation reads."
+	},
+	{
+		cap: "motion-detection",
+		reason: "The LOCAL ML motion pipeline's configuration. Motion STATE is the `motion` capability, which is mapped; two sources on one question is the failure D62 records."
+	},
+	{
+		cap: "motion-zones",
+		reason: "Zone geometry, not state. Per-zone counts already reach HA through the camera catalog's zone fan-out."
+	},
+	{
+		cap: "osd",
+		reason: "On-screen-display text overlay — a rendering setting with no automatable state."
+	},
+	{
+		cap: "pipeline-analytics",
+		reason: "Pipeline telemetry. Cluster health is already the CamStack Server synthetic device; per-camera pipeline counters would fan out across the fleet with nothing consuming them."
+	},
+	{
+		cap: "stream-params",
+		reason: "Encoder parameters (bitrate/resolution/fps) — transport rather than state."
+	},
+	{
+		cap: "videoclips",
+		reason: "Media retrieval by handle, not a state. Clips reach the operator through notifications and the viewer."
+	},
+	{
+		cap: "webrtc-session",
+		reason: "A session opener — the definition of transport."
+	},
+	{
+		cap: "events",
+		reason: "A paginated event LOG, not a state. Its natural target is HA's `event` platform, which the component does not build (Tier B)."
+	},
+	{
+		cap: "consumables",
+		reason: "The value is `items`, an ARRAY of per-device consumables named by the provider (a filter, a brush, a cartridge). This table is static per capability, so it cannot mint one sensor per item; doing it needs a reconcile-time entity mint keyed on the device, which is a design, not a row."
+	},
+	{
+		cap: "scene-monitor",
+		reason: "Per-ROI reference-region state, `monitors` being an array of operator-named regions. Same shape as consumables: the entity set is per device and changes when the operator adds a region, which a static descriptor cannot express."
+	},
+	{
+		cap: "audio-metrics",
+		reason: "A real measurement, and already exported from its authority: the camera catalog projects `audio_volume` and `audio_level_rms` from the analyzer's own `pipeline.audio-inference-result`. A second source on the same question is the two-knobs failure D62 records."
+	},
+	{
+		cap: "notifier",
+		reason: "A delivery service, not an entity — HA models these as `notify.<service>`, which is not one of the nine platforms the component builds."
+	},
+	{
+		cap: "accessories",
+		reason: "Grouping metadata. Every listed child is a device in its own right and is exported as one; a second entity would restate the link and disagree with it the moment a child moves."
+	},
+	{
+		cap: "zones",
+		reason: "Zone geometry — configuration, not state. Same reason as `zone-analytics`, whose per-zone counts are what actually reaches HA."
+	},
+	{
+		cap: "zone-rules",
+		reason: "Per-stage zone rules — configuration the pipeline consumes, with no value an automation reads."
 	}
 ];
+var UNNEGOTIATED_PLAN_OPTIONS = { platforms: UNNEGOTIATED_SUPPORT };
+/**
+* An entity whose platform the component cannot build, degraded to one it
+* can.
+*
+* The command topic goes with the platform: the degraded form is a
+* READING, and announcing a command topic on it would leave a route open
+* that nothing can reach. See `DEGRADED_PLATFORM` for the one entry this
+* exists for.
+*/
+function degradeUnsupported(spec, options) {
+	if (options.platforms.has(spec.platform)) return spec;
+	const fallback = DEGRADED_PLATFORM[spec.platform];
+	if (fallback === void 0) return spec;
+	const { writable: _writable, ...rest } = spec;
+	return {
+		...rest,
+		platform: fallback
+	};
+}
 /** 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)]);
@@ -746,8 +2853,19 @@ function unclassifiedCaps(caps) {
 * (`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.
+*
+* **The Tier A widening qualifies that, per ENTITY rather than per
+* device.** A cover, a thermostat or a media player is not one value; it
+* is a state plus the numbers around it, and the numbers are the reason
+* to own the device. So the PRIMARY entity of every capability still
+* arrives enabled — it is what the device is — and a secondary one
+* arrives enabled only when an operator automates on it. A thermostat's
+* measured temperature: yes. Its swing preset and its dual-setpoint
+* bounds: registered and off. That keeps a widened `climate-control`
+* device at three enabled entities rather than eight, without hiding the
+* data from anyone who wants it.
 */
-function buildDerivedPlan(device) {
+function buildDerivedPlan(device, options = UNNEGOTIATED_PLAN_OPTIONS) {
 	const specs = [{
 		entity: "online",
 		platform: "binary_sensor",
@@ -756,24 +2874,50 @@ function buildDerivedPlan(device) {
 		entityCategory: "diagnostic",
 		enabledByDefault: true
 	}];
+	const native = {};
 	for (const cap of device.boundCaps) {
+		/**
+		* A camera-scoped capability is built by the CAMERA half. Nothing
+		* binds `day-night` to a base device today, and if something did,
+		* two halves of this file would build the same entity id twice.
+		*/
+		if (CAMERA_DERIVED_CAPS.includes(cap)) continue;
 		const mapping = CAP_ENTITY_MAP[cap];
-		if (mapping === void 0) continue;
-		specs.push({
-			entity: toSlug(cap),
-			platform: mapping.platform,
+		const platform = nativePlatformFor(cap);
+		const plan = mapping === void 0 || platform === null || !options.platforms.has(platform) ? null : buildNativeComponent({
+			deviceKey: deviceKeyFor(device.stableId),
+			stableId: device.stableId,
+			capName: cap,
 			label: humanise(cap),
-			enabledByDefault: true,
-			...mapping.deviceClass !== void 0 ? { deviceClass: mapping.deviceClass } : {},
-			...mapping.unit !== void 0 ? { unit: mapping.unit } : {},
-			...mapping.writable === true ? { writable: true } : {}
+			slice: device.capSlices?.[cap],
+			mapping
 		});
+		if (plan === null) {
+			specs.push(...capEntitySpecs(cap).map((spec) => degradeUnsupported(spec, options)));
+			continue;
+		}
+		native[toComponentKey(plan.component.platform, derivedEntityId(cap))] = plan.component;
+		/**
+		* Rule 3 of `native-platforms.ts`: what the native entity reads, it
+		* owns. What it does NOT read is still announced — a vacuum's error
+		* label has nowhere to go on Home Assistant's vacuum, and dropping it
+		* to make the device look tidy would be a silent loss of a value an
+		* operator already automates on.
+		*/
+		specs.push(...capEntitySpecs(cap).filter((spec) => !plan.absorbed.has(spec.entity)));
 	}
-	return assemble(device, specs);
+	const assembled = assemble(device, specs);
+	return {
+		...assembled,
+		cmps: {
+			...assembled.cmps,
+			...native
+		}
+	};
 }
 /** Camera or base kind — the only place that decision is made. */
-function buildDevicePlan(device) {
-	return device.type === "camera" ? buildCameraPlan(device) : buildDerivedPlan(device);
+function buildDevicePlan(device, options = UNNEGOTIATED_PLAN_OPTIONS) {
+	return device.type === "camera" ? buildCameraPlan(device) : buildDerivedPlan(device, options);
 }
 //#endregion
 //#region src/ha-export/command-routes.ts
@@ -781,15 +2925,28 @@ function buildDevicePlan(device) {
 * 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.
+* surface; this module turns that pair into a typed command AND owns the
+* call each capability command makes. Resolution is pure; the dispatch
+* takes an injected `DeviceProxy` slice, so both halves are testable
+* without a hub.
+*
+* **The route and the call live together on purpose.** They used not to:
+* `resolveCommand` collapsed every non-button writable cap into
+* `kind: 'cap-switch'` and the addon called `device.switch.setState`
+* unconditionally, so `lock-control`, `siren`, `alarm-panel` and
+* `brightness` all advertised a control in Home Assistant that could not
+* work — a lock got `noProvider` and a 422, and `brightness` is a number
+* that never parsed as a boolean and never routed at all. A table that
+* names a method in one file and a switch that calls it in another is
+* exactly the drift that produced four lying controls.
 *
 * 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.
+* declares no `ptz` cap is not a no-op worth pretending succeeded; a cap
+* with no route does NOT fall through to `switch.setState`. Every
+* refusal carries a named reason so the log line says which of those it
+* was.
 */
 /** The camera switch ids, keyed by the entity slug the catalog emits. */
 var CAMERA_SWITCH_BY_SLUG = Object.fromEntries([
@@ -809,76 +2966,981 @@ function parseBool(value) {
 	if (lower === "false" || lower === "off" || lower === "0") return false;
 	return null;
 }
+/**
+* A lock's payload.
+*
+* The catalog renders `lock-control` as a `switch`, so Home Assistant
+* sends `true`/`false` — but the component is not the only caller and a
+* lock's own vocabulary is `lock`/`unlock`. Both are accepted because
+* both are unambiguous; anything else is refused rather than read as
+* "unlock", which is the wrong way to be wrong about a door.
+*/
+function parseLocked(value) {
+	const asBool = parseBool(value);
+	if (asBool !== null) return asBool;
+	const lower = value.trim().toLowerCase();
+	if (lower === "lock" || lower === "locked") return true;
+	if (lower === "unlock" || lower === "unlocked") return false;
+	return null;
+}
+/**
+* A free-form vocabulary value, as the DEVICE spells it.
+*
+* `fanMode`, `preset`, `operationMode`, `mode`, `fanSpeed` and `source` are
+* `z.string().min(1)` in their caps and their accepted values live in an
+* `available*` array on the slice. Nothing here validates against that list:
+* a pure resolution has no slice, and a second copy of the vocabulary would
+* be one firmware away from refusing a mode the device accepts. The device
+* is the authority on its own vocabulary, and its refusal surfaces with its
+* own words. Only EMPTY is refused here, because a blank is never a mode.
+*/
+function parseVocabulary(value) {
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? null : trimmed;
+}
+/** 0..100 inclusive, as `brightness.setBrightness` declares it. */
+function parsePercentage(value) {
+	const parsed = Number(value.trim());
+	if (!Number.isFinite(parsed)) return null;
+	if (parsed < 0 || parsed > 100) return null;
+	return parsed;
+}
+/**
+* An alarm panel's payload.
+*
+* Home Assistant's alarm-panel command vocabulary is `ARM_HOME`,
+* `ARM_AWAY`, `ARM_NIGHT`, `ARM_VACATION`, `ARM_CUSTOM_BYPASS`, `DISARM`
+* and `TRIGGER`; the cap's own vocabulary is the arm MODE (`home`,
+* `away`, …) and its state vocabulary is `armed_home`. All three are
+* accepted — they are the same instruction spelled by three layers of the
+* same stack — and the mode itself is validated by `AlarmArmModeSchema`
+* rather than by a second list here that could drift from the cap.
+*/
+function parseAlarmAction(value) {
+	const lower = value.trim().toLowerCase();
+	if (lower === "disarm" || lower === "disarmed") return { kind: "disarm" };
+	if (lower === "trigger" || lower === "triggered") return { kind: "trigger" };
+	const withoutPrefix = lower.startsWith("armed_") ? lower.slice(6) : lower.startsWith("arm_") ? lower.slice(4) : lower;
+	const mode = require_dist.AlarmArmModeSchema.safeParse(withoutPrefix);
+	return mode.success ? {
+		kind: "arm",
+		mode: mode.data
+	} : null;
+}
+/** A finite number in `[min, max]`, or `null` when the payload is neither. */
+function parseBounded(value, min, max) {
+	const parsed = Number(value.trim());
+	if (!Number.isFinite(parsed)) return null;
+	if (parsed < min || parsed > max) return null;
+	return parsed;
+}
+/**
+* A payload against an enum the CAP declares.
+*
+* Never against a second list here. `HvacModeSchema`, `FanDirectionSchema`
+* and `MediaPlayerRepeatSchema` are the same objects the catalog offers as
+* the `select`'s options, so the values HA can send and the values this
+* accepts cannot drift apart.
+*/
+function parseEnum(schema, value) {
+	const parsed = schema.safeParse(value.trim().toLowerCase());
+	return parsed.success ? parsed.data : null;
+}
+/**
+* capability → the commands that WRITE it.
+*
+* The entity catalog decides WHICH entities are writable; this decides what
+* writing each one does. An entity declared `writable` with no entry here is
+* refused with `no-route` and the drop is logged — it must never fall through
+* to another cap's method, which is how four controls came to advertise a
+* function they could not perform.
+*
+* Both directions are asserted by the specs: a writable descriptor with no
+* route fails, and a route with no descriptor fails too. An unreachable route
+* is the same defect read backwards — it describes a control the catalog
+* never built, and a leftover that describes the right design reads as
+* verification.
+*
+* **Every builder names ONE method with ONE value, and none of them reads
+* the device.** Resolution is pure and has no slice, which is why
+* `climate-control.setTargetRange` — the only cap method that takes two
+* values at once — resolves to a `climate-target-edge` carrying the half it
+* was given. The read of the other half belongs to {@link applyCapCommand},
+* which has the device; composing it here would have needed a slice this
+* function must not have.
+*/
+var CAP_COMMAND_ROUTES = {
+	switch: { primary: (deviceId, value) => {
+		const on = parseBool(value);
+		return on === null ? null : {
+			kind: "cap-switch",
+			deviceId,
+			capName: "switch",
+			on
+		};
+	} },
+	"lock-control": {
+		primary: (deviceId, value) => {
+			const locked = parseLocked(value);
+			return locked === null ? null : {
+				kind: "cap-lock",
+				deviceId,
+				locked
+			};
+		},
+		commands: { open: (deviceId) => ({
+			kind: "cap-lock-open",
+			deviceId
+		}) }
+	},
+	brightness: { primary: (deviceId, value) => {
+		const percentage = parsePercentage(value);
+		return percentage === null ? null : {
+			kind: "cap-brightness",
+			deviceId,
+			percentage
+		};
+	} },
+	"alarm-panel": { primary: (deviceId, value) => {
+		const action = parseAlarmAction(value);
+		return action === null ? null : {
+			kind: "cap-alarm",
+			deviceId,
+			action
+		};
+	} },
+	button: { primary: (deviceId) => ({
+		kind: "cap-button",
+		deviceId,
+		capName: "button"
+	}) },
+	cover: {
+		extras: {
+			position: (deviceId, value) => {
+				const position = parsePercentage(value);
+				return position === null ? null : {
+					kind: "cover-position",
+					deviceId,
+					position
+				};
+			},
+			tilt: (deviceId, value) => {
+				const tiltPosition = parsePercentage(value);
+				return tiltPosition === null ? null : {
+					kind: "cover-tilt",
+					deviceId,
+					tiltPosition
+				};
+			}
+		},
+		commands: {
+			open: (deviceId) => ({
+				kind: "cover-verb",
+				deviceId,
+				verb: "open"
+			}),
+			close: (deviceId) => ({
+				kind: "cover-verb",
+				deviceId,
+				verb: "close"
+			}),
+			stop: (deviceId) => ({
+				kind: "cover-verb",
+				deviceId,
+				verb: "stop"
+			})
+		}
+	},
+	"climate-control": {
+		primary: (deviceId, value) => {
+			const mode = parseEnum(require_dist.HvacModeSchema, value);
+			return mode === null ? null : {
+				kind: "climate-mode",
+				deviceId,
+				mode
+			};
+		},
+		extras: {
+			/**
+			* Bounded by the entity's declared range and nothing narrower: the
+			* per-device limits are the provider's (`getOptions`), and refusing
+			* here on a guess would reject a setpoint the device accepts.
+			*/
+			target: (deviceId, value) => {
+				const target = parseBounded(value, TEMPERATURE_MIN, TEMPERATURE_MAX);
+				return target === null ? null : {
+					kind: "climate-target",
+					deviceId,
+					target
+				};
+			},
+			"target-humidity": (deviceId, value) => {
+				const targetHumidity = parsePercentage(value);
+				return targetHumidity === null ? null : {
+					kind: "climate-target-humidity",
+					deviceId,
+					targetHumidity
+				};
+			},
+			"fan-mode": (deviceId, value) => {
+				const fanMode = parseVocabulary(value);
+				return fanMode === null ? null : {
+					kind: "climate-fan-mode",
+					deviceId,
+					fanMode
+				};
+			},
+			preset: (deviceId, value) => {
+				const preset = parseVocabulary(value);
+				return preset === null ? null : {
+					kind: "climate-preset",
+					deviceId,
+					preset
+				};
+			},
+			/**
+			* The two halves of `setTargetRange`, each bounded by the same range
+			* `target` is. They resolve to an EDGE rather than to a call: the other
+			* half is a fact about the device, and resolution is pure.
+			*/
+			"target-low": (deviceId, value) => {
+				const low = parseBounded(value, TEMPERATURE_MIN, TEMPERATURE_MAX);
+				return low === null ? null : {
+					kind: "climate-target-edge",
+					deviceId,
+					edge: "low",
+					value: low
+				};
+			},
+			"target-high": (deviceId, value) => {
+				const high = parseBounded(value, TEMPERATURE_MIN, TEMPERATURE_MAX);
+				return high === null ? null : {
+					kind: "climate-target-edge",
+					deviceId,
+					edge: "high",
+					value: high
+				};
+			},
+			"swing-vertical": (deviceId, value) => {
+				const on = parseBool(value);
+				return on === null ? null : {
+					kind: "climate-swing",
+					deviceId,
+					axis: "vertical",
+					on
+				};
+			},
+			"swing-horizontal": (deviceId, value) => {
+				const on = parseBool(value);
+				return on === null ? null : {
+					kind: "climate-swing",
+					deviceId,
+					axis: "horizontal",
+					on
+				};
+			}
+		}
+	},
+	"fan-control": {
+		primary: (deviceId, value) => {
+			const percentage = parsePercentage(value);
+			return percentage === null ? null : {
+				kind: "fan-percentage",
+				deviceId,
+				percentage
+			};
+		},
+		extras: {
+			preset: (deviceId, value) => {
+				const preset = parseVocabulary(value);
+				return preset === null ? null : {
+					kind: "fan-preset",
+					deviceId,
+					preset
+				};
+			},
+			oscillating: (deviceId, value) => {
+				const oscillating = parseBool(value);
+				return oscillating === null ? null : {
+					kind: "fan-oscillating",
+					deviceId,
+					oscillating
+				};
+			},
+			direction: (deviceId, value) => {
+				const direction = parseEnum(require_dist.FanDirectionSchema, value);
+				return direction === null ? null : {
+					kind: "fan-direction",
+					deviceId,
+					direction
+				};
+			}
+		}
+	},
+	humidifier: {
+		primary: (deviceId, value) => {
+			const on = parseBool(value);
+			return on === null ? null : {
+				kind: "humidifier-on",
+				deviceId,
+				on
+			};
+		},
+		extras: {
+			"target-humidity": (deviceId, value) => {
+				const humidity = parsePercentage(value);
+				return humidity === null ? null : {
+					kind: "humidifier-humidity",
+					deviceId,
+					humidity
+				};
+			},
+			mode: (deviceId, value) => {
+				const mode = parseVocabulary(value);
+				return mode === null ? null : {
+					kind: "humidifier-mode",
+					deviceId,
+					mode
+				};
+			}
+		}
+	},
+	"water-heater": { extras: {
+		target: (deviceId, value) => {
+			const temp = parseBounded(value, TEMPERATURE_MIN, TEMPERATURE_MAX);
+			return temp === null ? null : {
+				kind: "water-heater-temp",
+				deviceId,
+				temp
+			};
+		},
+		away: (deviceId, value) => {
+			const on = parseBool(value);
+			return on === null ? null : {
+				kind: "water-heater-away",
+				deviceId,
+				on
+			};
+		},
+		mode: (deviceId, value) => {
+			const mode = parseVocabulary(value);
+			return mode === null ? null : {
+				kind: "water-heater-mode",
+				deviceId,
+				mode
+			};
+		}
+	} },
+	valve: {
+		extras: { position: (deviceId, value) => {
+			const position = parsePercentage(value);
+			return position === null ? null : {
+				kind: "valve-position",
+				deviceId,
+				position
+			};
+		} },
+		commands: {
+			open: (deviceId) => ({
+				kind: "valve-verb",
+				deviceId,
+				verb: "open"
+			}),
+			close: (deviceId) => ({
+				kind: "valve-verb",
+				deviceId,
+				verb: "close"
+			}),
+			stop: (deviceId) => ({
+				kind: "valve-verb",
+				deviceId,
+				verb: "stop"
+			})
+		}
+	},
+	"vacuum-control": {
+		extras: { "fan-speed": (deviceId, value) => {
+			const speed = parseVocabulary(value);
+			return speed === null ? null : {
+				kind: "vacuum-fan-speed",
+				deviceId,
+				speed
+			};
+		} },
+		commands: {
+			start: (deviceId) => ({
+				kind: "vacuum-verb",
+				deviceId,
+				verb: "start"
+			}),
+			pause: (deviceId) => ({
+				kind: "vacuum-verb",
+				deviceId,
+				verb: "pause"
+			}),
+			stop: (deviceId) => ({
+				kind: "vacuum-verb",
+				deviceId,
+				verb: "stop"
+			}),
+			"return-to-base": (deviceId) => ({
+				kind: "vacuum-verb",
+				deviceId,
+				verb: "return-to-base"
+			}),
+			locate: (deviceId) => ({
+				kind: "vacuum-verb",
+				deviceId,
+				verb: "locate"
+			})
+		}
+	},
+	"lawn-mower-control": { commands: {
+		start: (deviceId) => ({
+			kind: "mower-verb",
+			deviceId,
+			verb: "start"
+		}),
+		pause: (deviceId) => ({
+			kind: "mower-verb",
+			deviceId,
+			verb: "pause"
+		}),
+		dock: (deviceId) => ({
+			kind: "mower-verb",
+			deviceId,
+			verb: "dock"
+		})
+	} },
+	"media-player": {
+		extras: {
+			volume: (deviceId, value) => {
+				const volumeLevel = parsePercentage(value);
+				return volumeLevel === null ? null : {
+					kind: "media-volume",
+					deviceId,
+					volumeLevel
+				};
+			},
+			muted: (deviceId, value) => {
+				const muted = parseBool(value);
+				return muted === null ? null : {
+					kind: "media-mute",
+					deviceId,
+					muted
+				};
+			},
+			shuffle: (deviceId, value) => {
+				const shuffle = parseBool(value);
+				return shuffle === null ? null : {
+					kind: "media-shuffle",
+					deviceId,
+					shuffle
+				};
+			},
+			repeat: (deviceId, value) => {
+				const repeat = parseEnum(require_dist.MediaPlayerRepeatSchema, value);
+				return repeat === null ? null : {
+					kind: "media-repeat",
+					deviceId,
+					repeat
+				};
+			},
+			source: (deviceId, value) => {
+				const source = parseVocabulary(value);
+				return source === null ? null : {
+					kind: "media-source",
+					deviceId,
+					source
+				};
+			}
+		},
+		commands: {
+			play: (deviceId) => ({
+				kind: "media-verb",
+				deviceId,
+				verb: "play"
+			}),
+			pause: (deviceId) => ({
+				kind: "media-verb",
+				deviceId,
+				verb: "pause"
+			}),
+			stop: (deviceId) => ({
+				kind: "media-verb",
+				deviceId,
+				verb: "stop"
+			}),
+			next: (deviceId) => ({
+				kind: "media-verb",
+				deviceId,
+				verb: "next"
+			}),
+			previous: (deviceId) => ({
+				kind: "media-verb",
+				deviceId,
+				verb: "previous"
+			})
+		}
+	},
+	color: { extras: { mireds: (deviceId, value) => {
+		const mireds = parseBounded(value, MIRED_MIN, MIRED_MAX);
+		if (mireds === null || !Number.isInteger(mireds)) return null;
+		return {
+			kind: "color-mireds",
+			deviceId,
+			mireds
+		};
+	} } },
+	"script-runner": { commands: {
+		run: (deviceId) => ({
+			kind: "script-verb",
+			deviceId,
+			verb: "run"
+		}),
+		stop: (deviceId) => ({
+			kind: "script-verb",
+			deviceId,
+			verb: "stop"
+		})
+	} },
+	"automation-control": {
+		primary: (deviceId, value) => {
+			const enabled = parseBool(value);
+			return enabled === null ? null : {
+				kind: "automation-enabled",
+				deviceId,
+				enabled
+			};
+		},
+		commands: { trigger: (deviceId) => ({
+			kind: "automation-trigger",
+			deviceId
+		}) }
+	}
+};
+/**
+* The bounds the parsers enforce, kept HERE rather than imported from the
+* catalog's `TEMPERATURE_RANGE` / `MIRED_RANGE`: the catalog's ranges are
+* what Home Assistant is TOLD, and these are what the hub ACCEPTS. They
+* agree today, and the catalog spec asserts they still do — but the
+* assertion has to be able to fail, which it cannot if both read one
+* constant.
+*/
+var TEMPERATURE_MIN = -20;
+var TEMPERATURE_MAX = 90;
+var MIRED_MIN = 50;
+var MIRED_MAX = 1e3;
 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;
+			if (enabled === null) return {
+				ok: false,
+				reason: "bad-value"
+			};
 			return {
-				kind: "camera-switch",
-				deviceId: target.deviceId,
-				switchId,
-				enabled
+				ok: true,
+				command: {
+					kind: "camera-switch",
+					deviceId: target.deviceId,
+					switchId,
+					enabled
+				}
 			};
 		}
 		if (entity === "reboot") return {
-			kind: "reboot",
-			deviceId: target.deviceId
+			ok: true,
+			command: {
+				kind: "reboot",
+				deviceId: target.deviceId
+			}
 		};
 		const direction = PTZ_DIRECTION_BY_ENTITY[entity];
 		if (direction !== void 0) {
-			if (!target.boundCaps.includes("ptz")) return null;
+			if (!target.boundCaps.includes("ptz")) return {
+				ok: false,
+				reason: "cap-not-bound",
+				capName: "ptz"
+			};
 			return {
-				kind: "ptz-move",
-				deviceId: target.deviceId,
-				direction
+				ok: true,
+				command: {
+					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;
+			if (!target.boundCaps.includes("ptz")) return {
+				ok: false,
+				reason: "cap-not-bound",
+				capName: "ptz"
+			};
+			if (value.trim().length === 0) return {
+				ok: false,
+				reason: "bad-value",
+				capName: "ptz"
+			};
 			return {
-				kind: "ptz-preset",
-				deviceId: target.deviceId,
-				preset: value
+				ok: true,
+				command: {
+					kind: "ptz-preset",
+					deviceId: target.deviceId,
+					preset: value
+				}
 			};
 		}
 		if (entity === "snooze") {
-			if (!SNOOZE_OPTIONS.includes(value)) return null;
+			if (!SNOOZE_OPTIONS.includes(value)) return {
+				ok: false,
+				reason: "bad-value"
+			};
 			const minutes = SNOOZE_MINUTES[value];
 			return {
-				kind: "snooze",
-				deviceId: target.deviceId,
-				minutes: minutes ?? null
+				ok: true,
+				command: {
+					kind: "snooze",
+					deviceId: target.deviceId,
+					minutes: minutes ?? null
+				}
 			};
 		}
-		return null;
+		return {
+			ok: false,
+			reason: "unknown-entity"
+		};
 	}
 	/**
-	* 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.
+	* The derived half.
+	*
+	* One capability can produce several entities — a cover is a state, two
+	* positions and three verbs — so the match is against every id the CATALOG
+	* builds for the cap, through the same two expressions it used
+	* (`derivedEntityId` / `derivedExtraEntityId`). Anything derived from the
+	* catalog rather than re-spelled here cannot address an entity that does
+	* not exist, which is the failure the shared expressions were extracted to
+	* end.
 	*/
-	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;
+	for (const capName of Object.keys(CAP_ENTITY_MAP)) {
+		const route = CAP_COMMAND_ROUTES[capName];
+		if (derivedEntityId(capName) === entity) {
+			if (CAP_ENTITY_MAP[capName]?.writable !== true) return {
+				ok: false,
+				reason: "not-writable",
+				capName
+			};
+			if (!target.boundCaps.includes(capName)) return {
+				ok: false,
+				reason: "cap-not-bound",
+				capName
+			};
+			return build(route?.primary, target.deviceId, value, capName);
+		}
+		for (const [suffix, extra] of Object.entries(CAP_ENTITY_MAP[capName]?.extras ?? {})) {
+			if (derivedExtraEntityId(capName, suffix) !== entity) continue;
+			if (extra.writable !== true) return {
+				ok: false,
+				reason: "not-writable",
+				capName
+			};
+			if (!target.boundCaps.includes(capName)) return {
+				ok: false,
+				reason: "cap-not-bound",
+				capName
+			};
+			return build(route?.extras?.[suffix], target.deviceId, value, capName);
+		}
+		/**
+		* Command buttons. A button carries no state, so there is no `writable`
+		* to consult — its existence in the catalog IS the declaration, and the
+		* route table is the other half. The payload (`PRESS`) is ignored on
+		* purpose: HA sends whatever `payload_press` says and the verb is
+		* already in the topic.
+		*/
+		for (const ref of capCommandEntities(capName)) {
+			if (ref.entity !== entity) continue;
+			if (!target.boundCaps.includes(capName)) return {
+				ok: false,
+				reason: "cap-not-bound",
+				capName
+			};
+			return build(route?.commands?.[ref.suffix], target.deviceId, value, capName);
+		}
+	}
+	return {
+		ok: false,
+		reason: "unknown-entity"
+	};
+}
+/** Run a builder, or name the refusal. The one place `no-route` is decided. */
+function build(builder, deviceId, value, capName) {
+	if (builder === void 0) return {
+		ok: false,
+		reason: "no-route",
+		capName
+	};
+	const command = builder(deviceId, value);
+	if (command === null) return {
+		ok: false,
+		reason: "bad-value",
+		capName
+	};
+	return {
+		ok: true,
+		command
+	};
+}
+/**
+* The camera half, listed rather than the capability half.
+*
+* The capability half is the one that grows — every Tier A row adds a
+* variant — and a narrowing written the other way round would silently send
+* each new one down the camera switch below. There are five camera
+* projections and there have been for the life of this file.
+*/
+function isCameraCommand(command) {
+	switch (command.kind) {
+		case "camera-switch":
+		case "reboot":
+		case "ptz-move":
+		case "ptz-preset":
+		case "snooze": return true;
+		default: return false;
+	}
+}
+/** Narrows an `ExportCommand` to the half {@link applyCapCommand} can make. */
+function isCapCommand(command) {
+	return !isCameraCommand(command);
+}
+/**
+* Make the call the command names.
+*
+* Every branch names ONE method on ONE cap. Nothing here falls back to a
+* neighbouring cap: a device that declares `lock-control` but serves no
+* provider for it is refused with `no-provider`, and the caller logs the
+* drop rather than turning a lock into a switch.
+*/
+async function applyCapCommand(device, command) {
+	switch (command.kind) {
+		case "cap-switch":
+			if (device.switch === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: command.capName
+			};
+			await device.switch.setState({ on: command.on });
+			return { ok: true };
+		case "cap-lock":
+			if (device.lockControl === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: "lock-control"
+			};
+			if (command.locked) await device.lockControl.lock({});
+			else await device.lockControl.unlock({});
+			return { ok: true };
+		case "cap-lock-open":
+			if (device.lockControl === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: "lock-control"
+			};
+			/**
+			* A lock without a latch REFUSES this, and the refusal is the answer.
+			* `lock-control` declares `open` unconditionally while the latch is a
+			* property of the hardware, so the provider is the only thing that
+			* knows — reporting success over its refusal would leave Home
+			* Assistant showing a door that opened and did not.
+			*/
+			try {
+				await device.lockControl.open({});
+			} catch (err) {
+				return {
+					ok: false,
+					reason: "refused",
+					capName: "lock-control",
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+			return { ok: true };
+		case "cap-brightness":
+			if (device.brightness === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: "brightness"
+			};
+			await device.brightness.setBrightness({ percentage: command.percentage });
+			return { ok: true };
+		case "cap-alarm":
+			if (device.alarmPanel === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: "alarm-panel"
+			};
+			/**
+			* **The arm can be REFUSED.** CamStack's own panel throws
+			* `NcAlarmArmRefusedError` when a contact the mode covers is open,
+			* and that refusal is the operator's answer — reporting success
+			* over it would leave Home Assistant showing `armed_away` on a
+			* house with an open door. It is caught HERE rather than left to
+			* the caller's generic catch so the reason is named `refused` and
+			* the panel's own message survives into the log.
+			*/
+			try {
+				switch (command.action.kind) {
+					case "arm":
+						await device.alarmPanel.arm({ mode: command.action.mode });
+						break;
+					case "disarm":
+						await device.alarmPanel.disarm({});
+						break;
+					case "trigger":
+						await device.alarmPanel.trigger({});
+						break;
+				}
+			} catch (err) {
+				return {
+					ok: false,
+					reason: "refused",
+					capName: "alarm-panel",
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+			return { ok: true };
+		case "cap-button":
+			if (device.button === void 0) return {
+				ok: false,
+				reason: "no-provider",
+				capName: command.capName
+			};
+			await device.button.press({});
+			return { ok: true };
+		case "cover-position": return call(device.cover, "cover", (cover) => cover.setPosition({ position: command.position }));
+		case "cover-tilt": return call(device.cover, "cover", (cover) => cover.setTiltPosition({ tiltPosition: command.tiltPosition }));
+		case "cover-verb": return call(device.cover, "cover", (cover) => {
+			switch (command.verb) {
+				case "open": return cover.open({});
+				case "close": return cover.close({});
+				case "stop": return cover.stop({});
+			}
+		});
+		case "climate-mode": return call(device.climateControl, "climate-control", (climate) => climate.setMode({ mode: command.mode }));
+		case "climate-target": return call(device.climateControl, "climate-control", (climate) => climate.setTarget({ target: command.target }));
+		case "climate-fan-mode": return call(device.climateControl, "climate-control", (climate) => climate.setFanMode({ fanMode: command.fanMode }));
+		case "climate-preset": return call(device.climateControl, "climate-control", (climate) => climate.setPreset({ preset: command.preset }));
+		/**
+		* The one read-then-write in this file, and the reason is the cap's
+		* signature rather than a preference: `setTargetRange` takes both edges
+		* and Home Assistant sends them one at a time. The OTHER edge is read
+		* from `getStatus` — the provider's own current answer — and a `null`
+		* there is REFUSED, because a dual-setpoint device that reports no range
+		* has no range to move one edge of, and substituting the single `target`
+		* would silently collapse the band to a point.
+		*/
+		case "climate-target-edge": return call(device.climateControl, "climate-control", async (climate) => {
+			const status = await climate.getStatus({});
+			if (status === null) throw new Error("the device reports no climate status, so setTargetRange has no range");
+			const low = command.edge === "low" ? command.value : status.targetLow;
+			const high = command.edge === "high" ? command.value : status.targetHigh;
+			if (low === null || high === null) throw new Error(`the device reports no ${command.edge === "low" ? "high" : "low"} setpoint, so setTargetRange has nothing to preserve`);
+			await climate.setTargetRange({
+				targetLow: low,
+				targetHigh: high
+			});
+		});
+		case "climate-target-humidity": return call(device.climateControl, "climate-control", (climate) => climate.setTargetHumidity({ targetHumidity: command.targetHumidity }));
+		case "climate-swing": return call(device.climateControl, "climate-control", (climate) => command.axis === "vertical" ? climate.setSwingVertical({ on: command.on }) : climate.setSwingHorizontal({ on: command.on }));
+		case "fan-percentage": return call(device.fanControl, "fan-control", (fan) => fan.setPercentage({ percentage: command.percentage }));
+		case "fan-preset": return call(device.fanControl, "fan-control", (fan) => fan.setPreset({ preset: command.preset }));
+		case "fan-oscillating": return call(device.fanControl, "fan-control", (fan) => fan.setOscillating({ oscillating: command.oscillating }));
+		case "fan-direction": return call(device.fanControl, "fan-control", (fan) => fan.setDirection({ direction: command.direction }));
+		case "humidifier-on": return call(device.humidifier, "humidifier", (humidifier) => humidifier.setOn({ on: command.on }));
+		case "humidifier-humidity": return call(device.humidifier, "humidifier", (humidifier) => humidifier.setTargetHumidity({ humidity: command.humidity }));
+		case "humidifier-mode": return call(device.humidifier, "humidifier", (humidifier) => humidifier.setMode({ mode: command.mode }));
+		case "water-heater-temp": return call(device.waterHeater, "water-heater", (heater) => heater.setTargetTemp({ temp: command.temp }));
+		case "water-heater-away": return call(device.waterHeater, "water-heater", (heater) => heater.setAway({ on: command.on }));
+		case "water-heater-mode": return call(device.waterHeater, "water-heater", (heater) => heater.setOperationMode({ mode: command.mode }));
+		case "valve-position": return call(device.valve, "valve", (valve) => valve.setPosition({ position: command.position }));
+		case "valve-verb": return call(device.valve, "valve", (valve) => {
+			switch (command.verb) {
+				case "open": return valve.open({});
+				case "close": return valve.close({});
+				case "stop": return valve.stop({});
+			}
+		});
+		case "vacuum-verb": return call(device.vacuumControl, "vacuum-control", (vacuum) => {
+			switch (command.verb) {
+				case "start": return vacuum.start({});
+				case "pause": return vacuum.pause({});
+				case "stop": return vacuum.stop({});
+				case "return-to-base": return vacuum.returnToBase({});
+				case "locate": return vacuum.locate({});
+			}
+		});
+		case "vacuum-fan-speed": return call(device.vacuumControl, "vacuum-control", (vacuum) => vacuum.setFanSpeed({ speed: command.speed }));
+		case "mower-verb": return call(device.lawnMowerControl, "lawn-mower-control", (mower) => {
+			switch (command.verb) {
+				case "start": return mower.startMowing({});
+				case "pause": return mower.pause({});
+				case "dock": return mower.dock({});
+			}
+		});
+		case "media-verb": return call(device.mediaPlayer, "media-player", (media) => {
+			switch (command.verb) {
+				case "play": return media.play({});
+				case "pause": return media.pause({});
+				case "stop": return media.stop({});
+				case "next": return media.next({});
+				case "previous": return media.previous({});
+			}
+		});
+		case "media-volume": return call(device.mediaPlayer, "media-player", (media) => media.setVolume({ volumeLevel: command.volumeLevel }));
+		case "media-mute": return call(device.mediaPlayer, "media-player", (media) => media.setMute({ muted: command.muted }));
+		case "media-shuffle": return call(device.mediaPlayer, "media-player", (media) => media.setShuffle({ shuffle: command.shuffle }));
+		case "media-repeat": return call(device.mediaPlayer, "media-player", (media) => media.setRepeat({ repeat: command.repeat }));
+		case "media-source": return call(device.mediaPlayer, "media-player", (media) => media.selectSource({ source: command.source }));
+		case "color-mireds": return call(device.color, "color", (color) => color.setColor({ color: {
+			mode: "mired",
+			mireds: command.mireds
+		} }));
+		case "script-verb": return call(device.scriptRunner, "script-runner", (script) => command.verb === "run" ? script.run({}) : script.stop({}));
+		case "automation-enabled": return call(device.automationControl, "automation-control", (automation) => command.enabled ? automation.enable({}) : automation.disable({}));
+		case "automation-trigger": return call(device.automationControl, "automation-control", (automation) => automation.trigger({}));
+	}
+}
+/**
+* One capability call, with the two outcomes that are not success.
+*
+* `no-provider` is a device that DECLARES the cap and serves nothing —
+* distinct from a throw, which is the device REFUSING. The distinction is the
+* whole reason `alarm-panel` grew its own try/catch first: an arm the panel
+* turns down (`NcAlarmArmRefusedError`, a contact the mode covers is open) is
+* the operator's answer and must reach them with the panel's own words, not
+* as an optimistic success. Every Tier A method can refuse the same way — a
+* cover already moving, a vacuum with an empty tank, a climate mode the unit
+* does not have in `availableModes` — so the handling is here rather than
+* repeated per branch.
+*/
+async function call(slice, capName, make) {
+	if (slice === void 0) return {
+		ok: false,
+		reason: "no-provider",
+		capName
+	};
+	try {
+		await make(slice);
+	} catch (err) {
 		return {
-			kind: "cap-switch",
-			deviceId: target.deviceId,
+			ok: false,
+			reason: "refused",
 			capName,
-			on
+			error: err instanceof Error ? err.message : String(err)
 		};
 	}
-	return null;
+	return { ok: true };
 }
 /**
 * The ONE derivation of "a signed, expiring URL".
@@ -1363,6 +4425,110 @@ function bool(value) {
 	return value ? "true" : "false";
 }
 /**
+* A value → the string Home Assistant's platform expects.
+*
+* Exhaustive over `HaPlatform` so a new platform cannot be added
+* without deciding what its values look like. Every value is a STRING:
+* the component lowercases binary values verbatim and a JSON number or
+* boolean raises inside its state callback, which it swallows — so the
+* entity silently never updates again.
+*/
+function renderCapValue(mapping, raw) {
+	switch (mapping.platform) {
+		case "binary_sensor":
+		case "switch": return typeof raw === "boolean" ? bool(raw) : null;
+		case "number": return typeof raw === "number" && Number.isFinite(raw) ? String(raw) : null;
+		case "sensor":
+			if (mapping.deviceClass === "timestamp") {
+				if (typeof raw === "number" && Number.isFinite(raw)) return iso(raw);
+				return typeof raw === "string" ? raw : null;
+			}
+			if (typeof raw === "number") return Number.isFinite(raw) ? String(raw) : null;
+			if (typeof raw === "string") return raw;
+			return typeof raw === "boolean" ? bool(raw) : null;
+		case "select":
+		case "alarm_control_panel":
+		case "image":
+		case "camera": return typeof raw === "string" ? raw : null;
+		case "button": return null;
+		case "cover":
+		case "climate":
+		case "lock":
+		case "fan":
+		case "vacuum":
+		case "valve":
+		case "humidifier":
+		case "water_heater":
+		case "media_player":
+ /**
+		* A native platform carries no value of its own. It is built from
+		* the topics of the DEGRADED descriptors — which are the ones this
+		* function renders — so `CAP_ENTITY_MAP` never names one, and a
+		* descriptor that did would be publishing to a topic no entity
+		* reads. `null` here is `unrenderable`, which the addon LOGS: the
+		* loud failure is the point.
+		*/
+		return null;
+	}
+}
+/**
+* One capability slice → the derived entity's value.
+*
+* **This is the push path every derived capability was missing.** The
+* addon used to handle four caps by hand (`device-status`, `battery`,
+* `doorbell`, `motion`) and the other 23 entries in `CAP_ENTITY_MAP` had
+* no push path at all — they moved only on the 300 s reconcile, and the
+* ones whose topics disagreed with the catalog never moved at all. This
+* is descriptor-driven, so a capability T3 adds to `CAP_ENTITY_MAP`
+* arrives with its push path already built.
+*/
+function projectCapSlice(deviceKey, capName, slice) {
+	const mapping = CAP_ENTITY_MAP[capName];
+	if (mapping === void 0) return {
+		kind: "no-entity",
+		capName
+	};
+	const entity = derivedEntityId(capName);
+	const values = [];
+	/**
+	* Every entity the capability produces, not just its primary. A `cover`
+	* is a state AND a position, and projecting only the first would leave
+	* the second in Home Assistant's registry with nothing arriving on it —
+	* which is precisely the defect the descriptor table replaced.
+	*/
+	for (const ref of capEntities(capName)) {
+		if (ref.descriptor.platform === "button") continue;
+		if (!Object.prototype.hasOwnProperty.call(slice, ref.descriptor.field)) return {
+			kind: "missing-field",
+			capName,
+			field: ref.descriptor.field,
+			sliceFields: Object.keys(slice)
+		};
+		const raw = slice[ref.descriptor.field];
+		if (raw === null || raw === void 0) continue;
+		const rendered = renderCapValue(ref.descriptor, deriveCapValue(ref.descriptor.derive, raw));
+		if (rendered === null) return {
+			kind: "unrenderable",
+			capName,
+			field: ref.descriptor.field,
+			valueType: typeof raw
+		};
+		values.push({
+			topic: stateTopic(deviceKey, ref.entity),
+			value: rendered
+		});
+	}
+	if (mapping.platform === "button" && mapping.extras === void 0) return {
+		kind: "no-entity",
+		capName
+	};
+	return {
+		kind: "values",
+		entity,
+		values
+	};
+}
+/**
 * Reachability.
 *
 * `device.sleeping` deliberately does NOT feed this: a battery camera in
@@ -1889,6 +5055,22 @@ function projectSynthetic(input, nowMs) {
 	}
 	return values;
 }
+//#endregion
+//#region src/ha-export/reconcile-fingerprint.ts
+function structureFingerprint(exported) {
+	return JSON.stringify([...exported.keys()].sort().map((key) => {
+		const entry = exported.get(key);
+		return [
+			key,
+			entry?.brokerIds,
+			entry?.plan
+		];
+	}));
+}
+/** Only an event-debounced pass with an unchanged structure may skip. */
+function shouldSkipAnnounce(reason, fingerprint, lastFingerprint) {
+	return reason === "structure-changed" && fingerprint === lastFingerprint;
+}
 /** The `BrokerInfo.kind` tag the Home Assistant provider stamps. */
 var HA_BROKER_KIND = "home-assistant";
 /**
@@ -1975,6 +5157,17 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 	/** A reason asked for while one was running. Re-run, never dropped. */
 	reconcilePending = null;
 	lastError;
+	/**
+	* Fingerprint of the last ANNOUNCED structure. An event-debounced
+	* reconcile that rebuilds an identical structure skips the announce and
+	* the full state push: a flapping camera (RTSP retry every 4 s emits a
+	* device event per attempt) was driving a full 2.7 s reconcile every
+	* ~13 s, forever. Only the 'structure-changed' reason short-circuits —
+	* 'boot', 'periodic' and config-driven passes always announce, so the
+	* D8/D11 contract (events are an optimisation, never a substitute)
+	* still holds through the periodic pass.
+	*/
+	lastStructureFingerprint;
 	entityCount = 0;
 	/** deviceId → the `lastPressedAt` already rung, so a re-read does not ring again. */
 	lastDoorbellPressAt = /* @__PURE__ */ new Map();
@@ -1982,6 +5175,15 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 	doorbellReleaseTimers = /* @__PURE__ */ new Map();
 	unclassified = [];
 	/**
+	* What each Home Assistant's custom component can BUILD.
+	*
+	* The hub and the component ship on different trains — the operator
+	* updates the integration through HACS when they decide to — so a
+	* platform this hub knows about is not one the component has. Refreshed
+	* at the top of every reconcile, before any plan is built.
+	*/
+	componentSupport = new ComponentSupportTracker();
+	/**
 	* 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.
@@ -2116,6 +5318,19 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			this.reconcileSoon();
 		});
 	}
+	/**
+	* A slice changed → the entities that read it.
+	*
+	* Two halves, exactly as the catalog has two halves. `device-status`
+	* and `battery` are projected by hand for BOTH kinds — their topics are
+	* the same on a camera and on a base device, and `battery` deliberately
+	* publishes nothing when the device reports a low-battery INDICATOR
+	* rather than a level, which a descriptor cannot express. Everything
+	* else on a camera is a projection of pipeline output, and everything
+	* else on a base device is derived from `CAP_ENTITY_MAP` — the same
+	* branch `buildDevicePlan` takes, so the value can only land on an
+	* entity the plan actually built.
+	*/
 	onSliceChanged(data) {
 		const deviceId = readNumber(data, "deviceId");
 		const capName = readString(data, "capName");
@@ -2123,6 +5338,19 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		if (deviceId === null || capName === null || slice === null) return;
 		const deviceKey = this.keyByDeviceId.get(deviceId);
 		if (deviceKey === void 0) return;
+		if (capName !== "device-status" && capName !== "battery" && !this.isCamera(deviceKey)) {
+			this.pushDerivedCap(deviceId, deviceKey, capName, slice);
+			return;
+		}
+		/**
+		* The two capabilities a CAMERA carries from the derived half. Same
+		* descriptor, same entity id, same projector — the camera catalog
+		* simply builds the component instead of `buildDerivedPlan`.
+		*/
+		if (CAMERA_DERIVED_CAPS.includes(capName)) {
+			this.pushDerivedCap(deviceId, deviceKey, capName, slice);
+			return;
+		}
 		if (capName === "device-status") {
 			const online = slice["online"];
 			if (typeof online === "boolean") this.push(deviceId, projectDeviceStatus(deviceKey, online));
@@ -2186,6 +5414,61 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			}));
 		}
 	}
+	/** Camera or base kind — the same question `buildDevicePlan` asks. */
+	isCamera(deviceKey) {
+		return this.exported.get(deviceKey)?.target.type === "camera";
+	}
+	/**
+	* The generic derived push: any capability in `CAP_ENTITY_MAP`.
+	*
+	* Every branch that produces no value SAYS so, once per
+	* (device, cap, field): an entity that exists and never receives a
+	* value used to be indistinguishable from an entity nothing had
+	* happened to, and that is how 23 of the 27 mapped capabilities went
+	* unnoticed with no push path at all. Once, because a slice that
+	* changes every second must not turn a catalog defect into a log
+	* flood — the first line already carries everything the fix needs.
+	*/
+	pushDerivedCap(deviceId, deviceKey, capName, slice) {
+		const projection = projectCapSlice(deviceKey, capName, slice);
+		switch (projection.kind) {
+			case "values":
+				if (projection.values.length > 0) this.push(deviceId, projection.values);
+				return;
+			case "no-entity": return;
+			case "missing-field":
+				this.warnOnce(deviceId, capName, projection.field, {
+					message: "ha-export: a derived entity reads a field its slice does not carry",
+					meta: {
+						capName,
+						field: projection.field,
+						sliceFields: projection.sliceFields
+					}
+				});
+				return;
+			case "unrenderable":
+				this.warnOnce(deviceId, capName, projection.field, {
+					message: "ha-export: a derived entity cannot render the value its slice carries",
+					meta: {
+						capName,
+						field: projection.field,
+						valueType: projection.valueType
+					}
+				});
+				return;
+		}
+	}
+	/** deviceId:cap:field already reported. Bounded by devices × mapped caps. */
+	warnedCapFields = /* @__PURE__ */ new Set();
+	warnOnce(deviceId, capName, field, line) {
+		const key = `${deviceId}:${capName}:${field}`;
+		if (this.warnedCapFields.has(key)) return;
+		this.warnedCapFields.add(key);
+		this.ctx.logger.warn(line.message, {
+			tags: { deviceId },
+			meta: line.meta
+		});
+	}
 	onOnlineChanged(data, online) {
 		const deviceId = readNumber(data, "deviceId");
 		if (deviceId === null) return;
@@ -2199,6 +5482,17 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		if (deviceId === null || typeof detected !== "boolean") return;
 		const deviceKey = this.keyByDeviceId.get(deviceId);
 		if (deviceKey === void 0) return;
+		/**
+		* A base device's motion entity is `motion`, a camera's is
+		* `motion_detected` + `triggered`. The cap event is the same one, so
+		* the projection has to follow the device's own half of the catalog —
+		* publishing the camera topics for a PIR sensor addressed three
+		* entities the sensor's plan never built.
+		*/
+		if (!this.isCamera(deviceKey)) {
+			this.pushDerivedCap(deviceId, deviceKey, "motion", { detected });
+			return;
+		}
 		const timestamp = readNumber(data, "timestamp") ?? Date.now();
 		this.push(deviceId, projectMotion(deviceKey, {
 			detected,
@@ -2390,6 +5684,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		try {
 			await this.refreshBrokers();
 			await this.refreshMediaBaseUrl();
+			await this.refreshComponentSupport();
 			const enabled = this.enabledBrokerIds();
 			const devices = await this.ctx.api.deviceManager.listAll.query({});
 			const snapshots = await this.ctx.api.deviceState.getAllSnapshots.query({});
@@ -2397,6 +5692,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			const exported = /* @__PURE__ */ new Map();
 			const keyByDeviceId = /* @__PURE__ */ new Map();
 			const allCaps = /* @__PURE__ */ new Set();
+			const exportedDeviceLog = [];
 			let entityCount = 0;
 			for (const deviceIdStr of exposedDeviceIds(this.config.membership, enabled)) {
 				const numericId = Number(deviceIdStr);
@@ -2420,8 +5716,15 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 				}
 				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));
+				/**
+				* The plan is built ONCE and announced to every broker that
+				* receives the device, so it can only use platforms ALL of them
+				* build — see `intersectSupport`. One instance on an old component
+				* therefore holds its device back and nobody's entities silently
+				* fail to arrive.
+				*/
+				const plan = buildDevicePlan(catalogDevice, { platforms: this.componentSupport.supportForAll(brokerIds) });
 				exported.set(plan.deviceKey, {
 					plan,
 					deviceId: numericId,
@@ -2430,7 +5733,8 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 						type: device.type,
 						boundCaps: catalogDevice.boundCaps
 					},
-					brokerIds
+					brokerIds,
+					streams: catalogDevice.streams ?? []
 				});
 				keyByDeviceId.set(numericId, plan.deviceKey);
 				entityCount += Object.keys(plan.cmps).length;
@@ -2439,16 +5743,16 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 				* 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.
+				* entities. Silence reads as "never happened" both ways. Deferred
+				* until the announce decision: a skipped identical pass must not
+				* repeat the whole roster either.
 				*/
-				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
-					}
+				exportedDeviceLog.push({
+					deviceId: numericId,
+					deviceType: device.type,
+					deviceKey: plan.deviceKey,
+					brokers: brokerIds,
+					entities: Object.keys(plan.cmps).length
 				});
 			}
 			/**
@@ -2469,7 +5773,8 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 						type: "synthetic",
 						boundCaps: []
 					},
-					brokerIds: [...enabled]
+					brokerIds: [...enabled],
+					streams: []
 				});
 				entityCount += Object.keys(plan.cmps).length;
 			}
@@ -2477,6 +5782,25 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			this.keyByDeviceId = keyByDeviceId;
 			this.entityCount = entityCount;
 			this.unclassified = unclassifiedCaps([...allCaps]);
+			const fingerprint = structureFingerprint(exported);
+			if (shouldSkipAnnounce(reason, fingerprint, this.lastStructureFingerprint)) {
+				this.ctx.logger.debug("ha-export: structure unchanged, skipping announce", { meta: {
+					devices: exported.size,
+					entities: entityCount
+				} });
+				this.lastError = void 0;
+				return;
+			}
+			this.lastStructureFingerprint = fingerprint;
+			for (const line of exportedDeviceLog) this.ctx.logger.info("ha-export: exporting device", {
+				tags: { deviceId: line.deviceId },
+				meta: {
+					deviceType: line.deviceType,
+					deviceKey: line.deviceKey,
+					brokers: line.brokers,
+					entities: line.entities
+				}
+			});
 			await this.announce(exported);
 			await this.pushFullState(exported, snapshots);
 			if (synthetic !== null) await this.pushSynthetic(projectSynthetic(synthetic, Date.now()), [...enabled]);
@@ -2616,7 +5940,55 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 				}));
 			}
 		}
+		/**
+		* The derived half, from the snapshot the reconcile already read.
+		*
+		* The reconcile is the CONTRACT — events are an optimisation over it
+		* (D8) — so every entity it announces must also get a value from it.
+		* It used to push only `device-status` and `battery`, which is why a
+		* derived entity whose event path was missing stayed blank for ever
+		* rather than for one interval.
+		*/
+		{
+			/**
+			* The derived half, and the two capabilities a CAMERA carries from
+			* it (`CAMERA_DERIVED_CAPS`). A camera takes the hand-written
+			* catalog, so every other cap slice on one addresses no component;
+			* these two do, because the camera catalog builds them from the
+			* same descriptor and the same entity id.
+			*/
+			const isCamera = entry.target.type === "camera";
+			for (const [capName, capSlice] of Object.entries(snapshot)) {
+				if (capName === "device-status" || capName === "battery") continue;
+				if (isCamera && !CAMERA_DERIVED_CAPS.includes(capName)) continue;
+				const projection = projectCapSlice(key, capName, capSlice);
+				if (projection.kind === "values") values.push(...projection.values);
+				else if (projection.kind === "missing-field") this.warnOnce(entry.deviceId, capName, projection.field, {
+					message: "ha-export: a derived entity reads a field its slice does not carry",
+					meta: {
+						capName,
+						field: projection.field,
+						sliceFields: projection.sliceFields
+					}
+				});
+				else if (projection.kind === "unrenderable") this.warnOnce(entry.deviceId, capName, projection.field, {
+					message: "ha-export: a derived entity cannot render the value its slice carries",
+					meta: {
+						capName,
+						field: projection.field,
+						valueType: projection.valueType
+					}
+				});
+			}
+		}
 		if (entry.target.type === "camera") {
+			/**
+			* The live picture publishes NOTHING here, deliberately. A `camera`
+			* entity's whole content is its `stream_target`, which travelled with
+			* the announce; the component fetches the still and negotiates the
+			* video itself. The url this block used to publish was read by
+			* nobody — see `camera-entities.ts`.
+			*/
 			const group = await this.ctx.api.pipelineOrchestrator.getCameraSwitches.query({ deviceId: entry.deviceId });
 			values.push(...projectCameraSwitches(key, group.switches.map((sw) => ({
 				id: sw.id,
@@ -2645,6 +6017,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 		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 streams = device.type === "camera" && boundCaps.includes("webrtc-session") ? await this.loadStreamChoices(device.id) : [];
 		const manufacturer = readString(device.metadata ?? {}, "manufacturer");
 		const model = readString(device.metadata ?? {}, "model");
 		return {
@@ -2659,9 +6032,48 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			zones,
 			switches,
 			ptzPresets,
-			slices: Object.keys(snapshot)
+			streams,
+			slices: Object.keys(snapshot),
+			/**
+			* The slice VALUES, for the native platforms only: a native
+			* `climate` announces the modes the device accepts, and
+			* `availableModes` is on the slice and nowhere else. See
+			* `CatalogDevice.capSlices`.
+			*/
+			capSlices: snapshot
 		};
 	}
+	/**
+	* Every stream of the camera, as the hub's own picker lists them.
+	*
+	* `webrtcSession.listStreams` rather than
+	* `cameraStreams.getProfileRtspEntries`: the component negotiates live
+	* video through `webrtcSession.handleOffer` and needs the `target`, not
+	* an address. Reading the RTSP entries instead cost this export three
+	* things it no longer pays — a `hostname` argument (the broker binds
+	* `127.0.0.1`, so a camera on a hub with no reachable base url got NO
+	* camera entity at all), a refusal for a credentialed url, and a whole
+	* value plane nothing consumed.
+	*
+	* `listStreams` also reports the camera's raw substreams, which the
+	* profile view could not express.
+	*/
+	async loadStreamChoices(deviceId) {
+		try {
+			return (await this.ctx.api.webrtcSession.listStreams.query({ deviceId })).map((choice) => ({
+				id: choice.id,
+				label: choice.label,
+				target: choice.target,
+				...choice.resolution === null ? {} : { height: choice.resolution.height }
+			}));
+		} catch (err) {
+			this.ctx.logger.warn("ha-export: could not read the camera streams, no camera entity", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			});
+			return [];
+		}
+	}
 	async loadBoundCaps(deviceId) {
 		try {
 			return (await this.ctx.api.deviceManager.getBindings.query({ deviceId })).entries.map((entry) => entry.capName);
@@ -2769,6 +6181,7 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			if (wanted.has(brokerId)) continue;
 			await link.client.dispose();
 			this.links.delete(brokerId);
+			this.componentSupport.forget(brokerId);
 			this.ctx.logger.info("ha-export: stopped exporting to a broker", { meta: { brokerId } });
 		}
 		for (const broker of haBrokers) {
@@ -2796,6 +6209,75 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			} });
 		}
 	}
+	/**
+	* Ask every live link what its component builds.
+	*
+	* Sequential and cheap — one GET per Home Assistant per reconcile, and
+	* there is one Home Assistant on almost every installation. A link that
+	* does not answer keeps whatever was negotiated last: the tracker treats
+	* silence as no information, because the alternative is that one
+	* timeout migrates every native entity back to a sensor.
+	*/
+	async refreshComponentSupport() {
+		for (const [brokerId, link] of this.links) {
+			const probe = await this.probeComponent(link);
+			const change = this.componentSupport.observe(brokerId, probe);
+			if (change.withheldDowngrade) {
+				/**
+				* D49. The read that DESTROYS work needs a second read to agree,
+				* and the operator gets to see that this is what happened rather
+				* than watching their entities migrate on one bad answer.
+				*/
+				this.ctx.logger.warn("ha-export: the Home Assistant component reports fewer platforms than before — holding the old set until a second read agrees", { meta: {
+					brokerId,
+					current: supportSignature(change.support),
+					reported: probe.kind === "reported" ? supportSignature(probe.report.platforms) : "none"
+				} });
+				continue;
+			}
+			if (!change.changed) continue;
+			this.ctx.logger.info("ha-export: negotiated the Home Assistant component platform set", { meta: {
+				brokerId,
+				componentVersion: probe.kind === "reported" ? probe.report.version ?? "unknown" : "pre-0.4.0",
+				platforms: supportSignature(change.support)
+			} });
+		}
+	}
+	/**
+	* One `GET /api/camstack/version`, turned into the three answers the
+	* tracker distinguishes.
+	*
+	* A 404 is the OLD component saying it has no such endpoint, which is
+	* information. Anything else — a timeout, a 500, a rotated token — is
+	* not, and must not be read as one.
+	*/
+	async probeComponent(link) {
+		try {
+			const response = await fetch(`${link.baseUrl.replace(/\/+$/, "")}${COMPONENT_VERSION_PATH}`, {
+				headers: { authorization: `Bearer ${link.token}` },
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (response.status === 404 || response.status === 405) return { kind: "absent" };
+			if (!response.ok) return {
+				kind: "unknown",
+				error: `Home Assistant answered ${response.status}`
+			};
+			const report = parseComponentReport(await response.json());
+			if (report === null) return {
+				kind: "unknown",
+				error: "the component answered without a platform list"
+			};
+			return {
+				kind: "reported",
+				report
+			};
+		} catch (err) {
+			return {
+				kind: "unknown",
+				error: errMsg(err)
+			};
+		}
+	}
 	async resolveBrokerConnection(brokerId, addonId) {
 		try {
 			const raw = await this.ctx.api.broker.getBrokerConfig.query({
@@ -2924,25 +6406,56 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 			}
 			return;
 		}
-		const command = resolveCommand(exported.target, parsed.entity, value);
-		if (command === null) {
-			this.ctx.logger.warn("ha-export: dropping an unroutable command", {
+		const resolution = resolveCommand(exported.target, parsed.entity, value);
+		if (!resolution.ok) {
+			/**
+			* The reason is NAMED. "Unroutable" covered five different faults —
+			* a typo in a topic, a capability the device does not declare, a
+			* payload the platform cannot carry, and a control the catalog
+			* advertised with no route behind it — and an operator watching a
+			* switch snap back in Home Assistant could not tell which.
+			*/
+			this.ctx.logger.warn("ha-export: dropping a command it cannot route", {
 				tags: { deviceId: exported.deviceId },
 				meta: {
 					topic,
-					entity: parsed.entity
+					entity: parsed.entity,
+					reason: resolution.reason,
+					...resolution.capName !== void 0 ? { capName: resolution.capName } : {}
 				}
 			});
 			reply.status(422);
-			reply.send({ error: "unroutable command" });
+			reply.send({ error: `unroutable command (${resolution.reason})` });
 			return;
 		}
-		const applied = await this.dispatch(command);
+		const applied = await this.dispatch(resolution.command);
 		reply.status(applied ? 200 : 422);
 		reply.send(applied ? {} : { error: "command not applied" });
 	}
 	async dispatch(command) {
 		try {
+			/**
+			* The capability half goes through the route table that NAMED the
+			* method — `lockControl.lock`, `brightness.setBrightness`,
+			* `alarmPanel.arm`, `switch.setState`. It used to end here
+			* regardless of the capability, calling `device.switch.setState`
+			* for all of them, so a lock got `noProvider` and a 422 and a
+			* brightness command never arrived at all.
+			*/
+			if (isCapCommand(command)) {
+				const outcome = await applyCapCommand(await this.ctx.fetchDevice(command.deviceId), command);
+				if (outcome.ok) return true;
+				if (outcome.reason === "no-provider") return this.noProvider(command.deviceId, outcome.capName);
+				this.ctx.logger.warn("ha-export: the device refused the command", {
+					tags: { deviceId: command.deviceId },
+					meta: {
+						capName: outcome.capName,
+						kind: command.kind,
+						...outcome.error !== void 0 ? { error: outcome.error } : {}
+					}
+				});
+				return false;
+			}
 			switch (command.kind) {
 				case "camera-switch": {
 					const parsed = require_dist.CameraSwitchIdSchema.safeParse(command.switchId);
@@ -2987,18 +6500,6 @@ var HaExportAddon = class extends require_dist.BaseAddon {
 					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) {
 			/**