@camstack/addon-provider-enpal 0.1.18 → 0.1.19

package/dist/addon.js

@@ -6057,7 +6057,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-Czv-4wFH.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).
@@ -15262,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,
@@ -44947,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;
@@ -44970,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
@@ -45011,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.
@@ -45043,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,
@@ -45064,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"),
@@ -45154,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()
@@ -45171,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
@@ -45251,7 +45246,7 @@ var AutomationBodyStepSchema = discriminatedUnion("kind", [
 var AutomationRepeatStepSchema = repeatSchemaOf(AutomationBodyStepSchema);
 var AutomationActionSchema = discriminatedUnion("kind", [
 	GuardedWaitStepSchema,
-	AutomationGuardedCapStepSchema,
+	AutomationGuardedCommandStepSchema,
 	AutomationStopStepSchema,
 	AutomationSetStepSchema,
 	chooseSchemaOf(AutomationBodyStepSchema),
@@ -45322,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.
 *
@@ -45824,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.
@@ -46003,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",
@@ -53784,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`. */
@@ -58776,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([
@@ -58827,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",
@@ -58937,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. */
@@ -59138,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)
@@ -59209,7 +59378,13 @@ 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",
@@ -77736,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" }),
@@ -78729,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({
@@ -85722,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,
@@ -86996,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",
@@ -87030,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 = {
@@ -87385,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) {
@@ -90289,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",
@@ -98753,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 {
@@ -102240,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").
@@ -103925,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"];
@@ -104028,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 } : {},
@@ -104178,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
@@ -104231,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" } : {}
 		});
 	}
@@ -104280,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, {
@@ -104297,7 +104478,8 @@ var EnpalSensorDevice = class extends BaseDevice {
 				this.registerPowerMeter();
 				return;
 			case "battery":
-				this.registerBattery();
+				this.retractBatteryCap();
+				this.registerNumeric();
 				this.registerPowerMeter();
 				return;
 			case "meter":
@@ -104309,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;
 		}
 	}
@@ -104318,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