@camstack/addon-provider-enpal 0.1.17 → 0.1.19

package/dist/addon.js

@@ -3,7 +3,7 @@ let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 let node_url = require("node:url");
-//#region ../types/dist/event-category-78tcBemo.mjs
+//#region ../types/dist/event-category-Dv-Gcv1f.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -444,6 +444,15 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["DeviceStateChanged"] = "device.state-changed";
 	/**
+	* A device COMMAND (a vocabulary action, D920/D983) settled in the hub's
+	* transition audit (D1022): confirmed, already in place, unconfirmed or
+	* failed. Never a device's own change. Payload: `DeviceCommandSettledEvent`
+	* (`{deviceId, action, outcome, actor, at}`, no arguments). It feeds
+	* the Notification Center `device-command` kind. Telemetry (D8): losing one
+	* costs a notification, never state; the audit row is the record.
+	*/
+	EventCategory["DeviceCommandSettled"] = "device.command-settled";
+	/**
 	* The NATIVE shadow of a cap a composition has claimed fields of moved
 	* (D663). Payload: `{ deviceId, capName, native }` — what the provider
 	* wrote, BEFORE the owned fields are overlaid. Owner-only (D224): it is for
@@ -6048,7 +6057,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-D0roI_CZ.mjs
+//#region ../types/dist/sleep-DyIxjZZt.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6731,6 +6740,13 @@ async function runAddonMigrations(host, migrations, logger, options = {}) {
 		else skipped.push(id);
 	};
 	const selected = options.only === void 0 ? null : new Set(options.only);
+	const deferred = /* @__PURE__ */ new Set();
+	const deferredBy = (reason) => {
+		if (selected === null || reason === null) return null;
+		const dep = /^dependency-(?:pending|blocked):(.+)$/.exec(reason)?.[1];
+		if (dep === void 0 || !byId.has(dep)) return null;
+		return !selected.has(dep) || deferred.has(dep) ? dep : null;
+	};
 	for (const step of declaration.steps) {
 		if (selected !== null && !selected.has(step.id)) continue;
 		const bound = byId.get(step.id);
@@ -6742,6 +6758,19 @@ async function runAddonMigrations(host, migrations, logger, options = {}) {
 		try {
 			const gate = await host.startMigration({ id: step.id });
 			if (!gate.proceed) {
+				const waitsFor = deferredBy(gate.reason);
+				if (waitsFor !== null) {
+					log.info("migration deferred: its predecessor runs in another phase of this owner", {
+						tags,
+						meta: {
+							waitsFor,
+							reason: gate.reason
+						}
+					});
+					deferred.add(step.id);
+					skipped.push(step.id);
+					continue;
+				}
 				log.warn("migration not run", {
 					tags,
 					meta: {
@@ -10279,6 +10308,13 @@ var DeviceTransitionSchema = object({
 	actor: TransitionActorSchema,
 	command: TransitionCommandSchema.optional()
 });
+object({
+	deviceId: number$1().int(),
+	action: string(),
+	outcome: TransitionOutcomeSchema,
+	actor: TransitionActorSchema,
+	at: number$1()
+});
 var READING_QUANTITIES = [
 	"temperature",
 	"pressure",
@@ -12302,7 +12338,10 @@ var ACTUATOR_CAP_VOCABULARY = {
 	"ir-transmitter": {
 		scope: "device",
 		noun: t("IR / RF transmitter", "Trasmettitore IR / RF"),
-		notOperatorFacing: { send: "a raw pulse train is not something an operator composes in an automation; the remote that owns the command table sends it" }
+		notOperatorFacing: {
+			send: "a raw pulse train is not something an operator composes in an automation; the remote that owns the command table sends it",
+			learn: "an interactive capture the operator starts from the source dialog and answers by pressing a physical remote; no automation can supply the signal"
+		}
 	},
 	control: {
 		scope: "device",
@@ -15223,6 +15262,32 @@ var CAP_VOCABULARY_BY_NAME = {
 	...SYSTEM_CAP_VOCABULARY
 };
 /**
+* Vocabulary actions by id (D983). An action step names a vocabulary action
+* (`cover.open`), never a raw cap method; this is the one lookup that turns the
+* id into its cap, method and effect — and a persisted legacy `cap` + `method`
+* pair back into the action id when exactly one action matches.
+*/
+function buildIndex() {
+	const byId = /* @__PURE__ */ new Map();
+	for (const [cap, entry] of Object.entries(CAP_VOCABULARY_BY_NAME)) {
+		if (entry.scope !== "device") continue;
+		for (const action of entry.actions ?? []) byId.set(action.id, {
+			cap,
+			action
+		});
+	}
+	return byId;
+}
+var index;
+function actionIndex() {
+	index ??= buildIndex();
+	return index;
+}
+/** The vocabulary action with this id, or `undefined`. */
+function findVocabAction(actionId) {
+	return actionIndex().get(actionId);
+}
+/**
 * `addon-pages-source` — collection cap exposing per-provider raw page
 * declarations. Every addon that contributes a UI page registers a
 * provider here. The hub-side singleton aggregator (`addon-pages` cap,
@@ -44908,21 +44973,23 @@ function convertLegacyWhen(half) {
 *    (instants) and state leaves (durations). It replaces the flat trigger list
 *    plus the separate condition tree; the firing rule is in that file and in
 *    ADR "one tree".
-*  - **Actions** — the `wait` and `cap` steps, plus the `{kind:'code'}`
+*  - **Actions** — the `wait` and device `command` steps, plus the `{kind:'code'}`
 *    fragment of §3.2.2. See {@link AutomationActionSchema}.
 *
 * A recipe stored in the old shape (`triggers` + `conditions`) still LOADS:
 * {@link AutomationRecipeSchema} (the parse-anywhere schema) converts it on parse. Nothing writes it.
 */
 /**
-* One action step: `wait`, or a `cap` call.
+* One action step: `wait`, or a device `command`.
 *
-* A cap step's target is who it acts on (D983: `devices`, a `domain`, or a
-* `{ $var }` resolved from the run's variables); the legacy `deviceId` is still
-* READ, never written. The step runner (`runSteps`) owns the device-scope
-* check, the stop-at-first-failure and the variable substitution, once, for
-* every caller — automations, Actions, and the notification centre, which runs
-* only Actions (planning#473).
+* A command step names a VOCABULARY action (`cover.open`) and who it acts on
+* (D983: `devices`, a `domain`, or a `{ $var }` resolved from the run's
+* variables). It never names a cap method: the step runner turns the action
+* id into its cap + method through the vocabulary index when the step runs
+* (`vocabCall`), the one place that mapping happens. The step runner
+* (`runSteps`) owns the device-scope check, the stop-at-first-failure and the
+* variable substitution, once, for every caller — automations, Actions, and
+* the notification centre, which runs only Actions (planning#473).
 */
 /** The longest one `wait` step lasts. It is cut by a restart of the run and does not survive a hub restart. */
 var WAIT_MAX_SECONDS = 3600;
@@ -44931,39 +44998,22 @@ var AutomationWaitStepSchema = object({
 	kind: literal("wait"),
 	seconds: number$1().min(0).max(WAIT_MAX_SECONDS, WAIT_TOO_LONG)
 });
-/** The legacy `deviceId` of a cap step: still READ, never written (D983). */
-var LegacyStepDeviceSchema = union([
-	number$1().int(),
-	array(number$1().int()).min(1),
-	object({ $var: string().min(1) })
-]);
 /**
-* The fields of a cap step, before the target rules are applied. Exported for
-* a shape that is "a cap call, narrowed" (a remote-control binding is one
-* device); a step is {@link AutomationCapStepSchema}.
+* The fields of a command step, before the vocabulary check. A step is
+* {@link AutomationCommandStepSchema}.
 */
-var AutomationCapStepBaseSchema = object({
-	kind: literal("cap"),
-	/**
-	* The vocabulary action this step performs (`cover.open`). Required when
-	* `target` is a `domain` (the domain is "every device offering this
-	* action"); filled by {@link normalizeCapStep} for a legacy step whose
-	* cap + method match exactly one vocabulary action.
-	*/
-	actionId: string().min(1).optional(),
-	/** WHO the step acts on. The only shape that is written. */
-	target: ActionTargetSchema.optional(),
+var AutomationCommandStepBaseSchema = object({
+	kind: literal("command"),
+	/** WHO the step acts on. */
+	target: ActionTargetSchema,
+	/** The vocabulary action this step performs (`cover.open`). */
+	actionId: string().min(1),
 	/**
-	* @deprecated The pre-D983 target: one device, several, or `{ $var }`.
-	* Still READ — {@link normalizeCapStep} maps it to `target` — and never
-	* written.
+	* The values of the action's OPEN args (`position`, `presetId`); the args
+	* the vocabulary bakes into the action are added when the step runs. Values
+	* may carry `{{vars.x}}` slots, or be exactly `{ $var: 'name' }`, which
+	* SUBSTITUTE and do not evaluate (§3.2.3).
 	*/
-	deviceId: LegacyStepDeviceSchema.optional(),
-	cap: string().min(1),
-	method: string().min(1),
-	/** Values may carry `{{vars.x}}` slots, or be exactly `{ $var: 'name' }`, which
-	*  SUBSTITUTE and do not evaluate (§3.2.3). Anything beyond substitution is
-	*  the expression leaf. */
 	args: record(string(), unknown()).optional(),
 	/**
 	* The unit the person picked per arg (display only). `args` always hold the
@@ -44972,18 +45022,20 @@ var AutomationCapStepBaseSchema = object({
 	*/
 	argUnits: record(string(), string().min(1)).optional()
 });
+/** The vocabulary check every command step passes: the action exists. */
+function refineKnownAction(step, ctx) {
+	if (findVocabAction(step.actionId) === void 0) ctx.addIssue({
+		code: "custom",
+		message: `"${step.actionId}" is not a vocabulary action id`,
+		path: ["actionId"]
+	});
+}
 /**
-* The steps an internal Action may contain: cap and wait, and nothing that can
+* The steps an internal Action may contain: command and wait, and nothing that can
 * call back into an Action — so an Action can never reach itself (no cycles).
 * This is the LEAF shape: no condition of its own.
 */
-var LeafActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCapStepBaseSchema.refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
-	message: "a cap step needs a target",
-	path: ["target"]
-}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
-	message: "a domain target needs the vocabulary action it applies to (actionId)",
-	path: ["actionId"]
-})]);
+var LeafActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCommandStepBaseSchema.superRefine(refineKnownAction)]);
 /**
 * The optional guard of a step (#472): `if` is the ONE `when` tree (D980), read
 * on the state mirror when the step is reached; `else` runs when it is false.
@@ -45004,13 +45056,7 @@ var GuardedWaitStepSchema = AutomationWaitStepSchema.extend(stepGuardShape).refi
 * same two step kinds an automation runs, minus a guard that reads the
 * automation's trigger, which such a list does not have.
 */
-var ActionStepSchema = discriminatedUnion("kind", [GuardedWaitStepSchema, AutomationCapStepBaseSchema.extend(stepGuardShape).refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
-	message: "a cap step needs a target",
-	path: ["target"]
-}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
-	message: "a domain target needs the vocabulary action it applies to (actionId)",
-	path: ["actionId"]
-}).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf)]).superRefine((step, ctx) => {
+var ActionStepSchema = discriminatedUnion("kind", [GuardedWaitStepSchema, AutomationCommandStepBaseSchema.extend(stepGuardShape).superRefine(refineKnownAction).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf)]).superRefine((step, ctx) => {
 	if (step.if !== void 0 && hasTriggeredByLeaves(step.if)) ctx.addIssue({
 		code: "custom",
 		message: TRIGGERED_BY_NEEDS_AUTOMATION,
@@ -45025,17 +45071,11 @@ var ActionStepSchema = discriminatedUnion("kind", [GuardedWaitStepSchema, Automa
 var continueOnErrorShape = { 
 /** A failure of this step is traced `failed-continued` and the next step runs. */
 continueOnError: literal(true).optional() };
-/** An automation's cap step: the shared guarded cap step, plus `continueOnError`. */
-var AutomationGuardedCapStepSchema = AutomationCapStepBaseSchema.extend({
+/** An automation's command step: the shared guarded command step, plus `continueOnError`. */
+var AutomationGuardedCommandStepSchema = AutomationCommandStepBaseSchema.extend({
 	...stepGuardShape,
 	...continueOnErrorShape
-}).refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
-	message: "a cap step needs a target",
-	path: ["target"]
-}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
-	message: "a domain target needs the vocabulary action it applies to (actionId)",
-	path: ["actionId"]
-}).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf);
+}).superRefine(refineKnownAction).refine((step) => step.else === void 0 || step.if !== void 0, elseNeedsIf);
 /** End the run here, on purpose. `reason` may carry `{{vars.x}}` slots. */
 var AutomationStopStepSchema = object({
 	kind: literal("stop"),
@@ -45115,13 +45155,7 @@ function nestTooDeep(issue) {
 }
 var plainStepSchemas = [
 	AutomationWaitStepSchema.strict(),
-	AutomationCapStepBaseSchema.extend(continueOnErrorShape).strict().refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
-		message: "a cap step needs a target",
-		path: ["target"]
-	}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
-		message: "a domain target needs the vocabulary action it applies to (actionId)",
-		path: ["actionId"]
-	}),
+	AutomationCommandStepBaseSchema.extend(continueOnErrorShape).strict().superRefine(refineKnownAction),
 	AutomationStopStepSchema.omit({ if: true }).strict(),
 	AutomationSetStepSchema.omit({ if: true }).strict(),
 	AutomationRunActionStepSchema.strict()
@@ -45132,7 +45166,7 @@ var plainStepSchemas = [
 */
 var AutomationBranchStepSchema = discriminatedUnion("kind", plainStepSchemas, { error: nestTooDeep });
 /** A step that can run beside others: it writes no variable and does not end the run. */
-var AutomationParallelMemberSchema = AutomationBranchStepSchema.refine((step) => step.kind === "cap" || step.kind === "action" || step.kind === "wait", "a parallel holds device commands, actions and waits only: a set or a stop beside other steps has no order");
+var AutomationParallelMemberSchema = AutomationBranchStepSchema.refine((step) => step.kind === "command" || step.kind === "action" || step.kind === "wait", "a parallel holds device commands, actions and waits only: a set or a stop beside other steps has no order");
 /**
 * Several steps at once (#500): all are started together and all are awaited.
 * A failure fails the run once the others finished, as in a sequence; a member
@@ -45212,7 +45246,7 @@ var AutomationBodyStepSchema = discriminatedUnion("kind", [
 var AutomationRepeatStepSchema = repeatSchemaOf(AutomationBodyStepSchema);
 var AutomationActionSchema = discriminatedUnion("kind", [
 	GuardedWaitStepSchema,
-	AutomationGuardedCapStepSchema,
+	AutomationGuardedCommandStepSchema,
 	AutomationStopStepSchema,
 	AutomationSetStepSchema,
 	chooseSchemaOf(AutomationBodyStepSchema),
@@ -45283,110 +45317,6 @@ function convertLegacyRecipe(legacy) {
 	};
 }
 var AutomationRecipeSchema = union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
-var DETECTION_DESCRIPTIONS = {
-	deviceId: "the camera that saw it",
-	className: "what it saw",
-	trackId: "the track",
-	score: "how sure the detector was",
-	label: "the label it matched (a name, a plate), empty when none"
-};
-var STATIONARY_DESCRIPTIONS = {
-	deviceId: "the camera that saw it",
-	className: "what it saw",
-	zones: "the zones it is in",
-	phase: "appeared or departed",
-	entryId: "the stopped object"
-};
-var BECOMES_DESCRIPTIONS = {
-	deviceId: "the device that changed",
-	from: "the value before the change, empty when it is not known",
-	to: "the value it changed to"
-};
-/**
-* A fire's payload is offered too, as `data.<path>` (`{{vars.data.channel}}`):
-* those names depend on the device, so they are not in this list.
-*/
-var FIRED_DESCRIPTIONS = {
-	deviceId: "the device that fired",
-	eventType: "the event, as the device names it",
-	sourceId: "the part of the device that fired (a button), empty when it names none",
-	eventKind: "the kind of press (press, long-press …), empty when the device declares none"
-};
-function describe$1(descriptions) {
-	return Object.entries(descriptions).map(([name, description]) => ({
-		name,
-		description
-	}));
-}
-describe$1(DETECTION_DESCRIPTIONS);
-describe$1(STATIONARY_DESCRIPTIONS);
-describe$1(FIRED_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
-	...v,
-	hintKey: "firedDeviceId"
-} : v);
-describe$1(BECOMES_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
-	...v,
-	hintKey: "becomesDeviceId"
-} : v);
-new Set(Object.values(COCO_TO_MACRO.mapping));
-/**
-* Generic stateless event emitter. Installed on a `DeviceType.EventEmitter`
-* device. Carries the device's EXACT declared event vocabulary verbatim
-* (NO normalization). Two shapes:
-*  - structured source (HA `event.*` entity) → `vocabulary` is the fixed
-*    declared set (e.g. press_short, press_long, …).
-*  - generic/legacy source (HA bus events, e.g. zha_event) → `vocabulary`
-*    is [] (open) and `lastEvent.data` carries the complex payload.
-* `vocabulary` (D1044) names each event for a person and types it for a
-* rule; `eventTypes` is its list of native tokens, kept for older readers.
-* A fire names the part of the device it came from in `sourceId` when the
-* vocabulary declares sources (a remote's buttons).
-* `seq` is monotonic so two identical events still produce distinct slice writes.
-*/
-var EventFireSchema = object({
-	deviceId: number$1(),
-	eventType: string(),
-	sourceId: string().optional(),
-	data: record(string(), unknown()).nullable(),
-	timestamp: number$1().meta(readingMeta("none")),
-	seq: number$1().meta(readingMeta("count"))
-});
-var EventEmitterStatusSchema = object({
-	eventTypes: array(string()),
-	/**
-	* Required of a provider by the type. A status written before the field
-	* existed still parses, as an empty vocabulary: read it through
-	* `readEventVocabulary`, which then answers with the plain tokens.
-	*/
-	vocabulary: array(EventVocabularyEntrySchema).default([]),
-	lastEvent: EventFireSchema.nullable(),
-	eventCountSinceStart: number$1().meta(readingMeta("count"))
-});
-var eventEmitterCapability = {
-	name: "event-emitter",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.EventEmitter],
-	methods: {},
-	events: { onEvent: { data: EventFireSchema } },
-	status: {
-		schema: EventEmitterStatusSchema,
-		kind: "push"
-	},
-	runtimeState: EventEmitterStatusSchema,
-	/**
-	* Runtime-state durability: **session** — `eventCountSinceStart` names its own scope.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	/**
-	* History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
-	*/
-	history: "none"
-};
 /**
 * Schedulers (D983) — an entity that performs actions over the day.
 *
@@ -45785,6 +45715,110 @@ var AutomationStateDocSchema = object({
 	lastRunStartedAt: number$1().nullable(),
 	traces: array(AutomationRunTraceSchema)
 });
+var DETECTION_DESCRIPTIONS = {
+	deviceId: "the camera that saw it",
+	className: "what it saw",
+	trackId: "the track",
+	score: "how sure the detector was",
+	label: "the label it matched (a name, a plate), empty when none"
+};
+var STATIONARY_DESCRIPTIONS = {
+	deviceId: "the camera that saw it",
+	className: "what it saw",
+	zones: "the zones it is in",
+	phase: "appeared or departed",
+	entryId: "the stopped object"
+};
+var BECOMES_DESCRIPTIONS = {
+	deviceId: "the device that changed",
+	from: "the value before the change, empty when it is not known",
+	to: "the value it changed to"
+};
+/**
+* A fire's payload is offered too, as `data.<path>` (`{{vars.data.channel}}`):
+* those names depend on the device, so they are not in this list.
+*/
+var FIRED_DESCRIPTIONS = {
+	deviceId: "the device that fired",
+	eventType: "the event, as the device names it",
+	sourceId: "the part of the device that fired (a button), empty when it names none",
+	eventKind: "the kind of press (press, long-press …), empty when the device declares none"
+};
+function describe$1(descriptions) {
+	return Object.entries(descriptions).map(([name, description]) => ({
+		name,
+		description
+	}));
+}
+describe$1(DETECTION_DESCRIPTIONS);
+describe$1(STATIONARY_DESCRIPTIONS);
+describe$1(FIRED_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
+	...v,
+	hintKey: "firedDeviceId"
+} : v);
+describe$1(BECOMES_DESCRIPTIONS).map((v) => v.name === "deviceId" ? {
+	...v,
+	hintKey: "becomesDeviceId"
+} : v);
+new Set(Object.values(COCO_TO_MACRO.mapping));
+/**
+* Generic stateless event emitter. Installed on a `DeviceType.EventEmitter`
+* device. Carries the device's EXACT declared event vocabulary verbatim
+* (NO normalization). Two shapes:
+*  - structured source (HA `event.*` entity) → `vocabulary` is the fixed
+*    declared set (e.g. press_short, press_long, …).
+*  - generic/legacy source (HA bus events, e.g. zha_event) → `vocabulary`
+*    is [] (open) and `lastEvent.data` carries the complex payload.
+* `vocabulary` (D1044) names each event for a person and types it for a
+* rule; `eventTypes` is its list of native tokens, kept for older readers.
+* A fire names the part of the device it came from in `sourceId` when the
+* vocabulary declares sources (a remote's buttons).
+* `seq` is monotonic so two identical events still produce distinct slice writes.
+*/
+var EventFireSchema = object({
+	deviceId: number$1(),
+	eventType: string(),
+	sourceId: string().optional(),
+	data: record(string(), unknown()).nullable(),
+	timestamp: number$1().meta(readingMeta("none")),
+	seq: number$1().meta(readingMeta("count"))
+});
+var EventEmitterStatusSchema = object({
+	eventTypes: array(string()),
+	/**
+	* Required of a provider by the type. A status written before the field
+	* existed still parses, as an empty vocabulary: read it through
+	* `readEventVocabulary`, which then answers with the plain tokens.
+	*/
+	vocabulary: array(EventVocabularyEntrySchema).default([]),
+	lastEvent: EventFireSchema.nullable(),
+	eventCountSinceStart: number$1().meta(readingMeta("count"))
+});
+var eventEmitterCapability = {
+	name: "event-emitter",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.EventEmitter],
+	methods: {},
+	events: { onEvent: { data: EventFireSchema } },
+	status: {
+		schema: EventEmitterStatusSchema,
+		kind: "push"
+	},
+	runtimeState: EventEmitterStatusSchema,
+	/**
+	* Runtime-state durability: **session** — `eventCountSinceStart` names its own scope.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	/**
+	* History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
+	*/
+	history: "none"
+};
 /**
 * Actions — named, runnable things an operator (or an automation) can start,
 * declared as LIST ENTRIES, never as devices.
@@ -45964,6 +45998,177 @@ var UnitWarningSchema = object({
 	assumedUnit: string(),
 	message: string()
 });
+/**
+* `device-export` — collection cap for addons that export camstack
+* devices to external ecosystems (HomeAssistant via MQTT discovery,
+* HomeKit/HAP, Alexa Smart Home, …).
+*
+* No `ecosystem` enum — the addon id identifies the export target.
+* Each addon owns its mapping logic in its own settings UI. The cap
+* exposes only the COMMON surface: link state, supported device
+* kinds (so the UI can filter the device picker), and per-device
+* expose/unexpose.
+*
+* INSTANCES. One export addon can serve several independent targets (a
+* HomeKit bridge, a Home Assistant broker). `listInstances` names them.
+* `instanceId` on a READ is optional: absent = the whole addon (linked if any
+* enabled instance is, `exposedDeviceCount` = distinct devices, `setup` = the
+* default instance's); present = that instance; an id the provider does not
+* serve is refused with `ExportInstanceUnknownError` (`export-instance-unknown`),
+* never answered empty. `instanceId` on a WRITE is REQUIRED: a membership
+* change always names the target it changes. A single-instance provider
+* accepts an absent id on a read or its own id, and refuses any other.
+*/
+/** Which instance of an export addon a call addresses. Absent on a read = the whole addon. */
+var InstanceIdSchema$1 = string().min(1);
+var InstancePinSchema = object({ instanceId: InstanceIdSchema$1.optional() });
+/** One independent export target of an addon. */
+var ExportInstanceSchema = object({
+	instanceId: InstanceIdSchema$1,
+	name: string(),
+	enabled: boolean(),
+	kind: string().optional(),
+	/**
+	* What this instance's platform accepts as a device name, in one operator-facing sentence
+	* (D1049). The derived "Name on <instance>" field shows it; absent = the field says nothing
+	* about the rule.
+	*/
+	nameRule: string().optional()
+});
+var LinkStateSchema = _enum([
+	"unlinked",
+	"linked",
+	"error"
+]);
+/**
+* A single label/value row surfaced in the export panel's "Setup"
+* section. Rendered with a copy-to-clipboard button. `secret: true`
+* rows are masked by default with a reveal toggle (client ids,
+* secrets, …).
+*/
+var ExportSetupFieldSchema = object({
+	label: string(),
+	value: string(),
+	/** Mask the value by default + render a reveal toggle (client id, secrets). */
+	secret: boolean().optional()
+});
+/**
+* Generic, addon-agnostic pairing/account block. Any export addon can
+* surface a scannable QR, a set of copyable label/value rows, and a
+* free-form operator note — the `DeviceExportPanel` renders whatever
+* the provider supplies and skips the section entirely when `setup`
+* is unset.
+*/
+var ExportSetupSchema = object({
+	/** A string to render as a scannable QR — HAP `X-HM://…` URI, a pairing URL, etc. Omitted when there's nothing to scan. */
+	qr: string().optional(),
+	/** Label/value rows shown with a copy button (HAP setup code, OAuth URLs, client id, linked-account count, …). */
+	fields: array(ExportSetupFieldSchema).readonly().optional(),
+	/** Free-form operator instructions rendered above the fields. */
+	note: string().optional()
+});
+var DeviceExportStatusSchema = object({
+	linkState: LinkStateSchema,
+	exposedDeviceCount: number$1(),
+	error: string().optional(),
+	/**
+	* Optional pairing/account info the panel renders in a generic
+	* "Setup" section. Addon-agnostic — the addon id identifies the
+	* export target, never an `ecosystem` key here.
+	*/
+	setup: ExportSetupSchema.optional()
+});
+var DeviceKindSchema = string();
+/**
+* EXPOSED NAME. What one instance calls a device on its platform, when it should not be the
+* device's own name. The exporter owns it: it is stored per instance in the exporter's per-device
+* store (D865), validated by the exporter against its platform's naming rules, and never reaches
+* the exported id — a rename updates the SAME device on the platform, never a second one.
+* Blank or `null` = the device's own name. A name the platform would refuse is refused with
+* `ExportNameRefusedError` (`export-name-refused`), whose message says why.
+*/
+var ExposedDeviceSchema = object({
+	deviceId: string(),
+	exposedAs: string().optional(),
+	/** The operator's name for this device on this instance; absent = the device's own name. */
+	exposedName: string().optional(),
+	capabilities: array(string()).optional()
+});
+var ExposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	deviceId: string(),
+	capabilities: array(string()).optional(),
+	/** Set the exposed name in the same call; absent = leave it as it is, blank/null = clear it. */
+	exposedName: string().nullable().optional()
+});
+var SetExposedNameInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	deviceId: string(),
+	/** Blank or null = the device's own name. */
+	name: string().nullable(),
+	/**
+	* Validate only: refuse exactly as a real call would, write nothing. A caller saving several
+	* names at once checks every one first, so one refusal writes none (D1049).
+	*/
+	dryRun: boolean().optional()
+});
+var UnexposeInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	deviceId: string()
+});
+/**
+* What an exporter may expose besides devices (D968). An action and a
+* notification target are LIST ENTRIES, never devices (D954): they enter an
+* exporter's own selection, not the device registry.
+*/
+var ExportEntityKindSchema = _enum([
+	"device",
+	"action",
+	"notifier"
+]);
+var ExportEntityRefSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("device"),
+		deviceId: string()
+	}),
+	object({
+		kind: literal("action"),
+		actionId: string().min(1)
+	}),
+	object({
+		kind: literal("notifier"),
+		targetId: string().min(1)
+	})
+]);
+var ExposedEntitySchema = object({
+	entity: ExportEntityRefSchema,
+	exposedAs: string().optional()
+});
+var ExposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+var UnexposeEntityInputSchema = object({
+	instanceId: InstanceIdSchema$1,
+	entity: ExportEntityRefSchema
+});
+method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(ExportInstanceSchema)), method(InstancePinSchema, array(DeviceKindSchema)), method(InstancePinSchema, array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(UnexposeInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(SetExposedNameInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(InstancePinSchema, array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), optionalMethod(UnexposeEntityInputSchema, _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+record(string(), string());
 _enum([
 	"automation",
 	"action",
@@ -51167,11 +51372,13 @@ var IrCodecError = class extends Error {
 		this.code = code;
 	}
 };
+/** Maximum number of mark/space entries one pulse train may carry. */
+var IR_TIMINGS_MAX = 1024;
 /**
 * A pulse train in signed microseconds: mark (+) first, then space (-), strictly
 * alternating, no zeros, 2..1024 entries.
 */
-var IrTimingsSchema = array(number$1().int()).min(2).max(1024).superRefine((timings, ctx) => {
+var IrTimingsSchema = array(number$1().int()).min(2).max(IR_TIMINGS_MAX).superRefine((timings, ctx) => {
 	timings.forEach((value, index) => {
 		const expectMark = index % 2 === 0;
 		if (value === 0 || value > 0 !== expectMark) ctx.addIssue({
@@ -51218,15 +51425,186 @@ function decodePronto(code) {
 		carrierHz: Math.round(1e6 / unitUs)
 	};
 }
-/** What a remote command stores: a raw pulse train, or a learned Pronto code. */
-var IrPayloadSchema = discriminatedUnion("kind", [object({
-	kind: literal("raw"),
-	timings: array(number$1().int()),
-	settings: TransmitSettingsSchema.optional()
-}), object({
-	kind: literal("pronto"),
-	code: string()
-})]);
+/**
+* FastLZ level 1: a byte-oriented LZ77 stream. A control byte below 32 starts a
+* literal run of `ctrl + 1` bytes; otherwise it is a back-reference whose length
+* is `ctrl >> 5` (extended by one byte when 7) and whose distance is split
+* between the low 5 bits and the next byte.
+*/
+var MAX_DISTANCE = 8192;
+var MAX_LITERAL_RUN = 32;
+var MIN_MATCH = 3;
+var MAX_MATCH = 264;
+/**
+* Most bytes a decoded IR code may hold: two bytes per timing. A level-1 stream
+* can expand ~130x, so the decoder checks this bound before every write.
+*/
+var IR_DECOMPRESSED_MAX = IR_TIMINGS_MAX * 2;
+function fastlzDecompress(input) {
+	const out = [];
+	let ip = 0;
+	const room = (count) => {
+		if (out.length + count > IR_DECOMPRESSED_MAX) throw new IrCodecError("tuya-malformed", "decompressed code is larger than any IR train");
+	};
+	const next = () => {
+		const byte = input[ip++];
+		if (byte === void 0) throw new IrCodecError("tuya-malformed", "compressed stream is truncated");
+		return byte;
+	};
+	while (ip < input.length) {
+		const ctrl = next();
+		if (ctrl < 32) {
+			room(ctrl + 1);
+			for (let i = 0; i <= ctrl; i++) out.push(next());
+			continue;
+		}
+		let len = (ctrl >> 5) - 1;
+		if (len === 6) len += next();
+		const distance = ((ctrl & 31) << 8) + next() + 1;
+		const start = out.length - distance;
+		if (start < 0) throw new IrCodecError("tuya-malformed", "back-reference points before the stream");
+		room(len + 3);
+		for (let i = 0; i < len + 3; i++) {
+			const byte = out[start + i];
+			if (byte === void 0) throw new IrCodecError("tuya-malformed", "back-reference is invalid");
+			out.push(byte);
+		}
+	}
+	return Uint8Array.from(out);
+}
+function fastlzCompress(input) {
+	const out = [];
+	const lastSeen = /* @__PURE__ */ new Map();
+	let literalStart = 0;
+	const flushLiterals = (end) => {
+		for (let from = literalStart; from < end; from += MAX_LITERAL_RUN) {
+			const to = Math.min(from + MAX_LITERAL_RUN, end);
+			out.push(to - from - 1);
+			for (let i = from; i < to; i++) out.push(input[i] ?? 0);
+		}
+	};
+	let pos = 0;
+	while (pos < input.length) {
+		let matchLen = 0;
+		let matchDistance = 0;
+		if (pos + MIN_MATCH <= input.length) {
+			const key = (input[pos] ?? 0) << 16 | (input[pos + 1] ?? 0) << 8 | (input[pos + 2] ?? 0);
+			const candidate = lastSeen.get(key);
+			lastSeen.set(key, pos);
+			if (candidate !== void 0 && pos - candidate <= MAX_DISTANCE) {
+				let len = 0;
+				while (pos + len < input.length && len < MAX_MATCH && input[candidate + len] === input[pos + len]) len++;
+				if (len >= MIN_MATCH) {
+					matchLen = len;
+					matchDistance = pos - candidate - 1;
+				}
+			}
+		}
+		if (matchLen === 0) {
+			pos++;
+			continue;
+		}
+		flushLiterals(pos);
+		const enc = matchLen - 2;
+		if (enc < 7) out.push(enc << 5 | matchDistance >> 8);
+		else out.push(224 | matchDistance >> 8, enc - 7);
+		out.push(matchDistance & 255);
+		pos += matchLen;
+		literalStart = pos;
+	}
+	flushLiterals(input.length);
+	return Uint8Array.from(out);
+}
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var MAX_DURATION_US = 65535;
+function toBase64(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const a = bytes[i] ?? 0;
+		const b = bytes[i + 1] ?? 0;
+		const c = bytes[i + 2] ?? 0;
+		const word = a << 16 | b << 8 | c;
+		out += ALPHABET[word >> 18 & 63];
+		out += ALPHABET[word >> 12 & 63];
+		out += i + 1 < bytes.length ? ALPHABET[word >> 6 & 63] : "=";
+		out += i + 2 < bytes.length ? ALPHABET[word & 63] : "=";
+	}
+	return out;
+}
+function fromBase64(text) {
+	const clean = text.trim().replace(/=+$/, "");
+	if (clean.length === 0 || clean.length % 4 === 1) throw new IrCodecError("tuya-malformed", "not a base64 string");
+	const out = [];
+	let bits = 0;
+	let acc = 0;
+	for (const ch of clean) {
+		const value = ALPHABET.indexOf(ch);
+		if (value < 0) throw new IrCodecError("tuya-malformed", "not a base64 string");
+		acc = acc << 6 | value;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out.push(acc >> bits & 255);
+		}
+	}
+	return Uint8Array.from(out);
+}
+/** Signed pulse train to a Tuya IR code: base64(FastLZ(uint16 LE durations)). */
+function encodeTuya(timings) {
+	const bytes = new Uint8Array(timings.length * 2);
+	timings.forEach((value, index) => {
+		const duration = Math.abs(value);
+		if (duration === 0 || duration > MAX_DURATION_US) throw new IrCodecError("invalid-timings", `timing ${index} does not fit 16 bits`);
+		bytes[index * 2] = duration & 255;
+		bytes[index * 2 + 1] = duration >> 8;
+	});
+	return toBase64(fastlzCompress(bytes));
+}
+/** A Tuya IR code to a signed pulse train (mark first). Throws `IrCodecError`. */
+function decodeTuya(code) {
+	const bytes = fastlzDecompress(fromBase64(code));
+	if (bytes.length === 0 || bytes.length % 2 !== 0) throw new IrCodecError("tuya-malformed", "payload is not a list of 16-bit durations");
+	const timings = [];
+	for (let i = 0; i < bytes.length; i += 2) {
+		const duration = (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8;
+		timings.push(i / 2 % 2 === 0 ? duration : -duration);
+	}
+	const checked = IrTimingsSchema.safeParse(timings);
+	if (!checked.success) throw new IrCodecError("tuya-malformed", checked.error.message);
+	return checked.data;
+}
+/** Device-native IR code formats a transmitter can replay verbatim. */
+var IrNativeFormatSchema = _enum(["tuya"]);
+/**
+* Longest native code accepted: base64 of the worst-case compressed stream
+* (every decoded byte as a literal, plus one control byte per 32), with margin.
+*/
+var IR_NATIVE_CODE_MAX_CHARS = Math.ceil((IR_DECOMPRESSED_MAX + Math.ceil(IR_DECOMPRESSED_MAX / 32)) / 3) * 4 + 256;
+var IrNativeCodeSchema = object({
+	format: IrNativeFormatSchema,
+	code: string().min(1).max(IR_NATIVE_CODE_MAX_CHARS)
+});
+var IR_NATIVE_CODECS = { tuya: {
+	encode: encodeTuya,
+	decode: decodeTuya
+} };
+/** What a remote command stores: a raw pulse train, a learned Pronto code, or a device-native code. */
+var IrPayloadSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("raw"),
+		timings: array(number$1().int()),
+		settings: TransmitSettingsSchema.optional()
+	}),
+	object({
+		kind: literal("pronto"),
+		code: string()
+	}),
+	object({
+		kind: literal("native"),
+		format: IrNativeFormatSchema,
+		code: string()
+	})
+]);
 /** Resolve a payload to what `ir-transmitter.send` takes. Throws `IrCodecError`. */
 function toTimings(payload) {
 	if (payload.kind === "pronto") {
@@ -51236,6 +51614,10 @@ function toTimings(payload) {
 			settings: { carrierHz: decoded.carrierHz }
 		};
 	}
+	if (payload.kind === "native") return {
+		timings: IR_NATIVE_CODECS[payload.format].decode(payload.code),
+		settings: {}
+	};
 	const checked = IrTimingsSchema.safeParse(payload.timings);
 	if (!checked.success) throw new IrCodecError("invalid-timings", checked.error.message);
 	return {
@@ -53568,144 +53950,6 @@ method(object({
 	kind: "mutation",
 	auth: "admin"
 });
-/**
-* `device-export` — collection cap for addons that export camstack
-* devices to external ecosystems (HomeAssistant via MQTT discovery,
-* HomeKit/HAP, Alexa Smart Home, …).
-*
-* No `ecosystem` enum — the addon id identifies the export target.
-* Each addon owns its mapping logic in its own settings UI. The cap
-* exposes only the COMMON surface: link state, supported device
-* kinds (so the UI can filter the device picker), and per-device
-* expose/unexpose.
-*
-* INSTANCES. One export addon can serve several independent targets (a
-* HomeKit bridge, a Home Assistant broker). `listInstances` names them.
-* `instanceId` on a READ is optional: absent = the whole addon (linked if any
-* enabled instance is, `exposedDeviceCount` = distinct devices, `setup` = the
-* default instance's); present = that instance; an id the provider does not
-* serve is refused with `ExportInstanceUnknownError` (`export-instance-unknown`),
-* never answered empty. `instanceId` on a WRITE is REQUIRED: a membership
-* change always names the target it changes. A single-instance provider
-* accepts an absent id on a read or its own id, and refuses any other.
-*/
-/** Which instance of an export addon a call addresses. Absent on a read = the whole addon. */
-var InstanceIdSchema$1 = string().min(1);
-var InstancePinSchema = object({ instanceId: InstanceIdSchema$1.optional() });
-/** One independent export target of an addon. */
-var ExportInstanceSchema = object({
-	instanceId: InstanceIdSchema$1,
-	name: string(),
-	enabled: boolean(),
-	kind: string().optional()
-});
-var LinkStateSchema = _enum([
-	"unlinked",
-	"linked",
-	"error"
-]);
-/**
-* A single label/value row surfaced in the export panel's "Setup"
-* section. Rendered with a copy-to-clipboard button. `secret: true`
-* rows are masked by default with a reveal toggle (client ids,
-* secrets, …).
-*/
-var ExportSetupFieldSchema = object({
-	label: string(),
-	value: string(),
-	/** Mask the value by default + render a reveal toggle (client id, secrets). */
-	secret: boolean().optional()
-});
-/**
-* Generic, addon-agnostic pairing/account block. Any export addon can
-* surface a scannable QR, a set of copyable label/value rows, and a
-* free-form operator note — the `DeviceExportPanel` renders whatever
-* the provider supplies and skips the section entirely when `setup`
-* is unset.
-*/
-var ExportSetupSchema = object({
-	/** A string to render as a scannable QR — HAP `X-HM://…` URI, a pairing URL, etc. Omitted when there's nothing to scan. */
-	qr: string().optional(),
-	/** Label/value rows shown with a copy button (HAP setup code, OAuth URLs, client id, linked-account count, …). */
-	fields: array(ExportSetupFieldSchema).readonly().optional(),
-	/** Free-form operator instructions rendered above the fields. */
-	note: string().optional()
-});
-var DeviceExportStatusSchema = object({
-	linkState: LinkStateSchema,
-	exposedDeviceCount: number$1(),
-	error: string().optional(),
-	/**
-	* Optional pairing/account info the panel renders in a generic
-	* "Setup" section. Addon-agnostic — the addon id identifies the
-	* export target, never an `ecosystem` key here.
-	*/
-	setup: ExportSetupSchema.optional()
-});
-var DeviceKindSchema = string();
-var ExposedDeviceSchema = object({
-	deviceId: string(),
-	exposedAs: string().optional(),
-	capabilities: array(string()).optional()
-});
-var ExposeInputSchema = object({
-	instanceId: InstanceIdSchema$1,
-	deviceId: string(),
-	capabilities: array(string()).optional()
-});
-var UnexposeInputSchema = object({
-	instanceId: InstanceIdSchema$1,
-	deviceId: string()
-});
-/**
-* What an exporter may expose besides devices (D968). An action and a
-* notification target are LIST ENTRIES, never devices (D954): they enter an
-* exporter's own selection, not the device registry.
-*/
-var ExportEntityKindSchema = _enum([
-	"device",
-	"action",
-	"notifier"
-]);
-var ExportEntityRefSchema = discriminatedUnion("kind", [
-	object({
-		kind: literal("device"),
-		deviceId: string()
-	}),
-	object({
-		kind: literal("action"),
-		actionId: string().min(1)
-	}),
-	object({
-		kind: literal("notifier"),
-		targetId: string().min(1)
-	})
-]);
-var ExposedEntitySchema = object({
-	entity: ExportEntityRefSchema,
-	exposedAs: string().optional()
-});
-var ExposeEntityInputSchema = object({
-	instanceId: InstanceIdSchema$1,
-	entity: ExportEntityRefSchema
-});
-var UnexposeEntityInputSchema = object({
-	instanceId: InstanceIdSchema$1,
-	entity: ExportEntityRefSchema
-});
-method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(ExportInstanceSchema)), method(InstancePinSchema, array(DeviceKindSchema)), method(InstancePinSchema, array(ExposedDeviceSchema)), method(ExposeInputSchema, _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(UnexposeInputSchema, _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), optionalMethod(_void(), array(ExportEntityKindSchema)), optionalMethod(InstancePinSchema, array(ExposedEntitySchema)), optionalMethod(ExposeEntityInputSchema, _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), optionalMethod(UnexposeEntityInputSchema, _void(), {
-	kind: "mutation",
-	auth: "admin"
-});
 var DeviceAliasSchema = string().max(64).regex(/^[a-z][a-z0-9_]*$/);
 var DeviceTemplateSchema = string().min(1).max(4096);
 /** One value a caller hands the renderer for `thisDevice`. */
@@ -58560,6 +58804,128 @@ var StateLookSchema = object({
 	background: _enum(HERO_BACKGROUNDS),
 	animation: HeroAnimationSchema
 });
+/** A string in both languages, as the cap vocabulary writes it (D920): no `t()` in the model. */
+var HeroTextSchema = object({
+	en: string(),
+	it: string()
+});
+/**
+* The ONE measurement a simple sensor shows (card wave, phase 1).
+*
+* A sensor that measures a single quantity (a temperature, a humidity, a power,
+* a contact, a text state) is drawn as that reading, once, big, inside a scene
+* whose motion says what the number means: heat rising when hot, flakes when
+* cold, a wire flowing at the speed of the power, a ring while a window is
+* open. Everything the card draws is decided here; a client only paints it.
+*/
+var HERO_MEASUREMENT_QUANTITIES = [
+	"temperature",
+	"humidity",
+	"power",
+	"contact",
+	"text"
+];
+/** How a temperature reads to a person; drives the heat or the cold scene. */
+var HERO_MEASUREMENT_BANDS = [
+	"hot",
+	"mild",
+	"cold"
+];
+/** `updated` = the value was last read then ("2 min ago"); `changed` = it has held since then ("for 12 min"). */
+var HERO_MEASUREMENT_SINCE_KINDS = ["updated", "changed"];
+var HeroMeasurementReadingSchema = object({
+	value: number$1(),
+	quantity: ReadingQuantitySchema
+});
+var HeroMeasurementSchema = object({
+	quantity: _enum(HERO_MEASUREMENT_QUANTITIES),
+	reading: HeroMeasurementReadingSchema.nullable(),
+	icon: IconKeySchema.nullable(),
+	value: HeroTextSchema,
+	unit: string().nullable(),
+	band: _enum(HERO_MEASUREMENT_BANDS).nullable(),
+	level: number$1().min(0).max(1).nullable(),
+	word: HeroTextSchema,
+	tone: _enum(HERO_TONES),
+	since: number$1().nullable(),
+	sinceKind: _enum(HERO_MEASUREMENT_SINCE_KINDS),
+	historyKey: string().nullable()
+});
+var same$2 = (text) => t(text, text);
+var clamp01$1 = (n) => Math.min(1, Math.max(0, n));
+var trimmed = (n, digits) => String(Number(n.toFixed(digits)));
+function temperatureBand(celsius) {
+	if (celsius < 12) return "cold";
+	if (celsius > 28) return "hot";
+	return "mild";
+}
+var BAND_WORD = {
+	hot: t("Hot", "Caldo"),
+	mild: t("Normal", "Normale"),
+	cold: t("Cold", "Freddo")
+};
+var BAND_TONE = {
+	hot: "warning",
+	mild: "muted",
+	cold: "info"
+};
+function temperatureMeasurement(celsius, since) {
+	const band = temperatureBand(celsius);
+	return {
+		quantity: "temperature",
+		reading: {
+			value: celsius,
+			quantity: "temperature"
+		},
+		icon: "thermometer",
+		value: same$2(trimmed(celsius, 1)),
+		unit: "°C",
+		band,
+		level: null,
+		word: BAND_WORD[band],
+		tone: BAND_TONE[band],
+		since,
+		sinceKind: "updated",
+		historyKey: "cap:temperature-sensor.temperature"
+	};
+}
+function humidityMeasurement(percent, since) {
+	const dry = percent < 30;
+	const humid = percent > 70;
+	return {
+		quantity: "humidity",
+		reading: {
+			value: percent,
+			quantity: "humidity"
+		},
+		icon: "droplets",
+		value: same$2(String(Math.round(percent))),
+		unit: "%",
+		band: null,
+		level: clamp01$1(percent / 100),
+		word: dry ? t("Dry", "Secco") : humid ? t("Humid", "Umido") : t("Normal", "Normale"),
+		tone: dry || humid ? "warning" : "info",
+		since,
+		sinceKind: "updated",
+		historyKey: "cap:humidity-sensor.humidity"
+	};
+}
+function textMeasurement(text, since) {
+	return {
+		quantity: "text",
+		reading: null,
+		icon: null,
+		value: same$2(text),
+		unit: null,
+		band: null,
+		level: null,
+		word: t("Changed", "Cambiato"),
+		tone: "muted",
+		since,
+		sinceKind: "updated",
+		historyKey: null
+	};
+}
 /** The scene as the model carries it. `null` = the device did not say (never a guess). */
 var HeroSceneSchema = object({
 	id: _enum([
@@ -58611,11 +58977,6 @@ var HeroSceneSchema = object({
 });
 DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
 DeviceRole.Siren, DeviceRole.Floodlight, DeviceRole.Spotlight, DeviceRole.PirSensor, DeviceRole.Chime, DeviceRole.Autotrack, DeviceRole.Nightvision, DeviceRole.PrivacyMask, DeviceRole.Doorbell, DeviceRole.CoverBlind, DeviceRole.CoverShutter, DeviceRole.CoverAwning, DeviceRole.CoverCurtain, DeviceRole.CoverGarage, DeviceRole.CoverGate, DeviceRole.CoverDoor, DeviceRole.CoverWindow, DeviceRole.BinaryHelper, DeviceRole.Outlet, DeviceRole.SwitchHeater, DeviceRole.SwitchFan, DeviceRole.ClimateAc, DeviceRole.ClimateThermostat, DeviceRole.ClimateFloor, DeviceRole.ClimateRadiator, DeviceRole.ClimateHeater, DeviceRole.ClimateHeatPumpCircuit, DeviceRole.MotionSensor, DeviceRole.ContactSensor, DeviceRole.LeakSensor, DeviceRole.SmokeSensor, DeviceRole.COSensor, DeviceRole.GasSensor, DeviceRole.TamperSensor, DeviceRole.VibrationSensor, DeviceRole.ConnectivitySensor, DeviceRole.SoundSensor, DeviceRole.BinarySensor, DeviceRole.TemperatureSensor, DeviceRole.HumiditySensor, DeviceRole.AmbientLightSensor, DeviceRole.PressureSensor, DeviceRole.WindSensor, DeviceRole.RainSensor, DeviceRole.UvSensor, DeviceRole.SolarRadiationSensor, DeviceRole.SoilMoistureSensor, DeviceRole.PowerSensor, DeviceRole.EnergySensor, DeviceRole.VoltageSensor, DeviceRole.CurrentSensor, DeviceRole.AirQualitySensor, DeviceRole.BatterySensor, DeviceRole.NumericSensor, DeviceRole.EnumSensor, DeviceRole.DateTimeSensor, DeviceRole.GenericSensor, DeviceRole.NumericControl, DeviceRole.SelectControl, DeviceRole.TextControl, DeviceRole.DateTimeControl, DeviceRole.MobilePushNotifier, DeviceRole.MessagingNotifier, DeviceRole.EmailNotifier, DeviceRole.GenericNotifier, DeviceRole.IrTransmitter;
-/** A string in both languages, as the cap vocabulary writes it (D920): no `t()` in the model. */
-var HeroTextSchema = object({
-	en: string(),
-	it: string()
-});
 var HeroRowIdSchema = _enum([
 	"progress",
 	"run-for",
@@ -58721,6 +59082,25 @@ var HeroControlSchema = discriminatedUnion("kind", [
 		optionLabels: record(string(), HeroTextSchema).optional(),
 		call: HeroCallSchema,
 		valueArg: string()
+	}),
+	object({
+		kind: literal("number"),
+		id: string(),
+		label: HeroTextSchema,
+		value: number$1().nullable(),
+		/** `null` = any number; the device rounds what it does not accept. */
+		step: number$1().nullable(),
+		unit: string(),
+		call: HeroCallSchema,
+		valueArg: string()
+	}),
+	object({
+		kind: literal("text"),
+		id: string(),
+		label: HeroTextSchema,
+		value: string().nullable(),
+		call: HeroCallSchema,
+		valueArg: string()
 	})
 ]);
 /** Declared by its interface: a `z.infer` of one more icon union pushes the cap's inferred type past what the compiler can print. */
@@ -58922,6 +59302,11 @@ var HeroModelSchema = object({
 	timedRun: HeroTimedRunSlotSchema.nullable(),
 	powerSupply: HeroPowerSupplySlotSchema.nullable(),
 	rows: array(HeroRowSchema),
+	/**
+	* The ONE measurement of a simple sensor, drawn once inside the scene in place of
+	* the caption, tiles and value chips. Absent = the card draws as before.
+	*/
+	measurement: HeroMeasurementSchema.optional(),
 	/** Ids of parts that actuate the device, hidden from a session that may not act on it. */
 	gated: array(string()),
 	provenance: array(HeroProvenanceSchema)
@@ -58993,8 +59378,23 @@ var HeroRowModelSchema = object({
 	* the call. Absent or empty = `primary` alone.
 	*/
 	extras: array(HeroControlSchema).max(2).optional(),
-	trailing: HeroFactSchema.nullable()
+	trailing: HeroFactSchema.nullable(),
+	/**
+	* The simple sensor's one reading (the hero's `measurement`): the row draws its value
+	* at the right, the unit small, the quantity's icon in the mini-scene. Absent = an
+	* older server or a device that is not a simple sensor: draw `trailing`.
+	*/
+	measurement: HeroMeasurementSchema.optional()
 });
+new Set([
+	"temperature",
+	"humidity",
+	"pressure",
+	"illuminance",
+	"reading",
+	"air-quality",
+	"valve"
+]);
 DeviceType.Climate;
 DeviceType.Climate, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer;
 /**
@@ -60083,13 +60483,32 @@ var IrSendResultSchema = object({
 var IrTransmitterInfoSchema = object({
 	media: array(IrMediumSchema),
 	settable: array(TransmitSettingKeySchema),
-	maxTimings: number$1().int().positive()
+	maxTimings: number$1().int().positive(),
+	/** The transmitter can learn a code (`learn`). */
+	learn: boolean().default(false),
+	/** Native code formats the transmitter replays verbatim (`send.native`). */
+	formats: array(IrNativeFormatSchema).default([])
+});
+var IR_LEARN_TIMEOUT_DEFAULT_MS = 2e4;
+var IR_LEARN_TIMEOUT_MAX_MS = 6e4;
+var IrLearnResultSchema = object({
+	/** The code in the device's own format, when it reports one. */
+	native: IrNativeCodeSchema.nullable(),
+	timings: IrTimingsSchema,
+	carrierHz: number$1().int().positive().nullable()
 });
 DeviceType.Generic, method(object({
 	deviceId: number$1().int().nonnegative(),
-	timings: IrTimingsSchema,
+	timings: IrTimingsSchema.optional(),
+	native: IrNativeCodeSchema.optional(),
 	settings: TransmitSettingsSchema.optional()
-}), IrSendResultSchema, {
+}).refine((input) => input.timings === void 0 !== (input.native === void 0), { message: "send takes exactly one of timings or native" }), IrSendResultSchema, {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number$1().int().nonnegative(),
+	timeoutMs: number$1().int().positive().max(IR_LEARN_TIMEOUT_MAX_MS).default(IR_LEARN_TIMEOUT_DEFAULT_MS)
+}), IrLearnResultSchema, {
 	kind: "mutation",
 	auth: "protected"
 }), method(object({ deviceId: number$1().int().nonnegative() }), IrTransmitterInfoSchema, {
@@ -69875,6 +70294,7 @@ var NcSystemEventKindSchema = _enum([
 	"recording-degraded",
 	"device-attention-required",
 	"device-attention-resolved",
+	"device-command",
 	"storage-location-low",
 	"storage-location-critical",
 	"storage-location-ok",
@@ -69937,11 +70357,6 @@ var NC_ALARM_SYSTEM_EVENT_KINDS = [
 	"alarm-sensor-bypass",
 	"alarm-disarmed"
 ];
-/**
-* One coherent system-event condition. `kinds` is the required opt-in safety
-* gate; the remaining lists are optional narrowing filters relevant to the
-* selected kinds.
-*/
 var NcSystemEventConditionSchema = object({
 	kinds: array(NcSystemEventKindSchema).min(1),
 	deviceIds: array(number$1().int()).min(1).optional(),
@@ -69973,6 +70388,28 @@ var NcSystemEventConditionSchema = object({
 	nodeIds: array(string().min(1)).min(1).optional(),
 	packageNames: array(string().min(1)).min(1).optional(),
 	/**
+	* `device-command` only: the vocabulary ACTION IDS (D983, `powerSource.forceRestart`)
+	* this rule speaks about - the same dictionary the automation action blocks
+	* pick from. The hub refuses an id the action index does not know.
+	*/
+	commandActions: array(string().min(1)).min(1).optional(),
+	/** `device-command` only: how the command settled. A device's own change is not a command. */
+	commandOutcomes: array(_enum([
+		"confirmed",
+		"already",
+		"unconfirmed",
+		"failed"
+	])).min(1).optional(),
+	/** `device-command` only: who asked (`user`, `addon`, `action`, `scheduler`, `composition`, `node`). */
+	commandActorKinds: array(_enum([
+		"user",
+		"addon",
+		"action",
+		"scheduler",
+		"composition",
+		"node"
+	])).min(1).optional(),
+	/**
 	* At or below this remaining-life %, a consumable is LOW for THIS rule
 	* (D642). Absent = {@link NC_CONSUMABLE_LOW_PERCENT_DEFAULT}; at most
 	* {@link NC_CONSUMABLE_LOW_PERCENT_MAX}, so every episode can recover. Scoped to the
@@ -70953,6 +71390,13 @@ var NcRuleInputSchema = object({
 	*/
 	groupingSec: number$1().int().min(5).max(60).optional(),
 	/**
+	* Hold deliveries of this rule to one target and, when two or more arrive
+	* before the window ends, send them as one summary. Absent = the kind's
+	* default (`groupWithinSecOf`): 5 s for a system-event rule, 0 for every
+	* other kind. `0` sends each delivery as it does today.
+	*/
+	groupWithinSec: number$1().int().min(0).max(300).optional(),
+	/**
 	* ASK ME TO CONFIRM DETECTIONS (#243): a DETECTION notification of this rule
 	* carries "Correct" / "Wrong" buttons (and, where the channel has room, a
 	* "Wrong, it is a <class>" choice). A tap marks the track for retraining, the
@@ -71389,7 +71833,12 @@ var NcHistoryEntrySchema = object({
 	* Assistant export) must render as "no image right now", never as a
 	* broken link.
 	*/
-	artifactIds: array(string().min(1)).optional()
+	artifactIds: array(string().min(1)).optional(),
+	/**
+	* When this row was folded into a group-window summary, the outbox id of
+	* that one notification. Absent on a row that was sent as itself.
+	*/
+	groupedInto: string().min(1).optional()
 });
 /**
 * Query filter for `getHistory` (spec §4.2). Every field is a narrowing
@@ -77462,10 +77911,15 @@ getStatus: method(object({ deviceId: number$1() }), RecordingSignalStatusSchema)
 	*/
 	history: "none"
 };
-var RemoteBindingSchema = object({ action: AutomationCapStepBaseSchema.omit({
-	target: true,
-	actionId: true
-}).extend({ deviceId: number$1().int().nonnegative() }) });
+var RemoteBindingSchema = object({ action: object({
+	kind: literal("cap"),
+	deviceId: number$1().int().nonnegative(),
+	cap: string().min(1),
+	method: string().min(1),
+	args: record(string(), unknown()).optional(),
+	/** The unit the person picked per arg (display only); `args` always hold the cap's own unit. */
+	argUnits: record(string(), string().min(1)).optional()
+}) });
 var RemoteCustomButtonSchema = object({
 	/** The slug after `custom:` in the role. */
 	key: string().refine(isRemoteCustomKey, { message: "a lowercase slug" }),
@@ -78455,7 +78909,7 @@ var sceneMonitorCapability = {
 		* instead of failing silently weeks later.
 		*
 		* Reachable from three surfaces on this one mutation: the scene card, a
-		* notification button (an `onTrigger` sequence with a `kind:'cap'` step —
+		* notification button (an `onTrigger` sequence with a `kind:'command'` step —
 		* no new Notification-Center code at all), and tRPC for scripts.
 		*/
 		resetScene: method(object({
@@ -85448,6 +85902,13 @@ function contribution(cap, schema, build) {
 		}
 	};
 }
+/** The fragment, carrying the cap's single measurement when it has one. */
+function measured(fragment, measurement) {
+	return measurement === void 0 ? fragment : {
+		...fragment,
+		measurement
+	};
+}
 function action(id, label, icon, cap, method, args = {}, emphasis = "normal", confirm = null) {
 	return {
 		id,
@@ -86722,10 +87183,26 @@ var controlContribution = contribution("control", ControlStatusSchema, (slice, c
 	};
 });
 var CONTROL_LABEL = t("Value", "Valore");
-/** A number with known bounds is a slider, a choice a picker; text and dates stay read-only. */
+/**
+* A number with known bounds is a slider, one without a number field, a choice a picker,
+* free text a text field; a date stays read-only.
+*/
 function controlRows(slice) {
 	if (slice.kind === "numeric" && typeof slice.value === "number") {
-		if (slice.min === void 0 || slice.max === void 0) return [];
+		if (slice.min === void 0 || slice.max === void 0) return [row$1("control", "sliders-horizontal", null, [{
+			kind: "number",
+			id: "control.value",
+			label: CONTROL_LABEL,
+			value: slice.value,
+			step: slice.step ?? null,
+			unit: "",
+			call: {
+				cap: "control",
+				method: "setValue",
+				args: { control: { kind: "numeric" } }
+			},
+			valueArg: "control.value"
+		}])];
 		return [row$1("control", "sliders-horizontal", null, [{
 			kind: "slider",
 			id: "control.value",
@@ -86756,6 +87233,18 @@ function controlRows(slice) {
 		},
 		valueArg: "control.value"
 	}])];
+	if (slice.kind === "text") return [row$1("control", "sliders-horizontal", null, [{
+		kind: "text",
+		id: "control.value",
+		label: CONTROL_LABEL,
+		value: typeof slice.value === "string" ? slice.value : null,
+		call: {
+			cap: "control",
+			method: "setValue",
+			args: { control: { kind: "text" } }
+		},
+		valueArg: "control.value"
+	}])];
 	return [];
 }
 var SENSORS_FAMILY_CONTRIBUTIONS = {
@@ -87111,15 +87600,15 @@ function sensorFragment(value, id, icon, en, it, text) {
 		tiles: { right: [tile$1(en, it, text)] }
 	};
 }
-var temperatureContribution = contribution("temperature-sensor", TemperatureSensorStatusSchema, (slice) => sensorFragment(slice?.temperature ?? null, "temperature", "thermometer", "Temperature", "Temperatura", formatDegrees(slice?.temperature ?? 0)));
-var humidityContribution = contribution("humidity-sensor", HumiditySensorStatusSchema, (slice) => sensorFragment(slice?.humidity ?? null, "humidity", "droplets", "Humidity", "Umidità", `${Math.round(slice?.humidity ?? 0)}%`));
+var temperatureContribution = contribution("temperature-sensor", TemperatureSensorStatusSchema, (slice) => measured(sensorFragment(slice?.temperature ?? null, "temperature", "thermometer", "Temperature", "Temperatura", formatDegrees(slice?.temperature ?? 0)), slice?.temperature == null ? void 0 : temperatureMeasurement(slice.temperature, slice.lastFetchedAt)));
+var humidityContribution = contribution("humidity-sensor", HumiditySensorStatusSchema, (slice) => measured(sensorFragment(slice?.humidity ?? null, "humidity", "droplets", "Humidity", "Umidità", `${Math.round(slice?.humidity ?? 0)}%`), slice?.humidity == null ? void 0 : humidityMeasurement(slice.humidity, slice.lastFetchedAt)));
 var pressureContribution = contribution("pressure-sensor", PressureSensorStatusSchema, (slice) => sensorFragment(slice?.pressure ?? null, "pressure", "gauge", "Pressure", "Pressione", `${Math.round(slice?.pressure ?? 0)} hPa`));
 var illuminanceContribution = contribution("ambient-light-sensor", AmbientLightSensorStatusSchema, (slice) => sensorFragment(slice?.illuminance ?? null, "illuminance", "sun", "Light", "Luce", `${Math.round(slice?.illuminance ?? 0)} lx`));
 var numericContribution = contribution("numeric-sensor", NumericSensorStatusSchema, (slice) => sensorFragment(slice?.value ?? null, "reading", "gauge", "Value", "Valore", String(Number((slice?.value ?? 0).toFixed(2)))));
 var enumContribution = contribution("enum-sensor", EnumSensorStatusSchema, (slice) => {
 	if (slice === void 0 || slice.value === "") return { reading: reading("sensor", "unknown") };
 	if (slice.timestamp === true) return { reading: reading("sensor", "on") };
-	return sensorFragment(slice.value, "reading", "gauge", "State", "Stato", slice.value);
+	return measured(sensorFragment(slice.value, "reading", "gauge", "State", "Stato", slice.value), textMeasurement(slice.value, slice.lastFetchedAt));
 });
 /** Index bands: the headline of an air-quality sensor is a word, not a number. */
 function airQualityWord(aqi) {
@@ -90015,6 +90504,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"deviceExport.setExposedName": {
+		capName: "device-export",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceExport.unexposeDevice": {
 		capName: "device-export",
 		capScope: "system",
@@ -91954,6 +92450,13 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"irTransmitter.learn": {
+		capName: "ir-transmitter",
+		capScope: "device",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
 	"irTransmitter.send": {
 		capName: "ir-transmitter",
 		capScope: "device",
@@ -98472,48 +98975,6 @@ Object.freeze({
 		role: "admin"
 	}
 });
-/**
-* "Do" actions an operator can pick for a device — presentation-free.
-*
-* The wire shape stays `{ cap, method, args }`. Since D920 this module no
-* longer HOLDS a catalogue: {@link DEVICE_DO_ACTIONS} is a projection of the
-* cap vocabulary (`cap-vocabulary/`), the one cap-keyed map of every action
-* and trigger — so a picker built on this module and one built on
-* `actionsForDevice` (the vocabulary resolver) can never disagree about what
-* a device can do. Ids, baked args and the matching of saved steps are the
-* vocabulary's; labels here are its English labels.
-*
-* Shared by the admin NC Sequences / rule Do editor and Automations; the
-* viewer can reuse the same catalogue once its step editor catches up.
-*/
-function openArgKind(offer) {
-	if (offer.kind === "number") return "number";
-	if (offer.kind === "dynamic" && offer.valueKind === "number") return "number";
-	if (offer.kind === "enum" && offer.values.every((v) => typeof v.value === "number")) return "number";
-	return "string";
-}
-function projectOpenArg(arg) {
-	return {
-		key: arg.key,
-		label: arg.label.en,
-		kind: openArgKind(arg.offer),
-		offer: arg.offer,
-		...arg.optional === true ? { optional: true } : {}
-	};
-}
-function projectAction(cap, action) {
-	const open = action.openArgs ?? [];
-	return {
-		id: action.id,
-		label: action.label.en,
-		cap,
-		method: action.method,
-		args: action.args ?? {},
-		...open.length > 0 ? { openArgs: open.map(projectOpenArg) } : {}
-	};
-}
-Object.entries(CAP_VOCABULARY_BY_NAME).flatMap(([cap, entry]) => entry.scope === "device" ? (entry.actions ?? []).map((a) => projectAction(cap, a)) : []);
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
 DeviceFeature.BatteryOperated;
 function bound(cap, methods = [], authority = "reported") {
 	return {
@@ -99805,6 +100266,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"irTransmitter.learn": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"irTransmitter.send": [{
 		name: "deviceId",
 		form: "single",
@@ -101744,7 +102210,10 @@ var NC_SYSTEM_EVENT_FILTER_KEYS = [
 	"deviceTypes",
 	"nodeIds",
 	"packageNames",
-	"consumableLowPercent"
+	"consumableLowPercent",
+	"commandActions",
+	"commandOutcomes",
+	"commandActorKinds"
 ];
 new Map(Object.entries({
 	"device-online": "device-events",
@@ -101767,6 +102236,7 @@ new Map(Object.entries({
 	"recording-degraded": "device-events",
 	"device-attention-required": "device-events",
 	"device-attention-resolved": "device-events",
+	"device-command": "device-events",
 	"node-online": "system",
 	"node-offline": "system",
 	"node-restarting": "system",
@@ -101867,6 +102337,12 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Needs attention",
 		kinds: ["device-attention-required", "device-attention-resolved"]
 	},
+	{
+		id: "device-command",
+		family: "device-events",
+		label: "Commands given to devices",
+		kinds: ["device-command"]
+	},
 	{
 		id: "nodes",
 		family: "system",
@@ -101944,6 +102420,15 @@ function systemEventKindsOfFamily(family) {
 	return NC_SYSTEM_EVENT_KIND_GROUP_SPECS.filter((g) => g.family === family).flatMap((g) => g.kinds);
 }
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
+new Set([
+	"alarm.trigger",
+	"alarm.disarm",
+	"alarm.arm.home",
+	"alarm.arm.away",
+	"alarm.arm.night",
+	"alarm.arm.vacation",
+	"alarm.arm.custom_bypass"
+]);
 /**
 * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
 * persists (D640 "a sensor rule fires on the raise, the clear, or both").
@@ -102139,6 +102624,7 @@ var DEVICE_EVENTS = [
 	"recording-healthy",
 	"recording-degraded",
 	...DEVICE_ATTENTION,
+	"device-command",
 	...ALARM
 ];
 /** Every kind a summary may speak about — the two summarisable families. */
@@ -102292,6 +102778,9 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_BODY_ONLY],
 	[...RULE_TEXT],
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
@@ -103625,7 +104114,7 @@ function findSpec(id) {
 function capsOfSpec(spec) {
 	switch (spec.kind) {
 		case "power-meter": return ["power-meter"];
-		case "battery": return ["battery", "power-meter"];
+		case "battery": return ["numeric-sensor", "power-meter"];
 		case "meter": return ["meter"];
 		case "numeric": return ["numeric-sensor"];
 		case "text": return ["enum-sensor"];
@@ -103728,11 +104217,9 @@ function computeSlices(spec, snapshot, options, now) {
 			const v = numberOf(voltage);
 			const a = numberOf(current);
 			return {
-				battery: {
-					level: nullableOf(soc),
-					charging: "unknown",
-					sleeping: false,
-					lastUpdated: now
+				numeric: {
+					value: nullableOf(soc),
+					lastFetchedAt: now
 				},
 				...w !== void 0 || v !== void 0 || a !== void 0 ? { powerMeter: {
 					...w !== void 0 ? { power: w * sign || 0 } : {},
@@ -103878,12 +104365,6 @@ var METER_CAP = meterCapability.name;
 var NUMERIC_CAP = numericSensorCapability.name;
 var ENUM_CAP = enumSensorCapability.name;
 var POWER_COLD = { lastFetchedAt: 0 };
-var BATTERY_COLD = {
-	level: null,
-	charging: "unknown",
-	sleeping: false,
-	lastUpdated: 0
-};
 var VALUE_COLD = {
 	value: null,
 	lastFetchedAt: 0
@@ -103931,6 +104412,7 @@ var EnpalSensorDevice = class extends BaseDevice {
 			id: `${this.integrationId}:${spec.id}`,
 			system: ENPAL_SYSTEM,
 			...spec.kind === "meter" || spec.kind === "numeric" ? { quantity: spec.quantity } : {},
+			...spec.kind === "battery" ? { quantity: spec.level.quantity } : {},
 			...spec.kind === "text" && spec.timestamp === true ? { dateTimeShape: "date" } : {}
 		});
 	}
@@ -103980,7 +104462,6 @@ var EnpalSensorDevice = class extends BaseDevice {
 				energy: this.energyGuard.accept(kwh)
 			});
 		}
-		if (slices.battery !== void 0) this.runtimeState.setCapState(BATTERY_CAP, slices.battery);
 		if (slices.meter !== void 0) {
 			const raw = slices.meter.value;
 			this.runtimeState.setCapState(METER_CAP, {
@@ -103997,7 +104478,8 @@ var EnpalSensorDevice = class extends BaseDevice {
 				this.registerPowerMeter();
 				return;
 			case "battery":
-				this.registerBattery();
+				this.retractBatteryCap();
+				this.registerNumeric();
 				this.registerPowerMeter();
 				return;
 			case "meter":
@@ -104009,8 +104491,7 @@ var EnpalSensorDevice = class extends BaseDevice {
 				this.runtimeState.setCapState(ENUM_CAP, TEXT_COLD);
 				return;
 			case "numeric":
-				this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState(NUMERIC_CAP) ?? VALUE_COLD });
-				this.runtimeState.setCapState(NUMERIC_CAP, VALUE_COLD);
+				this.registerNumeric();
 				return;
 		}
 	}
@@ -104018,15 +104499,18 @@ var EnpalSensorDevice = class extends BaseDevice {
 		this.ctx.registerNativeCap(powerMeterCapability, { getStatus: async () => this.runtimeState.getCapState(POWER_CAP) ?? POWER_COLD });
 		this.runtimeState.setCapState(POWER_CAP, POWER_COLD);
 	}
-	registerBattery() {
-		this.ctx.registerNativeCap(batteryCapability, {
-			getStatus: async () => this.runtimeState.getCapState(BATTERY_CAP) ?? BATTERY_COLD,
-			wakeForStream: async () => ({
-				awoke: false,
-				durationMs: 0
-			})
-		});
-		this.runtimeState.setCapState(BATTERY_CAP, BATTERY_COLD);
+	registerNumeric() {
+		this.ctx.registerNativeCap(numericSensorCapability, { getStatus: async () => this.runtimeState.getCapState(NUMERIC_CAP) ?? VALUE_COLD });
+		this.runtimeState.setCapState(NUMERIC_CAP, VALUE_COLD);
+	}
+	/**
+	* The storage battery once registered the `battery` cap (#522). This process never
+	* registers it, so the call retracts the binding a previous incarnation left on the hub
+	* (`unregisterNativeCap`'s stale-retract path): a restored device stops answering
+	* `battery` and no `battery` slice is written again.
+	*/
+	retractBatteryCap() {
+		this.ctx.unregisterNativeCap?.(BATTERY_CAP);
 	}
 };
 //#endregion
@@ -105374,7 +105858,39 @@ var enpalConnectionsEntryKind = defineEntryKind("connections", {
 });
 /** Every kind this addon declares, keyed by its name. */
 var enpalRecordKinds = { connections: enpalConnectionsEntryKind };
+var REJECTED_KINDS = new Set([
+	"unauthorized",
+	"token-missing",
+	"empty"
+]);
+function connectionForTest(values) {
+	const host = values["host"];
+	if (typeof host !== "string" || host.trim().length === 0) return null;
+	const parsed = enpalConnectionSchema.safeParse({ ...values });
+	return parsed.success ? parsed.data : null;
+}
+function testFailure(error) {
+	if (error instanceof EnpalError) return {
+		success: false,
+		status: REJECTED_KINDS.has(error.kind) ? "rejected" : "inconclusive",
+		error: error.message
+	};
+	return {
+		success: false,
+		status: "inconclusive",
+		error: "The Enpal box did not answer"
+	};
+}
+function liveProbe(blazor) {
+	return (connection) => readEnpalSnapshot({
+		connection,
+		fetch: globalThis.fetch,
+		now: () => Date.now(),
+		blazor: blazor?.()
+	});
+}
 function buildEnpalInstances(records, deps) {
+	const probe = deps.probe ?? liveProbe(deps.blazor);
 	return new RecordIntegrationInstances(records, enpalConnectionsEntryKind, {
 		description: {
 			role: "devices",
@@ -105384,18 +105900,36 @@ function buildEnpalInstances(records, deps) {
 			},
 			instanceMode: "multiple",
 			kind: "server",
-			canTest: false,
+			canTest: true,
 			kinds: [{
 				id: "connection",
 				label: "Enpal",
 				functionCap: "device-provider",
-				role: "devices"
+				role: "devices",
+				canTest: true
 			}]
 		},
 		formSchema: () => buildConnectionFormSchema(),
 		initialBody: (name) => ({ name }),
 		configured: (body) => (body.host ?? "").length > 0,
-		onChanged: () => deps.onChanged()
+		onChanged: () => deps.onChanged(),
+		test: async ({ values }) => {
+			const connection = connectionForTest(values);
+			if (connection === null) return {
+				success: false,
+				status: "rejected",
+				error: "Host is required"
+			};
+			try {
+				await probe(connection);
+				return {
+					success: true,
+					status: "validated"
+				};
+			} catch (error) {
+				return testFailure(error);
+			}
+		}
 	});
 }
 /**
@@ -105688,7 +106222,10 @@ var EnpalProviderAddon = class extends BaseDeviceProvider {
 			...rowsDepsOver(api),
 			kind: enpalConnectionsEntryKind
 		}));
-		this.instances = buildEnpalInstances(records, { onChanged: () => this.reconcileIntegrations() });
+		this.instances = buildEnpalInstances(records, {
+			onChanged: () => this.reconcileIntegrations(),
+			blazor: () => this.blazorReader ?? void 0
+		});
 		this.blazorReader = await this.createBlazorBridge();
 		this.clients = new EnpalClientRegistry(this.ctx.logger, {
 			blazor: () => this.blazorReader ?? void 0,