@camstack/addon-provider-unifi 0.2.148 → 0.2.150

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region ../types/dist/event-category-CT-hz5Rb.mjs
+//#region ../types/dist/event-category-DmZDPDf_.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -626,7 +626,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* (a track was promoted to a stationary-registry entry) or departs (the
 	* object moved / was removed). Telemetry (D8): lossy, drives a UI refresh of
 	* the dedicated "Stationary" section — never the live event feed. Payload:
-	* `{ deviceId, entryId, className, phase:'appeared'|'departed', timestamp }`.
+	* `{ deviceId, entryId, className, phase:'appeared'|'departed', timestamp, observedAt, zones }`.
 	*/
 	EventCategory["PipelineAnalyticsStationaryChanged"] = "pipeline-analytics.stationary-changed";
 	/**
@@ -764,6 +764,11 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["AccessoriesChanged"] = "accessories.onAccessoriesChanged";
 	/**
+	* An action run started or ended. Emitted by the `actions` surface.
+	* Payload: `ActionRunChanged` (`{ actionId, runId, isRunning, outcome?, lastRunAt, lastError }`).
+	*/
+	EventCategory["ActionsRunChanged"] = "actions.onRunChanged";
+	/**
 	* Progress update from a running model conversion job.
 	* Payload: `{ kind: 'model-convert', phase, sessionId?, pct?, detail? }`.
 	* Emitted by `addon-model-studio` on the converting node.
@@ -5442,7 +5447,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-bykKrTgu.mjs
+//#region ../types/dist/sleep-Crlmu_tO.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -8562,6 +8567,8 @@ Object.freeze({ "doorbell": "lastPressedAt" });
 /** Every capability name, so addon code can check a name without the schema graph. */
 var CAP_NAMES = Object.freeze([
 	"accessories",
+	"action-source",
+	"actions",
 	"addon-pages",
 	"addon-pages-source",
 	"addon-routes",
@@ -8635,6 +8642,7 @@ var CAP_NAMES = Object.freeze([
 	"filesystem-browse",
 	"flood",
 	"gas",
+	"group-active",
 	"group-commands",
 	"group-status",
 	"heating-valve",
@@ -8657,6 +8665,7 @@ var CAP_NAMES = Object.freeze([
 	"login-method",
 	"media-player",
 	"mesh-network",
+	"meter",
 	"metrics-provider",
 	"model-convert",
 	"model-distributor",
@@ -8748,11 +8757,11 @@ var CAP_NAMES = Object.freeze([
 Object.freeze({
 	"air-quality-sensor": [
 		{
-			"path": "co2Ppm",
+			"path": "co2",
 			"valueType": "number"
 		},
 		{
-			"path": "vocPpb",
+			"path": "voc",
 			"valueType": "number"
 		},
 		{
@@ -8802,7 +8811,7 @@ Object.freeze({
 		}
 	],
 	"ambient-light-sensor": [{
-		"path": "lux",
+		"path": "illuminance",
 		"valueType": "number"
 	}],
 	"audio-metrics": [
@@ -8863,7 +8872,7 @@ Object.freeze({
 	],
 	"battery": [
 		{
-			"path": "percentage",
+			"path": "level",
 			"valueType": "number"
 		},
 		{
@@ -8885,7 +8894,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "volts",
+			"path": "voltage",
 			"valueType": "number"
 		},
 		{
@@ -8906,7 +8915,7 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"brightness": [{
-		"path": "percentage",
+		"path": "level",
 		"valueType": "number"
 	}],
 	"broker": [{
@@ -9107,7 +9116,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "mireds",
+			"path": "colorTemperature",
 			"valueType": "number"
 		}
 	],
@@ -9286,15 +9295,15 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "remainingSeconds",
+			"path": "remaining",
 			"valueType": "number"
 		},
 		{
-			"path": "delayedStartSeconds",
+			"path": "delayedStart",
 			"valueType": "number"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -9408,7 +9417,7 @@ Object.freeze({
 	],
 	"fan-control": [
 		{
-			"path": "percentage",
+			"path": "speed",
 			"valueType": "number"
 		},
 		{
@@ -9455,6 +9464,10 @@ Object.freeze({
 		"path": "detected",
 		"valueType": "boolean"
 	}],
+	"group-active": [{
+		"path": "active",
+		"valueType": "boolean"
+	}],
 	"group-status": [
 		{
 			"path": "included",
@@ -9504,7 +9517,7 @@ Object.freeze({
 		}
 	],
 	"humidity-sensor": [{
-		"path": "percent",
+		"path": "humidity",
 		"valueType": "number"
 	}],
 	"image": [{
@@ -9614,7 +9627,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -9693,11 +9706,11 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "positionMs",
+			"path": "position",
 			"valueType": "number"
 		},
 		{
-			"path": "durationMs",
+			"path": "duration",
 			"valueType": "number"
 		},
 		{
@@ -9714,6 +9727,10 @@ Object.freeze({
 			]
 		}
 	],
+	"meter": [{
+		"path": "value",
+		"valueType": "number"
+	}],
 	"motion": [
 		{
 			"path": "detected",
@@ -9795,11 +9812,11 @@ Object.freeze({
 			]
 		},
 		{
-			"path": "signalPercent",
+			"path": "signal",
 			"valueType": "number"
 		},
 		{
-			"path": "rssiDbm",
+			"path": "rssi",
 			"valueType": "number"
 		},
 		{
@@ -9854,6 +9871,18 @@ Object.freeze({
 			"path": "foodLevel",
 			"valueType": "number"
 		},
+		{
+			"path": "bowlFood",
+			"valueType": "number"
+		},
+		{
+			"path": "eating",
+			"valueType": "boolean"
+		},
+		{
+			"path": "supportsMarkRefilled",
+			"valueType": "boolean"
+		},
 		{
 			"path": "food1",
 			"valueType": "number"
@@ -9918,23 +9947,23 @@ Object.freeze({
 	],
 	"power-meter": [
 		{
-			"path": "watts",
+			"path": "power",
 			"valueType": "number"
 		},
 		{
-			"path": "kwhTotal",
+			"path": "energy",
 			"valueType": "number"
 		},
 		{
-			"path": "volts",
+			"path": "voltage",
 			"valueType": "number"
 		},
 		{
-			"path": "amps",
+			"path": "current",
 			"valueType": "number"
 		},
 		{
-			"path": "va",
+			"path": "apparentPower",
 			"valueType": "number"
 		},
 		{
@@ -9962,14 +9991,10 @@ Object.freeze({
 		{
 			"path": "gps.accuracyMeters",
 			"valueType": "number"
-		},
-		{
-			"path": "batteryPercent",
-			"valueType": "number"
 		}
 	],
 	"pressure-sensor": [{
-		"path": "hpa",
+		"path": "pressure",
 		"valueType": "number"
 	}],
 	"privacy-mask": [{
@@ -10283,7 +10308,7 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"temperature-sensor": [{
-		"path": "celsius",
+		"path": "temperature",
 		"valueType": "number"
 	}],
 	"update": [
@@ -10331,7 +10356,7 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -10471,7 +10496,7 @@ function userError(code, params, englishFallback) {
 	return new CamstackError(code, params, englishFallback);
 }
 //#endregion
-//#region ../types/dist/err-msg-BXKzRBwg.mjs
+//#region ../types/dist/err-msg-DIorGYeC.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
 	DeviceType["Hub"] = "hub";
@@ -10565,8 +10590,14 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["PetFeeder"] = "pet-feeder";
 	/** Built-in dishwasher — program lifecycle, door / remote-start gates,
 	*  salt and rinse-aid levels. Installed with the `dishwasher` cap.
-	*  Sources: native Bosch Home Connect, reusable by similar integrations. */
+	*  Sources: native Bosch Home Connect, reusable by similar integrations.
+	*  A plug-built dishwasher carries running-state and power instead. */
 	DeviceType["Dishwasher"] = "dishwasher";
+	/** Washing machine. A plug-built one is running while its power stays
+	*  above a threshold. No program cap — that surface is the dishwasher's. */
+	DeviceType["Washer"] = "washer";
+	/** Tumble dryer. Same plug-built running surface as {@link Washer}. */
+	DeviceType["Dryer"] = "dryer";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -10824,7 +10855,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-OhpuespA.mjs
+//#region ../types/dist/composition-CZImLpOI.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -11139,6 +11170,13 @@ var table = {
 		apply: () => {
 			throw new ExpressionEvalError("latchedAt: stateful evaluation context is required");
 		}
+	},
+	schmitt: {
+		minArgs: 3,
+		maxArgs: 5,
+		apply: () => {
+			throw new ExpressionEvalError("schmitt: stateful evaluation context is required");
+		}
 	}
 };
 Object.freeze(Object.assign(Object.create(null), table));
@@ -11580,6 +11618,99 @@ function validateExpressionSource(src) {
 	return null;
 }
 /**
+* One power reading becomes a washer, dryer or dishwasher (D944 helper).
+*
+* Standby of the control board is under 5 W; a motor or a heater is far
+* above that, so 5 W is the line. A door lock or a short pump spike is not
+* a cycle, so running starts only after 30 s above the line.
+*
+* A wash, dry or dishwasher pause (soak, heat-wait, heater off between
+* bursts) lasts several minutes. Ending the cycle on the first dip would
+* report "finished" in the middle of the program, so the stop dwell is
+* 10 minutes on every type. The number is stored per type so one machine
+* can move later without moving the others.
+*/
+var APPLIANCE_TEMPLATE_ID = "appliance";
+var APPLIANCE_KINDS = [
+	"washer",
+	"dryer",
+	"dishwasher"
+];
+DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
+/**
+* Statistics and integrals over a history read (D944).
+*
+* Pure: the same points always give the same answer, so a restart recomputes
+* rather than trusting a buffer. A gauge mean is time-weighted (value × ms),
+* never the mean of the samples. A hole with no held value is not integrated
+* as zero. A truncated read is not published.
+*/
+var STATISTIC_STATS = [
+	"min",
+	"max",
+	"mean",
+	"sum",
+	"count",
+	"change"
+];
+/**
+* The range a statistics or integral helper asks history for (D944).
+*
+* Calendar edges are the hub's timezone, never UTC midnight: a day is 23, 24
+* or 25 hours across a DST change. A tier is eligible only when its retention
+* is strictly longer than the longest that range can be. Forever qualifies.
+* Equal to a tier's retention is a refusal, not a short answer.
+*/
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var ROLLING_SPANS = [
+	"1h",
+	"24h",
+	"2d",
+	"7d",
+	"30d",
+	"custom"
+];
+var CALENDAR_PERIODS = [
+	"today",
+	"yesterday",
+	"this-week",
+	"this-month"
+];
+var RESET_PERIODS = [
+	"never",
+	"daily",
+	"weekly",
+	"monthly"
+];
+5 * MINUTE_MS;
+24 * HOUR_MS, 2 * DAY_MS, 7 * DAY_MS, 30 * DAY_MS;
+7 * DAY_MS, 30 * DAY_MS, 365 * DAY_MS;
+var rollingWindowObject = object({
+	kind: literal("rolling"),
+	span: _enum(ROLLING_SPANS),
+	customMinutes: number().int().min(5).optional()
+}).check((payload) => {
+	if (payload.value.span === "custom" && payload.value.customMinutes === void 0) payload.issues.push({
+		code: "custom",
+		message: "a custom range needs a duration in minutes",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+	if (payload.value.span !== "custom" && payload.value.customMinutes !== void 0) payload.issues.push({
+		code: "custom",
+		message: "only a custom range carries a duration",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+});
+var RollingWindowSchema = rollingWindowObject;
+var StatisticWindowSchema = discriminatedUnion("kind", [rollingWindowObject, object({
+	kind: literal("calendar"),
+	period: _enum(CALENDAR_PERIODS)
+})]);
+/**
 * A composition source identity: `(addonId, stableId)`, never a numeric device
 * id. Split out so helper schemas can name it without a cycle through
 * `composition.ts` (D659).
@@ -11605,7 +11736,13 @@ var GROUP_TEMPLATE_IDS = [
 	"occupancy",
 	"binary",
 	"switch",
-	"light"
+	"light",
+	"fan",
+	"cover",
+	"valve",
+	"lock",
+	"media-player",
+	"climate"
 ];
 var NUMERIC_AGGREGATES = [
 	"mean",
@@ -11635,14 +11772,73 @@ var HelperMemberSchema = object({
 	cap: string().min(1),
 	fieldPath: string().min(1)
 });
-var HelperSpecSchema = discriminatedUnion("kind", [object({
-	kind: literal("group"),
-	templateId: GroupTemplateIdSchema,
-	aggregate: AggregateReducerSchema,
-	members: array(HelperMemberSchema).min(1).max(64),
-	/** Actuator groups only. Readings leave this unset. */
-	active: ActiveCriterionSchema.optional()
-})]);
+var HelperSpecSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("group"),
+		templateId: GroupTemplateIdSchema,
+		aggregate: AggregateReducerSchema,
+		members: array(HelperMemberSchema).min(1).max(64),
+		/** Actuator groups only. Readings leave this unset. */
+		active: ActiveCriterionSchema.optional()
+	}),
+	object({
+		kind: literal("appliance"),
+		templateId: literal(APPLIANCE_TEMPLATE_ID),
+		appliance: _enum(APPLIANCE_KINDS),
+		thresholdWatts: number().positive(),
+		startDwellMs: number().int().nonnegative(),
+		stopDwellMs: number().int().nonnegative(),
+		member: HelperMemberSchema
+	}),
+	object({
+		kind: literal("statistic"),
+		stat: _enum(STATISTIC_STATS),
+		window: StatisticWindowSchema,
+		source: HelperMemberSchema
+	}),
+	object({
+		kind: literal("integral"),
+		reset: _enum(RESET_PERIODS),
+		output: _enum(["energy", "meter"]),
+		source: HelperMemberSchema
+	}),
+	object({
+		kind: literal("threshold"),
+		source: HelperMemberSchema,
+		high: number(),
+		low: number(),
+		onForMs: number().int().nonnegative(),
+		offForMs: number().int().nonnegative()
+	}),
+	object({
+		kind: literal("arithmetic"),
+		op: _enum([
+			"sum",
+			"difference",
+			"ratio"
+		]),
+		inputs: array(HelperMemberSchema).min(2).max(64)
+	}),
+	object({
+		kind: literal("expression"),
+		expr: string().min(1),
+		inputs: array(object({
+			name: string().min(1),
+			member: HelperMemberSchema
+		})).min(1).max(64),
+		output: _enum(["number", "boolean"])
+	}),
+	object({
+		kind: literal("derivative"),
+		window: RollingWindowSchema,
+		per: _enum([
+			"second",
+			"minute",
+			"hour"
+		]),
+		source: HelperMemberSchema
+	})
+]);
 /** A composed device's stableId is this prefix plus the block id. */
 var COMPOSED_DEVICE_STABLE_ID_PREFIX = "composed-";
 /** Longest snippet a `code` source may carry (slice 4). */
@@ -11703,6 +11899,12 @@ var CompositionFieldSourceSchema = discriminatedUnion("kind", [
 			"all"
 		]),
 		reads: array(CompositionFieldReadSchema).min(1).max(64),
+		/**
+		* Set when the reads are an enum state, not a yes/no: the listed states
+		* count as active (a cover is `open`). A state outside the list is inactive;
+		* a read that is not a state at all is left out. Only `any` / `all` use it.
+		*/
+		activeWhen: array(string().min(1)).min(1).optional(),
 		/** `value` is the reading; the others are the member counts. */
 		publish: _enum([
 			"value",
@@ -11716,6 +11918,26 @@ var CompositionFieldSourceSchema = discriminatedUnion("kind", [
 			"omit",
 			"offline"
 		])
+	}),
+	object({
+		kind: literal("series"),
+		read: CompositionFieldReadSchema,
+		/** `value` is the statistic or the integral. The others are the gap counts. */
+		publish: _enum([
+			"value",
+			"included",
+			"excluded",
+			"total"
+		]),
+		/**
+		* What an unanswered `value` does. Counts ignore this. `offline` leaves the
+		* device unseeded until history answers, so a restart cannot publish 0.
+		*/
+		empty: _enum([
+			"null",
+			"omit",
+			"offline"
+		])
 	})
 ]);
 var CompositionCommandTargetSchema = discriminatedUnion("kind", [object({
@@ -15153,6 +15375,14 @@ var AutomationConditionLeafSchema = object({
 		array(union([string(), number()]))
 	])
 });
+var AutomationConditionStationaryPresentSchema = object({
+	kind: literal("stationary-present"),
+	deviceId: number().int().nonnegative(),
+	/** Class names; a macro class matches every raw class that maps to it. */
+	classes: array(string().min(1)).min(1).optional(),
+	/** The parked object must be in at least one of these zones. */
+	zones: array(string().min(1)).min(1).optional()
+});
 /**
 * The expression leaf, declared as a plain object rather than an intersection
 * with {@link ExpressionSourceSchema}: a discriminated union has to be able to
@@ -15186,7 +15416,8 @@ var AutomationConditionSchema = lazy(() => discriminatedUnion("kind", [
 		child: AutomationConditionSchema
 	}),
 	AutomationConditionLeafSchema,
-	AutomationConditionExpressionSchema
+	AutomationConditionExpressionSchema,
+	AutomationConditionStationaryPresentSchema
 ]));
 /**
 * What starts a run.
@@ -15227,7 +15458,34 @@ var AutomationTriggerSchema = discriminatedUnion("kind", [
 		kind: literal("schedule"),
 		cron: string().min(1).max(120)
 	}),
-	object({ kind: literal("manual") })
+	object({ kind: literal("manual") }),
+	object({
+		kind: literal("detection"),
+		/** Class names. A macro class (`animal`, `vehicle`, `person`, `package`)
+		*  matches every raw class that maps to it; any other name matches
+		*  exactly. */
+		classes: array(string().min(1)).min(1),
+		deviceIds: array(number().int().nonnegative()).min(1),
+		/** The track must have visited at least one of these zones. */
+		zones: array(string().min(1)).min(1).optional(),
+		/** Best-so-far confidence the track must reach. */
+		minScore: number().min(0).max(1).optional()
+	}),
+	object({
+		kind: literal("stationary"),
+		deviceIds: array(number().int().nonnegative()).min(1),
+		/** Class names; a macro class matches like the detection trigger. */
+		classes: array(string().min(1)).min(1).optional(),
+		/** The parked object must be in at least one of these zones. */
+		zones: array(string().min(1)).min(1).optional(),
+		/** `appeared`: it became parked. `departed`: the registry retired it.
+		*  The vocabulary of `PipelineAnalyticsStationaryChanged`. */
+		phase: _enum(["appeared", "departed"])
+	}),
+	object({
+		kind: literal("interval"),
+		minutes: number().int().min(1).max(1440)
+	})
 ]);
 /**
 * One action step.
@@ -15247,28 +15505,47 @@ var AutomationTriggerSchema = discriminatedUnion("kind", [
 * is called. The runner still receives a number and is untouched; the
 * resolution is the recipe's job, not the runner's.
 */
+var AutomationWaitStepSchema = object({
+	kind: literal("wait"),
+	seconds: number().min(0).max(300)
+});
+var AutomationCapStepSchema = object({
+	kind: literal("cap"),
+	/**
+	* One device, several same-family devices (locks / climate family / …),
+	* or `{ $var }` for the device that triggered the run. An array is
+	* fan-out at codegen — each id gets the same cap.method call.
+	*/
+	deviceId: union([
+		number().int(),
+		array(number().int()).min(1),
+		object({ $var: string().min(1) })
+	]),
+	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 steps an internal Action may contain: cap and wait, and nothing that can
+* call back into an Action — so an Action can never reach itself (no cycles).
+*/
+var ActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCapStepSchema]);
 var AutomationActionSchema = discriminatedUnion("kind", [
+	AutomationWaitStepSchema,
+	AutomationCapStepSchema,
 	object({
-		kind: literal("wait"),
-		seconds: number().min(0).max(300)
-	}),
-	object({
-		kind: literal("cap"),
-		/**
-		* One device, several same-family devices (locks / climate family / …),
-		* or `{ $var }` for the device that triggered the run. An array is
-		* fan-out at codegen — each id gets the same cap.method call.
-		*/
-		deviceId: union([
-			number().int(),
-			array(number().int()).min(1),
-			object({ $var: string().min(1) })
-		]),
-		cap: string().min(1),
-		method: string().min(1),
-		/** Values may carry `{{vars.x}}` slots, which SUBSTITUTE and do not
-		*  evaluate (§3.2.3). Anything beyond substitution is the expression leaf. */
-		args: record(string(), unknown()).optional()
+		kind: literal("action"),
+		/** An entry of the `actions` surface (`internal:<uuid>` or `<addonId>:<localId>`). */
+		actionId: string().min(1),
+		/** Values for the action's declared variables; the others take their default. */
+		variables: record(string(), union([
+			string(),
+			number(),
+			boolean()
+		])).optional()
 	}),
 	object({
 		kind: literal("code"),
@@ -15277,10 +15554,357 @@ var AutomationActionSchema = discriminatedUnion("kind", [
 		code: string().min(1).max(2e4)
 	})
 ]);
+/**
+* How a trigger that arrives while the automation is busy (or cooling down) is
+* handled. One of the automation's execution modes, never a property of its
+* actions. Absent means `single`.
+*
+*  - `single`   — drop the trigger while a run is in progress (traced + logged).
+*  - `restart`  — abort the run in progress (at its next step boundary), start fresh.
+*  - `queued`   — queue up to `max` triggers, drop the rest (traced).
+*  - `parallel` — up to `max` runs at once, drop the rest (traced).
+*  - `cooldown` — `single`, and no new run until `minutes` after the last run
+*    STARTED; persisted across a restart. A manual trigger bypasses only this
+*    wait, never the single/queued limits.
+*/
+var AutomationRunModeSchema = discriminatedUnion("mode", [
+	object({ mode: literal("single") }),
+	object({ mode: literal("restart") }),
+	object({
+		mode: literal("queued"),
+		max: number().int().min(1).max(10)
+	}),
+	object({
+		mode: literal("parallel"),
+		max: number().int().min(1).max(10)
+	}),
+	object({
+		mode: literal("cooldown"),
+		minutes: number().int().min(1).max(1440)
+	})
+]);
 var AutomationRecipeSchema = object({
 	triggers: array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
-	actions: array(AutomationActionSchema)
+	actions: array(AutomationActionSchema),
+	runMode: AutomationRunModeSchema.optional(),
+	/** How many run traces the automation keeps (default {@link DEFAULT_TRACE_KEEP}). */
+	keepTraces: number().int().min(1).max(100).optional()
+});
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
+new Set(Object.values(COCO_TO_MACRO.mapping));
+/**
+* Run traces — what an automation (or, later, an Action run) DID, node by node,
+* so the editor can paint every block green or red with its reason.
+*
+* A trace is data, not a log: it covers the WHOLE tree — the trigger stage,
+* every condition node (containers and leaves, including the ones a
+* short-circuit never reached), the run-mode verdict and every action step —
+* each addressed by a stable path (`conditions.0.1`, `actions.2`, or `steps.N`
+* for an Action run). Skipped
+* evaluations are traced too, and identical consecutive skips collapse into a
+* repeat count so a trigger that fails every 5 minutes cannot flush real runs.
+*
+* {@link AutomationStepTraceSchema} is deliberately free of automation
+* vocabulary so an Action run records the same step shape.
+*/
+/** A value a trace may show: JSON primitives and short lists, nothing deeper. */
+var TraceValueSchema = union([
+	string(),
+	number(),
+	boolean(),
+	_null(),
+	array(union([string(), number()]))
+]);
+var AutomationRunOutcomeSchema = _enum([
+	"ran",
+	"skipped-trigger",
+	"skipped-conditions",
+	"skipped-cooldown",
+	"skipped-overlap",
+	"failed",
+	"aborted"
+]);
+/** `not-evaluated` = a short-circuit never reached the node. */
+var TraceNodeOutcomeSchema = _enum([
+	"pass",
+	"fail",
+	"not-evaluated"
+]);
+var AutomationTriggerTraceSchema = object({
+	kind: string().min(1),
+	outcome: _enum(["pass", "fail"]),
+	/** Why an event was rejected ("class person not in [dog]") or what fired. */
+	reason: string(),
+	/** deviceId, className, trackId, score … — only what the trigger exposes. */
+	vars: record(string(), TraceValueSchema)
+});
+var AutomationConditionTraceNodeSchema = object({
+	/** `conditions` for the root, `conditions.<i>` for its i-th child, … */
+	path: string().min(1),
+	kind: _enum([
+		"all",
+		"any",
+		"not",
+		"condition",
+		"expression",
+		"stationary-present"
+	]),
+	outcome: TraceNodeOutcomeSchema,
+	reason: string(),
+	deviceId: number().int().optional(),
+	cap: string().optional(),
+	fieldPath: string().optional(),
+	operator: string().optional(),
+	expected: TraceValueSchema.optional(),
+	/** What the mirror held; `null` when it held nothing (unknown). */
+	observed: TraceValueSchema.optional()
+});
+var AutomationRunVerdictSchema = object({
+	mode: AutomationRunModeSchema,
+	decision: _enum([
+		"run",
+		"queued",
+		"restart",
+		"drop",
+		"cooldown",
+		"bypass"
+	]),
+	reason: string()
+});
+/** One executed (or not-run) step — shared by automations and Action runs. */
+var AutomationStepTraceSchema = object({
+	/** `actions.<i>` */
+	path: string().min(1),
+	kind: string().min(1),
+	cap: string().optional(),
+	method: string().optional(),
+	deviceId: number().int().optional(),
+	startedAt: number().optional(),
+	endedAt: number().optional(),
+	outcome: _enum([
+		"ok",
+		"error",
+		"not-run"
+	]),
+	message: string().optional()
+});
+var AutomationRunTraceSchema = object({
+	runId: string().min(1),
+	startedAt: number(),
+	endedAt: number(),
+	trigger: AutomationTriggerTraceSchema,
+	conditions: array(AutomationConditionTraceNodeSchema),
+	verdict: AutomationRunVerdictSchema.optional(),
+	steps: array(AutomationStepTraceSchema),
+	outcome: AutomationRunOutcomeSchema,
+	/** How many identical consecutive skips this trace stands for (>= 1). */
+	repeat: number().int().min(1),
+	/** When the latest of those repeats happened. */
+	lastAt: number()
+});
+/**
+* What the hub's `runs` ledger holds for one owner (`automation:<blockId>` or
+* `action:<actionId>`): the cooldown stamp and the trace ring.
+*/
+var AutomationStateDocSchema = object({
+	version: literal(1),
+	lastRunStartedAt: number().nullable(),
+	traces: array(AutomationRunTraceSchema)
+});
+/**
+* Actions — named, runnable things an operator (or an automation) can start,
+* declared as LIST ENTRIES, never as devices.
+*
+* An entry is either **internal** (a short list of cap/wait steps kept in the
+* hub's `actions` record kind) or declared by an addon through the
+* `action-source` collection (a Home Assistant script, a scene …). The one
+* surface the UI and automations talk to is the `actions` cap; it keeps no
+* catalog of its own (D3) — every `list` asks the providers live.
+*
+* This file is the data half: the entry schema, the variables an entry may
+* declare, and the pure resolution of the values a run was given. It holds no
+* runtime.
+*/
+/** What a variable's value is. `select` takes one of `options`. */
+var ActionVariableTypeSchema = _enum([
+	"string",
+	"number",
+	"boolean",
+	"select"
+]);
+var ACTION_VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ActionVariableValueSchema = union([
+	string(),
+	number(),
+	boolean()
+]);
+/**
+* One declared variable. Steps reference it as `{ $var: 'name' }` (the whole
+* value) or `{{vars.name}}` (inside a string) in their args.
+*/
+var ActionVariableSchema = object({
+	name: string().regex(ACTION_VARIABLE_NAME_RE),
+	label: string().min(1).max(120).optional(),
+	type: ActionVariableTypeSchema,
+	required: boolean().optional(),
+	default: ActionVariableValueSchema.optional(),
+	/** The allowed values of a `select`. */
+	options: array(string().min(1)).min(1).optional()
+}).superRefine((v, ctx) => {
+	if (v.type === "select" && v.options === void 0) ctx.addIssue({
+		code: "custom",
+		message: "a select variable needs options",
+		path: ["options"]
+	});
+	if (v.default !== void 0 && variableValueError(v, v.default) !== null) ctx.addIssue({
+		code: "custom",
+		message: variableValueError(v, v.default) ?? "invalid default",
+		path: ["default"]
+	});
+});
+/** Why `value` is not a legal value for the variable, or null when it is. */
+function variableValueError(variable, value) {
+	switch (variable.type) {
+		case "string": return typeof value === "string" ? null : `variable "${variable.name}" must be a string`;
+		case "number": return typeof value === "number" && Number.isFinite(value) ? null : `variable "${variable.name}" must be a number`;
+		case "boolean": return typeof value === "boolean" ? null : `variable "${variable.name}" must be true or false`;
+		case "select": return typeof value === "string" && (variable.options ?? []).includes(value) ? null : `variable "${variable.name}" must be one of ${(variable.options ?? []).join(", ")}`;
+	}
+}
+var ActionSourceKindSchema = _enum(["internal", "addon"]);
+function isInternalActionId(actionId) {
+	return actionId.startsWith("internal:") && actionId.length > 9;
+}
+/** The addon behind a `<addonId>:<localId>` id, or null for anything else (internal included). */
+function addonIdOfActionId(actionId) {
+	if (isInternalActionId(actionId)) return null;
+	const at = actionId.indexOf(":");
+	return at > 0 && at < actionId.length - 1 ? actionId.slice(0, at) : null;
+}
+var ActionStatusSchema = object({
+	isRunning: boolean(),
+	/** Ms epoch the latest run STARTED; null when it never ran. */
+	lastRunAt: number().nullable(),
+	/** The latest run's failure; null on success or when it never ran. */
+	lastError: string().nullable()
+});
+var ActionEntrySchema = object({
+	/** `internal:<uuid>` or `<addonId>:<localId>`. */
+	id: string().min(3),
+	name: string().min(1).max(120),
+	/** The addon that declared it; `core-blocks` for an internal one. */
+	addonId: string().min(1),
+	source: ActionSourceKindSchema,
+	/** An addon-declared entry is edited where it was declared. */
+	readOnly: boolean(),
+	/** Internal only: cap and wait steps. No action-in-action, so no cycles. */
+	steps: array(ActionStepSchema).min(1).max(50).optional(),
+	variables: array(ActionVariableSchema).max(20).optional(),
+	status: ActionStatusSchema
+}).superRefine((entry, ctx) => {
+	if (entry.source === "internal") {
+		if (!isInternalActionId(entry.id)) ctx.addIssue({
+			code: "custom",
+			message: "an internal action id is internal:<uuid>",
+			path: ["id"]
+		});
+		return;
+	}
+	if (entry.steps !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "only an internal action carries steps",
+		path: ["steps"]
+	});
+	if (!entry.readOnly) ctx.addIssue({
+		code: "custom",
+		message: "an addon action is read-only here",
+		path: ["readOnly"]
+	});
+	if (addonIdOfActionId(entry.id) === null) ctx.addIssue({
+		code: "custom",
+		message: "an addon action id is <addonId>:<localId>",
+		path: ["id"]
+	});
+});
+/** What an operator writes for an internal action. */
+var ActionInputSchema = object({
+	name: string().min(1).max(120),
+	steps: array(ActionStepSchema).min(1).max(50),
+	variables: array(ActionVariableSchema).max(20).optional()
+});
+/** Who started a run. Absent = the operator pressed it. */
+var ActionRunOriginSchema = object({ 
+/** The automation block whose step started it. */
+blockId: string().min(1).optional() });
+/** `started` = the caller did not ask to wait. */
+var ActionRunOutcomeSchema = union([AutomationRunOutcomeSchema, literal("started")]);
+var ActionRunResultSchema = object({
+	runId: string().min(1),
+	outcome: ActionRunOutcomeSchema,
+	/** Why it did not run, or what failed. */
+	message: string().optional()
+});
+_enum([
+	"not-found",
+	"read-only",
+	"invalid-variables",
+	"invalid-steps",
+	"not-linked",
+	"busy"
+]);
+object({
+	actionId: string(),
+	runId: string(),
+	isRunning: boolean(),
+	/** Set when the run ended. */
+	outcome: AutomationRunOutcomeSchema.optional(),
+	lastRunAt: number().nullable(),
+	lastError: string().nullable()
 });
 /**
 * `addon-pages` — system-scoped singleton aggregator cap. Public-facing
@@ -16875,7 +17499,22 @@ var BrokerProviderInfoSchema = object({
 		*/
 		interactiveConnectPath: string().min(1).optional(),
 		/** Relative hub path to disconnect the linked account (same popup pattern). */
-		interactiveDisconnectPath: string().min(1).optional()
+		interactiveDisconnectPath: string().min(1).optional(),
+		/**
+		* The kind signs in through a server-held interactive session instead of
+		* (or before) typed credentials. `basePath` is a hub-relative route set
+		* served by the owning addon (`/addon/<id>/...`) speaking the sign-in
+		* contract: `POST {basePath}/start` (body: the form's settings) answers
+		* `{ sessionId, loginUrl }`; `GET {basePath}/status?sessionId=` answers
+		* `{ phase: 'starting' | 'awaiting-login' | 'captured' | 'error' |
+		* 'cancelled', loginUrl, error }`; `POST {basePath}/commit`
+		* (`{ sessionId, name, brokerId? }`) stores the credentials on a new or
+		* existing broker and answers `{ brokerId }`; `POST {basePath}/cancel`
+		* (`{ sessionId }`) drops the session. The dialog that edits a broker
+		* offers it as the default path; the fields the session fills are
+		* marked `filledBySignIn` in the kind's settings schema.
+		*/
+		signIn: object({ basePath: string().min(1) }).optional()
 	}))
 });
 var ListInputSchema = object({ 
@@ -17952,7 +18591,7 @@ var CompositionEventPlanSchema = object({
 	stateField: string(),
 	fieldKey: string()
 });
-/** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.celsius`. */
+/** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.temperature`. */
 var CompositionProblemSchema = object({
 	code: _enum([
 		"reserved-variant",
@@ -17980,7 +18619,8 @@ var CompositionProblemSchema = object({
 		"native-capability-replace",
 		"mixed-quantity",
 		"helper-mismatch",
-		"member-constraint"
+		"member-constraint",
+		"retention"
 	]),
 	path: string(),
 	message: string()
@@ -18214,13 +18854,17 @@ Object.freeze({
 	latchedAt: {
 		kind: "fixed",
 		result: ["number", "null"]
+	},
+	schmitt: {
+		kind: "fixed",
+		result: ["boolean", "null"]
 	}
 });
 /**
 * One catalog row per base reading a group helper can build (D944 §3).
 * Data, not a form default written into the block.
 */
-var NOW = {
+var NOW$2 = {
 	fieldPath: "lastFetchedAt",
 	expr: "now"
 };
@@ -18234,6 +18878,8 @@ function numeric(input) {
 		family: "numeric",
 		deviceType: DeviceType.Sensor,
 		memberDeviceType: DeviceType.Sensor,
+		memberDeviceTypes: [DeviceType.Sensor],
+		activeWhen: void 0,
 		commandCaps: [],
 		baseUnit: baseUnitOf(input.quantity),
 		aggregates: NUMERIC_AGGREGATES,
@@ -18249,6 +18895,8 @@ function binary(input) {
 		family: "binary",
 		deviceType: DeviceType.Sensor,
 		memberDeviceType: DeviceType.Sensor,
+		memberDeviceTypes: [DeviceType.Sensor],
+		activeWhen: void 0,
 		commandCaps: [],
 		quantity: "none",
 		baseUnit: void 0,
@@ -18262,73 +18910,73 @@ var GROUP_TEMPLATES = [
 		summary: "Mean, median, min, max or sum of temperatures. Offline and unknown members are left out, never read as 0 °C.",
 		role: DeviceRole.TemperatureSensor,
 		outputCap: "temperature-sensor",
-		outputField: "celsius",
+		outputField: "temperature",
 		quantity: "temperature",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "humidity",
 		summary: "Humidity in percent. Offline and unknown members are left out, never read as 0 %.",
 		role: DeviceRole.HumiditySensor,
 		outputCap: "humidity-sensor",
-		outputField: "percent",
+		outputField: "humidity",
 		quantity: "humidity",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "pressure",
 		summary: "Pressure in hectopascals. Offline and unknown members are left out, never read as 0 hPa.",
 		role: DeviceRole.PressureSensor,
 		outputCap: "pressure-sensor",
-		outputField: "hpa",
+		outputField: "pressure",
 		quantity: "pressure",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "illuminance",
 		summary: "Illuminance in lux. Offline and unknown members are left out, never read as 0 lx.",
 		role: DeviceRole.AmbientLightSensor,
 		outputCap: "ambient-light-sensor",
-		outputField: "lux",
+		outputField: "illuminance",
 		quantity: "illuminance",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "power",
 		summary: "Power in watts, summed by default. Nobody reporting omits the key rather than writing 0 W.",
 		role: DeviceRole.PowerSensor,
 		outputCap: "power-meter",
-		outputField: "watts",
+		outputField: "power",
 		quantity: "power",
 		defaultAggregate: "sum",
 		empty: "omit",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "energy",
 		summary: "Energy in kilowatt-hours, summed by default. Nobody reporting omits the key rather than writing 0 kWh.",
 		role: DeviceRole.EnergySensor,
 		outputCap: "power-meter",
-		outputField: "kwhTotal",
+		outputField: "energy",
 		quantity: "energy",
 		defaultAggregate: "sum",
 		empty: "omit",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	numeric({
 		id: "battery",
 		summary: "Battery charge in percent. Offline and unknown members are left out, never read as 0 %.",
 		role: DeviceRole.BatterySensor,
 		outputCap: "battery",
-		outputField: "percentage",
+		outputField: "level",
 		quantity: "percentage",
 		defaultAggregate: "mean",
 		empty: "null",
@@ -18356,7 +19004,7 @@ var GROUP_TEMPLATES = [
 		quantity: "device",
 		defaultAggregate: "mean",
 		empty: "null",
-		companions: [NOW]
+		companions: [NOW$2]
 	}),
 	binary({
 		id: "motion",
@@ -18450,6 +19098,11 @@ var GROUP_TEMPLATES = [
 		summary: "On when at least one switch is on, or when all of them are. Offline and unknown members are left out of that decision, never read as off, and still receive the command.",
 		deviceType: DeviceType.Switch,
 		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
 		commandCaps: ["switch"]
 	}),
 	actuator({
@@ -18457,34 +19110,136 @@ var GROUP_TEMPLATES = [
 		summary: "On when at least one light is on, or when all of them are. Brightness and colour are offered only when every member has them. A command is not sent to a member that lacks it.",
 		deviceType: DeviceType.Light,
 		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
 		commandCaps: [
 			"switch",
 			"brightness",
 			"color"
 		]
+	}),
+	actuator({
+		id: "fan",
+		summary: "On when at least one fan is on, or when all of them are. Speed, preset, direction and oscillation are offered only when every fan has them. A command is not sent to a fan that lacks it.",
+		deviceType: DeviceType.Fan,
+		outputCap: "switch",
+		outputField: "on",
+		member: {
+			cap: "switch",
+			fieldPath: "on"
+		},
+		commandCaps: ["switch", "fan-control"]
+	}),
+	actuator({
+		id: "cover",
+		summary: "Open when at least one cover is open or part-open, or only when all of them are. Position and tilt are offered only when every cover has them. A cover that reports nothing is left out, never read as closed.",
+		deviceType: DeviceType.Cover,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "cover",
+			fieldPath: "state"
+		},
+		activeWhen: [
+			"open",
+			"opening",
+			"stopped"
+		],
+		commandCaps: ["cover"]
+	}),
+	actuator({
+		id: "valve",
+		summary: "Open when at least one valve is open or part-open, or only when all of them are. Position is offered only when every valve has it. A valve that reports nothing is left out, never read as closed.",
+		deviceType: DeviceType.Valve,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "valve",
+			fieldPath: "state"
+		},
+		activeWhen: [
+			"open",
+			"opening",
+			"stopped"
+		],
+		commandCaps: ["valve"]
+	}),
+	actuator({
+		id: "lock",
+		summary: "Locked when at least one lock is locked, or only when all of them are. A jammed or moving lock is not locked. Locking is one tap; unlocking the group needs a confirmation every time, and nothing is sent without it.",
+		deviceType: DeviceType.Lock,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "lock-control",
+			fieldPath: "state"
+		},
+		activeWhen: ["locked"],
+		commandCaps: ["lock-control"]
+	}),
+	actuator({
+		id: "media-player",
+		summary: "Playing when at least one player is playing, or only when all of them are. Volume is offered only when every player has it. A player that reports nothing is left out, never read as stopped.",
+		deviceType: DeviceType.MediaPlayer,
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "media-player",
+			fieldPath: "state"
+		},
+		activeWhen: ["playing", "buffering"],
+		commandCaps: ["media-player"]
+	}),
+	actuator({
+		id: "climate",
+		summary: "Running when at least one thermostat or air conditioner is not off, or only when all of them are. Target temperature and fan are offered only when every device has them. A device that reports nothing is left out, never read as off.",
+		deviceType: DeviceType.Thermostat,
+		memberDeviceTypes: [DeviceType.Thermostat, DeviceType.Climate],
+		outputCap: "group-active",
+		outputField: "active",
+		member: {
+			cap: "climate-control",
+			fieldPath: "mode"
+		},
+		activeWhen: [
+			"heat",
+			"cool",
+			"auto",
+			"heat_cool",
+			"fan_only",
+			"dry"
+		],
+		commandCaps: ["climate-control"]
 	})
 ];
 function actuator(input) {
 	return {
-		...input,
+		id: input.id,
+		summary: input.summary,
+		deviceType: input.deviceType,
+		outputCap: input.outputCap,
+		outputField: input.outputField,
+		commandCaps: input.commandCaps,
 		family: "actuator",
 		role: void 0,
 		memberDeviceType: input.deviceType,
-		outputField: "on",
+		memberDeviceTypes: input.memberDeviceTypes ?? [input.deviceType],
+		activeWhen: input.activeWhen,
 		quantity: "none",
 		baseUnit: void 0,
 		aggregates: BINARY_AGGREGATES,
 		defaultAggregate: "any",
 		empty: "offline",
-		accept: [{
-			cap: "switch",
-			fieldPath: "on"
-		}],
+		accept: [input.member],
 		companions: [CHANGED]
 	};
 }
 new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
 DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired;
+DeviceType.Camera;
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
 * What a composition may BUILD on a device type (G2, D676): the caps a new
@@ -18799,7 +19554,18 @@ method(object({}), object({ blocks: array(CoreBlockSchema) }), { auth: "admin" }
 	kind: "mutation",
 	auth: "admin",
 	access: "view"
-});
+}), method(object({
+	blockId: string().min(1),
+	trace: AutomationRunTraceSchema.optional(),
+	runStartedAt: number().optional(),
+	keepTraces: number().int().min(1).max(100).optional()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ blockId: string().min(1) }), AutomationStateDocSchema, { auth: "admin" }), method(object({ blockId: string().min(1) }), object({
+	traces: array(AutomationRunTraceSchema),
+	lastError: string().nullable()
+}), { auth: "admin" });
 /**
 * `custom-model-registry` — collection cap exposing operator-registered
 * custom detection models. Each provider (today: `addon-model-studio`)
@@ -43804,7 +44570,7 @@ var NetworkAccessStatusSchema = object({
 });
 /**
 * Optional, richer endpoint shape returned by providers that expose
-* MORE than one ingress concurrently (Tailscale Ingress with mixed
+* MORE than one ingress concurrently (Tailscale Funnel with mixed
 * serve+funnel rules, future ngrok multi-tunnel, …). Each entry carries
 * the originating provider config (mode + sourcePort) so the
 * orchestrator UI can label rows distinctly. Providers that expose only
@@ -44197,51 +44963,6 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	kind: "mutation",
 	auth: "admin"
 });
-new Set([
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-].map((l) => l.id));
-var COCO_TO_MACRO = {
-	mapping: {
-		person: "person",
-		bicycle: "vehicle",
-		car: "vehicle",
-		motorcycle: "vehicle",
-		airplane: "vehicle",
-		bus: "vehicle",
-		train: "vehicle",
-		truck: "vehicle",
-		boat: "vehicle",
-		bird: "animal",
-		cat: "animal",
-		dog: "animal",
-		horse: "animal",
-		sheep: "animal",
-		cow: "animal",
-		elephant: "animal",
-		bear: "animal",
-		zebra: "animal",
-		giraffe: "animal",
-		suitcase: "package",
-		backpack: "package",
-		handbag: "package"
-	},
-	preserveOriginal: false
-};
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
@@ -46491,7 +47212,20 @@ var NcRuleInputSchema = object({
 	* save by the hub's grouping guard). `.optional()`, never `.default()`: the addon cap
 	* path does not run Zod defaults.
 	*/
-	groupingSec: number().int().min(5).max(60).optional()
+	groupingSec: number().int().min(5).max(60).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
+	* same mark the Library writes, and records whose notification it was and
+	* when. A channel with no buttons gets the same two choices as links.
+	*
+	* `.optional()`, never `.default()` (a Zod default does not run on the addon
+	* cap path): absent and `false` both mean off, which is what every rule
+	* authored before this field meant. An editor turns it off by writing
+	* `false`, so it needs no `clear` key.
+	*/
+	askVerdict: boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -56795,9 +57529,9 @@ method(object({ nodeId: string().optional() }).optional(), array(AddonListItemSc
 */
 var AirQualitySensorStatusSchema = object({
 	/** Carbon dioxide concentration in ppm. */
-	co2Ppm: number().min(0).optional().meta(readingMeta("concentration-volume")),
+	co2: number().min(0).optional().meta(readingMeta("concentration-volume")),
 	/** Total volatile organic compounds in ppb. */
-	vocPpb: number().min(0).optional().meta(readingMeta("concentration-ppb")),
+	voc: number().min(0).optional().meta(readingMeta("concentration-ppb")),
 	/** Particulate matter ≤ 2.5 μm in µg/m³. */
 	pm25: number().min(0).optional().meta(readingMeta("concentration-mass")),
 	/** Particulate matter ≤ 10 μm in µg/m³. */
@@ -56830,12 +57564,12 @@ var airQualitySensorCapability = {
 	* History (D850): recorded series.
 	*/
 	history: { fields: {
-		co2Ppm: {
+		co2: {
 			kind: "gauge",
 			unit: "ppm",
 			deadband: 5
 		},
-		vocPpb: {
+		voc: {
 			kind: "gauge",
 			unit: "ppb",
 			deadband: 5
@@ -56866,7 +57600,7 @@ var airQualitySensorCapability = {
 */
 var AmbientLightSensorStatusSchema = object({
 	/** Current illuminance in lux (lx). `null` when the sample was refused (D393). */
-	lux: number().min(0).nullable().meta(readingMeta("illuminance", {
+	illuminance: number().min(0).nullable().meta(readingMeta("illuminance", {
 		precision: 0,
 		label: "Illuminance"
 	})),
@@ -56895,7 +57629,7 @@ var ambientLightSensorCapability = {
 	/**
 	* History (D850): recorded series. Wide range, so a RELATIVE deadband (10 %).
 	*/
-	history: { fields: { lux: {
+	history: { fields: { illuminance: {
 		kind: "gauge",
 		unit: "lx",
 		deadbandPct: 10,
@@ -57034,6 +57768,84 @@ var audioMetricsCapability = {
 	*/
 	history: "none"
 };
+method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
+	actionId: string().min(1),
+	variables: record(string(), ActionVariableValueSchema).optional()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ actionId: string().min(1) }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
+* actions — the ONE surface for runnable actions, for the UI and for
+* automations. Provided by the core-blocks builtin on the hub.
+*
+* An action is a LIST ENTRY, not a device (D883): either internal (cap and wait
+* steps, kept in the hub's `actions` record kind) or declared by an addon over
+* `action-source`. `list` asks every `action-source` provider LIVE and overlays
+* the run status from the hub's `runs` ledger; there is no catalog here to
+* drift (D3).
+*
+* **Permissions follow the camera, as linked devices do.** An action is linked
+* to cameras by the operator (`setLinks`, D356: nothing links itself). A
+* non-admin may `get` / `run` an action only through a camera they may see that
+* links it: they name the camera (`deviceId`, a top-level field so the scope
+* gate sees it) and the provider refuses an action that camera does not link.
+* An admin, and an in-process caller (an automation block), may run any action.
+* Every refusal is typed (`[not-linked] …`) and logged.
+*
+* A second `run` of an action that is already running is REFUSED — traced and
+* logged — never queued.
+*/
+var ActionIdInput = object({ actionId: string().min(1) });
+var ActionLinksSchema = object({
+	deviceId: number().int().nonnegative(),
+	actionIds: array(string().min(1)).max(100)
+});
+method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
+	actionId: string().min(1),
+	deviceId: number().int().nonnegative().optional()
+}), object({ action: ActionEntrySchema.nullable() }), {
+	role: "viewer",
+	auth: "protected",
+	kind: "query",
+	caller: "required"
+}), method(object({
+	actionId: string().min(1),
+	variables: record(string(), ActionVariableValueSchema).optional(),
+	wait: boolean().optional(),
+	origin: ActionRunOriginSchema.optional(),
+	deviceId: number().int().nonnegative().optional()
+}), ActionRunResultSchema, {
+	role: "viewer",
+	auth: "protected",
+	kind: "mutation",
+	caller: "required"
+}), method(ActionIdInput, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ActionIdInput, object({ traces: array(AutomationRunTraceSchema) }), { auth: "admin" }), method(object({ action: ActionInputSchema }), object({ action: ActionEntrySchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	actionId: string().min(1),
+	action: ActionInputSchema.partial()
+}), object({ action: ActionEntrySchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ActionIdInput, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), array(ActionEntrySchema), {
+	role: "viewer",
+	auth: "protected",
+	kind: "query"
+}), method(object({ deviceId: number().int().nonnegative() }), ActionLinksSchema, { auth: "admin" }), method(ActionLinksSchema, ActionLinksSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
 /**
 * Automation-control cap. Models HA `automation.*` entities on
 * `DeviceType.Automation`. An automation is a trigger+condition+
@@ -57130,7 +57942,7 @@ var BatteryStatusSchema = object({
 	* Consumers must SKIP a null rather than coerce it — `battery-band` already
 	* declines to band a non-finite reading, which is the correct shape.
 	*/
-	percentage: number().min(0).max(100).nullable().meta(readingMeta("percentage", { label: "Charge" })),
+	level: number().min(0).max(100).nullable().meta(readingMeta("percentage", { label: "Charge" })),
 	/**
 	* Charging source. `'dc'` covers wall/USB adapters; `'solar'` is
 	* Reolink-specific for the Solar Panel 2 accessory (will become
@@ -57140,7 +57952,7 @@ var BatteryStatusSchema = object({
 	* `'unknown'` is the absence of an answer: the provider has not read the
 	* power fields yet, or the firmware reported neither. Before it existed,
 	* two unreadable fields produced `'none'`, and a camera nobody had reached
-	* was drawn "on battery alone" — the same D315 defect `percentage` closed
+	* was drawn "on battery alone" — the same D315 defect `level` closed
 	* by going nullable. Consumers SKIP it (no charger state published, no
 	* glyph, no HomeKit ChargingState) rather than coerce it either way.
 	*/
@@ -57164,7 +57976,7 @@ var BatteryStatusSchema = object({
 	* that only report charge. A second reading on this cap, not a second
 	* `numeric-sensor` on the same device.
 	*/
-	volts: number().nullable().optional().meta(readingMeta("voltage", { label: "Voltage" })),
+	voltage: number().nullable().optional().meta(readingMeta("voltage", { label: "Voltage" })),
 	/**
 	* Ms epoch of the last time the device PROVED it was reachable — a
 	* completed firmware round-trip, an observed wake, or an inbound push
@@ -57198,7 +58010,7 @@ var BatteryStatusSchema = object({
 	/**
 	* True when the source is a BINARY low-battery indicator (HA
 	* `binary_sensor` device_class=battery / `LOW_BAT`) that has no real
-	* charge level — `percentage` is then a coarse stand-in (100 = normal,
+	* charge level — `level` is then a coarse stand-in (100 = normal,
 	* sub-threshold = low). UI MUST render "Normal"/"Low" instead of a
 	* misleading exact percentage. Absent/false → genuine 0–100 % reading.
 	*/
@@ -57211,21 +58023,22 @@ var BATTERY_DEVICE_TYPES = [
 	DeviceType.Switch,
 	DeviceType.PetFeeder,
 	DeviceType.Container,
-	DeviceType.Thermostat
+	DeviceType.Thermostat,
+	DeviceType.EventEmitter
 ];
 /** Generic Customize target for the percentage reading (D936). */
 var batteryCustomize = {
 	version: 1,
 	targets: [{
-		id: "percentage",
+		id: "level",
 		cardinality: "scalar",
 		vocabulary: {
 			cap: "battery",
-			stateField: "percentage"
+			stateField: "level"
 		},
 		deviceTypes: BATTERY_DEVICE_TYPES,
 		apply: "add",
-		path: "percentage",
+		path: "level",
 		sources: [{
 			kind: "field",
 			valueKinds: ["number", "string"],
@@ -57319,7 +58132,7 @@ onStatusChanged: { data: object({
 		schema: BatteryStatusSchema,
 		kind: "push",
 		empty: {
-			percentage: null,
+			level: null,
 			charging: "unknown",
 			sleeping: false,
 			lastUpdated: 0
@@ -57346,11 +58159,11 @@ onStatusChanged: { data: object({
 	* History (D850): recorded series. The generic capture replaces the `battery` series of `pipeline-analytics:stats-5m`.
 	*/
 	history: { fields: {
-		percentage: {
+		level: {
 			kind: "gauge",
 			unit: "%"
 		},
-		volts: {
+		voltage: {
 			kind: "gauge",
 			unit: "V"
 		}
@@ -57410,14 +58223,14 @@ var binaryCapability = {
 * controls to this single-method surface.
 *
 * The cap is intentionally minimal: a single `setBrightness({deviceId,
-* percentage})` mutation plus the auto-injected `getStatus`. Drivers
+* level})` mutation plus the auto-injected `getStatus`. Drivers
 * that expose richer controls (color temperature, scenes, schedules)
 * should surface those via the device's `getSettingsUISchema()`
 * instead of bloating this cap.
 */
 var BrightnessStatusSchema = object({
 	/** Current level as 0..100 inclusive. Firmware-reported. */
-	percentage: number().min(0).max(100).meta(readingMeta("percentage")),
+	level: number().min(0).max(100).meta(readingMeta("percentage")),
 	/** Ms epoch of the last operator-driven change. Useful for UI freshness. */
 	lastChangedAt: number()
 });
@@ -57429,7 +58242,7 @@ var brightnessCapability = {
 	deviceTypes: [DeviceType.Light],
 	methods: { setBrightness: method(object({
 		deviceId: number().int().nonnegative(),
-		percentage: number().min(0).max(100)
+		level: number().min(0).max(100)
 	}), _void(), {
 		kind: "mutation",
 		auth: "protected"
@@ -57442,7 +58255,7 @@ var brightnessCapability = {
 	*/
 onBrightnessChanged: { data: object({
 		deviceId: number(),
-		percentage: number().min(0).max(100),
+		level: number().min(0).max(100),
 		lastChangedAt: number()
 	}) } },
 	status: {
@@ -57465,7 +58278,7 @@ onBrightnessChanged: { data: object({
 	/**
 	* History (D850): recorded series. Actuator tier: level keeps every change.
 	*/
-	history: { fields: { percentage: {
+	history: { fields: { level: {
 		kind: "gauge",
 		unit: "%",
 		minIntervalMs: 0
@@ -58079,11 +58892,11 @@ var ColorInputSchema = discriminatedUnion("mode", [
 	}),
 	object({
 		mode: literal("mired"),
-		mireds: number().int().min(50).max(1e3)
+		colorTemperature: number().int().min(50).max(1e3)
 	})
 ]);
 var ColorStatusSchema = object({
-	/** Active color mode — which of `rgb` / `hsv` / `mireds` reflects
+	/** Active color mode — which of `rgb` / `hsv` / `colorTemperature` reflects
 	*  the bulb's current state. */
 	mode: _enum([
 		"rgb",
@@ -58095,7 +58908,7 @@ var ColorStatusSchema = object({
 	/** Populated when `mode === 'hsv'`. */
 	hsv: HsvTripletSchema.optional(),
 	/** Populated when `mode === 'mired'`. */
-	mireds: number().int().optional().meta(readingMeta("colour-temperature")),
+	colorTemperature: number().int().optional().meta(readingMeta("colour-temperature")),
 	/** Ms epoch of the last operator-driven change. */
 	lastChangedAt: number()
 });
@@ -58127,7 +58940,7 @@ onColorChanged: { data: object({
 		]),
 		rgb: RgbTripletSchema.optional(),
 		hsv: HsvTripletSchema.optional(),
-		mireds: number().int().optional(),
+		colorTemperature: number().int().optional(),
 		lastChangedAt: number()
 	}) } },
 	status: {
@@ -59004,11 +59817,11 @@ var DishwasherStatusSchema = object({
 	/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
 	availablePrograms: array(string()),
 	/** Seconds remaining on the active cycle, or null when not running / not known. */
-	remainingSeconds: number().int().nonnegative().nullable().meta(readingMeta("duration")),
+	remaining: number().int().nonnegative().nullable().meta(readingMeta("duration")),
 	/** Seconds the delayed start is set to (time until the cycle starts), or null. */
-	delayedStartSeconds: number().int().nonnegative().nullable().meta(readingMeta("duration")),
+	delayedStart: number().int().nonnegative().nullable().meta(readingMeta("duration")),
 	/** Cycle completion 0..100, or null when not applicable. */
-	progressPercent: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	progress: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** True when the door is reported open; null when the door state is not known. */
 	doorOpen: boolean().nullable(),
 	/** True when the door is latched (locked) during a cycle; null when not reported. */
@@ -59227,14 +60040,14 @@ var dishwasherCapability = {
 	runtimeState: DishwasherStatusSchema,
 	durability: "session",
 	history: { fields: {
-		progressPercent: {
+		progress: {
 			kind: "gauge",
 			unit: "%",
 			deadband: 2
 		},
 		state: { kind: "enum" },
 		operationState: { kind: "enum" },
-		remainingSeconds: {
+		remaining: {
 			kind: "gauge",
 			unit: "s",
 			minIntervalMs: 6e4
@@ -59825,7 +60638,7 @@ var FanDirectionSchema = _enum(["forward", "reverse"]);
 var FanControlStatusSchema = object({
 	/** Active speed as 0..100 inclusive. Null when the device has no
 	*  speed surface (single-speed fan). */
-	percentage: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	speed: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Speed granularity the device accepts (HA `percentage_step`, e.g. 25 for
 	*  a 4-speed fan). Absent when unknown — the UI then falls back to step 1. */
 	percentageStep: number().positive().optional().meta(readingMeta("percentage")),
@@ -59852,7 +60665,7 @@ var fanControlCapability = {
 	methods: {
 		setPercentage: method(object({
 			deviceId: number().int().nonnegative(),
-			percentage: number().min(0).max(100)
+			speed: number().min(0).max(100)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -59885,7 +60698,7 @@ var fanControlCapability = {
 	},
 	/**
 	* Runtime-state slice — mirrored by the kernel. UI fan speed
-	* sliders read `percentage` for live updates.
+	* sliders read `speed` for live updates.
 	*/
 	runtimeState: FanControlStatusSchema,
 	/**
@@ -59899,7 +60712,7 @@ var fanControlCapability = {
 	* History (D850): recorded series. Actuator tier: speed keeps every change.
 	*/
 	history: { fields: {
-		percentage: {
+		speed: {
 			kind: "gauge",
 			unit: "%",
 			minIntervalMs: 0
@@ -60088,7 +60901,17 @@ var groupCommandsCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Switch, DeviceType.Light],
+	deviceTypes: [
+		DeviceType.Switch,
+		DeviceType.Light,
+		DeviceType.Fan,
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Thermostat,
+		DeviceType.Climate
+	],
 	methods: {},
 	status: {
 		schema: GroupCommandsSchema,
@@ -60106,6 +60929,49 @@ var groupCommandsCapability = {
 	history: "none"
 };
 /**
+* Whether a helper actuator group counts as active (D944): at least one
+* included member is, or every included member is. What "active" means is the
+* type's: a cover is open, a lock is locked, a media player is playing, a
+* climate device is not off. A group of lights, switches and fans reports
+* `switch.on` instead; this cap is for the types whose own state is not a
+* yes/no. Unknown members are left out (`group-status` counts them) and an
+* empty included set takes the device offline, never `active: false`.
+*/
+var GroupActiveSchema = object({
+	active: boolean().meta({ label: "Active" }),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+var groupActiveCapability = {
+	name: "group-active",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Climate,
+		DeviceType.Thermostat
+	],
+	methods: {},
+	status: {
+		schema: GroupActiveSchema,
+		kind: "push"
+	},
+	runtimeState: GroupActiveSchema,
+	/**
+	* Runtime-state durability: **session** — recomputed from the members on the
+	* next source event; a restored value would outlive the members it named.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
+/**
 * How many members of a helper group answered (D944). Counts are integers,
 * not measurements: zero included is a real count, never a stand-in reading.
 * The reading itself stays on the output capability. History is none — the
@@ -60136,7 +61002,14 @@ var groupStatusCapability = {
 	deviceTypes: [
 		DeviceType.Sensor,
 		DeviceType.Switch,
-		DeviceType.Light
+		DeviceType.Light,
+		DeviceType.Fan,
+		DeviceType.Cover,
+		DeviceType.Valve,
+		DeviceType.Lock,
+		DeviceType.MediaPlayer,
+		DeviceType.Thermostat,
+		DeviceType.Climate
 	],
 	methods: {},
 	status: {
@@ -60284,7 +61157,7 @@ var humidifierCapability = {
 */
 var HumiditySensorStatusSchema = object({
 	/** Current relative humidity, 0..100. `null` when the sample was refused (D393). */
-	percent: number().min(0).max(100).nullable().meta(readingMeta("humidity", {
+	humidity: number().min(0).max(100).nullable().meta(readingMeta("humidity", {
 		precision: 0,
 		label: "Humidity"
 	})),
@@ -60313,7 +61186,7 @@ var humiditySensorCapability = {
 	/**
 	* History (D850): recorded series.
 	*/
-	history: { fields: { percent: {
+	history: { fields: { humidity: {
 		kind: "gauge",
 		unit: "%",
 		deadband: .5
@@ -60953,7 +61826,7 @@ var LawnMowerControlStatusSchema = object({
 	batteryLevel: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** 0..100 mowing-completion percentage of the current task, or null when no
 	*  task is active / progress is unavailable. */
-	progressPercent: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	progress: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Current device/event code (dynamic — mostly status, sometimes an error),
 	*  or null when unknown. */
 	currentCode: number().nullable().meta(readingMeta("none")),
@@ -61409,7 +62282,14 @@ var lockControlCapability = {
 		}),
 		unlock: method(object({
 			deviceId: number().int().nonnegative(),
-			code: string().min(1).optional()
+			code: string().min(1).optional(),
+			/**
+			* Honoured by a helper lock GROUP only (D944): unlocking several doors
+			* with one call is refused unless the caller says it was confirmed. A
+			* single lock ignores it. The refusal lives in the callee, so no
+			* automation or API caller reaches the doors by skipping a dialog.
+			*/
+			confirm: boolean().optional()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -61446,6 +62326,44 @@ var lockControlCapability = {
 	volatileStateFields: ["lastChangedAt"]
 };
 /**
+* A monotonic total between resets (D944). Energy uses `power-meter.energy`
+* so dashboards keep one series; every other instantaneous reading lands here.
+* `value` is the time integral in the source quantity's accumulated base
+* (base-unit seconds, or kWh on the power meter). `null` is a gap, never zero.
+*/
+var MeterStatusSchema = object({
+	value: number().nullable().meta(readingMeta("device", { label: "Total" })),
+	lastFetchedAt: number()
+});
+var meterCapability = {
+	name: "meter",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Sensor],
+	methods: {},
+	status: {
+		schema: MeterStatusSchema,
+		kind: "push"
+	},
+	runtimeState: MeterStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — the total is a cache of the
+	* history integral. A restart shows it only until the history pass
+	* recomputes the open period; it is not an in-memory buffer.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	history: { fields: { value: {
+		kind: "counter",
+		deadband: .001,
+		minIntervalMs: 6e4
+	} } },
+	volatileStateFields: ["lastFetchedAt"]
+};
+/**
 * Media-player cap. Models HA `media_player.*` (Sonos, Chromecast,
 * Apple TV, Spotify, Roku, generic OTT receivers, …) on
 * `DeviceType.MediaPlayer`. Disjoint from the camera streaming
@@ -61502,10 +62420,10 @@ var MediaPlayerStatusSchema = object({
 	currentMedia: MediaInfoSchema.nullable(),
 	/** Current playback position in ms. Null when not seekable or
 	*  nothing is playing. Pair with `DeviceFeature.MediaPlayerSeek`. */
-	positionMs: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
+	position: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
 	/** Total duration of the current media in ms. Null when unknown
 	*  (live stream) or nothing is playing. */
-	durationMs: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
+	duration: number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
 	/** Shuffle toggle. Null when no shuffle surface.
 	*  Pair with `DeviceFeature.MediaPlayerShuffle`. */
 	shuffle: boolean().nullable(),
@@ -61544,7 +62462,7 @@ var mediaPlayerCapability = {
 		}),
 		seek: method(object({
 			deviceId: number().int().nonnegative(),
-			positionMs: number().int().nonnegative()
+			position: number().int().nonnegative()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -61616,7 +62534,7 @@ var mediaPlayerCapability = {
 	/**
 	* History (D850): volume (a level an operator or an automation sets; the
 	* default 10 s floor folds a slider drag into its end value) and mute.
-	* `positionMs` is not recorded: it moves continuously while playing.
+	* `position` is not recorded: it moves continuously while playing.
 	*/
 	history: { fields: {
 		volumeLevel: {
@@ -62578,9 +63496,9 @@ var NetworkLinkStatusSchema = object({
 	* one whose reading has not landed must not be drawn at 0 %. Consumers
 	* SKIP a null rather than coerce it.
 	*/
-	signalPercent: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	signal: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Raw received signal strength in dBm, when the firmware reports one. */
-	rssiDbm: number().optional().meta(readingMeta("signal-level")),
+	rssi: number().optional().meta(readingMeta("signal-level")),
 	/** Network name of a wireless link, when the firmware reports it. */
 	ssid: string().optional(),
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
@@ -62616,7 +63534,7 @@ onStatusChanged: { data: object({
 		kind: "push",
 		empty: {
 			type: "unknown",
-			signalPercent: null,
+			signal: null,
 			lastUpdated: 0
 		}
 	},
@@ -62639,13 +63557,13 @@ onStatusChanged: { data: object({
 	* History (D850): recorded series.
 	*/
 	history: { fields: {
-		signalPercent: {
+		signal: {
 			kind: "gauge",
 			unit: "%",
 			deadband: 3,
 			minIntervalMs: 6e4
 		},
-		rssiDbm: {
+		rssi: {
 			kind: "gauge",
 			unit: "dBm",
 			deadband: 2,
@@ -63390,10 +64308,20 @@ var PetFeederDeviceStatusSchema = _enum([
 ]);
 var gramsPortion = number().int().min(4).max(200);
 var PetFeederStatusSchema = object({
-	/** Food currently in the bowl (grams). Null when the device has not
-	*  reported a reading yet. On dual-hopper models this is the combined
-	*  bowl reading; per-hopper levels live in `food1`/`food2`. */
+	/** Food in the TANK (hopper), as the feeder's own sensor reports it
+	*  (`state.food`). A coarse level code, not grams — `0` is empty. The
+	*  amount in the bowl is `bowlFood`. On dual-hopper models this is the
+	*  combined reading; per-hopper levels live in `food1`/`food2`. Null when
+	*  the device has not reported yet. */
 	foodLevel: number().nullable().meta(readingMeta("none")),
+	/** Food in the BOWL as the feeder reports it (`state.bowl`), in the
+	*  feeder's own units. Null when the model reports none. */
+	bowlFood: number().nullable().meta(readingMeta("none")),
+	/** True while the pet is eating (`state.eating`). */
+	eating: boolean(),
+	/** Whether `markFoodReplenished` does anything on this model. When false
+	*  the client must not offer it. */
+	supportsMarkRefilled: boolean(),
 	/** Hopper-1 food level (grams) on dual-hopper feeders; null on
 	*  single-hopper models. */
 	food1: number().nullable().meta(readingMeta("none")),
@@ -63401,8 +64329,8 @@ var PetFeederStatusSchema = object({
 	*  single-hopper models. */
 	food2: number().nullable().meta(readingMeta("none")),
 	/** Derived low-food flag — mirrors the HA `food_level` binary_sensor
-	*  (`device_class: problem`, on = low). True when the bowl is empty /
-	*  below the feeder's low threshold. */
+	*  (`device_class: problem`, on = low). True when the tank reports empty,
+	*  or, on a dual-hopper model, when EITHER hopper is empty. */
 	lowFood: boolean(),
 	/** Battery charge 0..100 (%). Null on mains-powered models or when the
 	*  device has no battery reading. */
@@ -63470,7 +64398,9 @@ var petFeederCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		/** Mark a hopper as refilled (D4H/D4S/D4SH). */
+		/** Tell the PetKit cloud a hopper was refilled so it stops its low-food
+		*  reminders (D4H/D4S/D4SH only — see `supportsMarkRefilled`). It does not
+		*  change any sensor reading. */
 		markFoodReplenished: method(object({ deviceId: number().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -63543,6 +64473,7 @@ var petFeederCapability = {
 	*/
 	history: { fields: {
 		foodLevel: { kind: "gauge" },
+		bowlFood: { kind: "gauge" },
 		food1: { kind: "gauge" },
 		food2: { kind: "gauge" },
 		batteryPower: {
@@ -63952,27 +64883,89 @@ method(_void(), PlatformCapabilitiesSchema), method(_void(), HardwareInfoSchema)
 * in real-world devices.
 */
 var PowerMeterStatusSchema = object({
-	/** Instantaneous power draw in watts. */
-	watts: number().optional().meta(readingMeta("power", { label: "Power" })),
+	/** Instantaneous power draw (watts). */
+	power: number().optional().meta(readingMeta("power", { label: "Power" })),
 	/** Cumulative energy in kilowatt-hours since the meter was reset. */
-	kwhTotal: number().optional().meta(readingMeta("energy", { label: "Energy" })),
-	/** Voltage in volts. */
-	volts: number().optional().meta(readingMeta("voltage")),
+	energy: number().optional().meta(readingMeta("energy", { label: "Energy" })),
+	/** Voltage (volts). */
+	voltage: number().optional().meta(readingMeta("voltage", { label: "Voltage" })),
 	/** Current in amperes. */
-	amps: number().optional().meta(readingMeta("current")),
+	current: number().optional().meta(readingMeta("current", { label: "Current" })),
 	/** Apparent power in volt-amperes. */
-	va: number().optional().meta(readingMeta("apparent-power")),
+	apparentPower: number().optional().meta(readingMeta("apparent-power")),
 	/** Power factor (0..1) if reported. */
 	powerFactor: number().min(0).max(1).optional().meta(readingMeta("ratio")),
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: number()
 });
+/**
+* Loads that draw metered mains power (D951). The reading is a feature of the
+* device itself — a plug, a lamp, a fan, an air conditioner, a boiler, a
+* vacuum dock — not a separate sensor beside it. A `Sensor` stays: a clamp
+* meter or a standalone energy monitor IS the device. Cover, lock, valve,
+* camera and the like are left out: their draw is not what anyone meters.
+*/
+var POWER_METER_DEVICE_TYPES = [
+	DeviceType.Sensor,
+	DeviceType.Switch,
+	DeviceType.Light,
+	DeviceType.Fan,
+	DeviceType.Climate,
+	DeviceType.Thermostat,
+	DeviceType.Humidifier,
+	DeviceType.WaterHeater,
+	DeviceType.MediaPlayer,
+	DeviceType.Washer,
+	DeviceType.Dryer,
+	DeviceType.Dishwasher,
+	DeviceType.Vacuum,
+	DeviceType.LawnMower,
+	DeviceType.PetFeeder
+];
+/** Everything but a bare `Sensor`: a sensor that takes its reading from another sensor adds nothing. */
+var POWER_METER_CUSTOMIZE_DEVICE_TYPES = POWER_METER_DEVICE_TYPES.filter((type) => type !== DeviceType.Sensor);
+/** One scalar target per reading; each is sourced from a device of its own (D951). */
+function powerTarget(id, unit) {
+	return {
+		id,
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "power-meter",
+			stateField: id
+		},
+		deviceTypes: POWER_METER_CUSTOMIZE_DEVICE_TYPES,
+		apply: "add",
+		path: id,
+		sources: [{
+			kind: "numeric",
+			requiredUnit: unit,
+			transforms: [{ kind: "identity" }]
+		}],
+		companions: [{
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "always"
+		}],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	};
+}
+/** "Power and energy" extension: power, energy, voltage and current from other devices (D951). */
+var powerMeterCustomize = {
+	version: 1,
+	targets: [
+		powerTarget("power", "W"),
+		powerTarget("energy", "kWh"),
+		powerTarget("voltage", "V"),
+		powerTarget("current", "A")
+	]
+};
 var powerMeterCapability = {
 	name: "power-meter",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Sensor],
+	deviceTypes: POWER_METER_DEVICE_TYPES,
 	methods: {},
 	status: {
 		schema: PowerMeterStatusSchema,
@@ -63980,41 +64973,41 @@ var powerMeterCapability = {
 	},
 	runtimeState: PowerMeterStatusSchema,
 	/**
-	* Runtime-state durability: **restored** — as `numeric-sensor`; `kwhTotal` is an accumulator whose restored value is the baseline.
+	* Runtime-state durability: **restored** — as `numeric-sensor`; `energy` is an accumulator whose restored value is the baseline.
 	*
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
 	/**
-	* History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
+	* History (D850): recorded series. Gauges are floored at 30 s; `energy` is the one monotonic meter (counter).
 	*/
 	history: { fields: {
-		watts: {
+		power: {
 			kind: "gauge",
 			unit: "W",
 			deadband: 1,
 			minIntervalMs: 3e4
 		},
-		kwhTotal: {
+		energy: {
 			kind: "counter",
 			unit: "kWh",
 			deadband: .01,
 			minIntervalMs: 6e4
 		},
-		volts: {
+		voltage: {
 			kind: "gauge",
 			unit: "V",
 			deadband: 1,
 			minIntervalMs: 3e4
 		},
-		amps: {
+		current: {
 			kind: "gauge",
 			unit: "A",
 			deadband: .05,
 			minIntervalMs: 3e4
 		},
-		va: {
+		apparentPower: {
 			kind: "gauge",
 			unit: "VA",
 			deadband: 1,
@@ -64029,7 +65022,8 @@ var powerMeterCapability = {
 	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"]
+	volatileStateFields: ["lastFetchedAt"],
+	customize: powerMeterCustomize
 };
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
@@ -64063,9 +65057,6 @@ var PresenceStatusSchema = object({
 	location: string().nullable(),
 	/** GPS coordinates when available. Null otherwise. */
 	gps: GpsLocationSchema.nullable(),
-	/** Optional battery level of the tracking device (0..100). Null
-	*  when not reported. */
-	batteryPercent: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: number()
 });
@@ -64094,14 +65085,7 @@ var presenceCapability = {
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
 	durability: "restored",
-	/**
-	* History (D850): recorded series.
-	*/
-	history: { fields: { batteryPercent: {
-		kind: "gauge",
-		unit: "%",
-		deadband: 1
-	} } },
+	history: "none",
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -64116,7 +65100,7 @@ var presenceCapability = {
 */
 var PressureSensorStatusSchema = object({
 	/** Current pressure in hPa. `null` when the sample was refused (D393). */
-	hpa: number().nullable().meta(readingMeta("pressure", { precision: 0 })),
+	pressure: number().nullable().meta(readingMeta("pressure", { precision: 0 })),
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: number()
 });
@@ -64142,7 +65126,7 @@ var pressureSensorCapability = {
 	/**
 	* History (D850): recorded series.
 	*/
-	history: { fields: { hpa: {
+	history: { fields: { pressure: {
 		kind: "gauge",
 		unit: "hPa",
 		deadband: .1
@@ -64710,6 +65694,8 @@ var runningCustomize = {
 			stateField: "running"
 		},
 		deviceTypes: [
+			DeviceType.Washer,
+			DeviceType.Dryer,
 			DeviceType.Dishwasher,
 			DeviceType.Vacuum,
 			DeviceType.LawnMower,
@@ -67199,7 +68185,8 @@ var switchCapability = {
 	deviceTypes: [
 		DeviceType.Switch,
 		DeviceType.Siren,
-		DeviceType.Light
+		DeviceType.Light,
+		DeviceType.Fan
 	],
 	methods: { setState: method(object({
 		deviceId: number(),
@@ -67838,7 +68825,7 @@ var tamperCapability = {
 */
 var TemperatureSensorStatusSchema = object({
 	/** Current temperature in Celsius. `null` when the sample was refused (D393). */
-	celsius: number().nullable().meta(readingMeta("temperature", {
+	temperature: number().nullable().meta(readingMeta("temperature", {
 		precision: 1,
 		label: "Temperature"
 	})),
@@ -67867,7 +68854,7 @@ var temperatureSensorCapability = {
 	/**
 	* History (D850): recorded series.
 	*/
-	history: { fields: { celsius: {
+	history: { fields: { temperature: {
 		kind: "gauge",
 		unit: "°C",
 		deadband: .1
@@ -68164,7 +69151,7 @@ var VacuumControlStatusSchema = object({
 	/** Speed tokens the hardware accepts — drives the UI selector. */
 	availableFanSpeeds: array(string()),
 	/** 0..100 cleaning-completion percentage of the current task, or null. */
-	progressPercent: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	progress: number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Current error code (0 / null = no error). */
 	errorCode: number().nullable().meta(readingMeta("none")),
 	/** Human label for {@link errorCode}, or null when none / undecodable. */
@@ -69412,8 +70399,9 @@ method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" })
 	kind: "mutation",
 	auth: "admin"
 });
+DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, 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.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Camera, DeviceType.Camera, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, 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.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Camera, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
 String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 DeviceRole.BinarySensor, DeviceRole.MotionSensor;
 new Set(CAP_NAMES);
@@ -69742,6 +70730,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	featureProbe: featureProbeCapability,
 	flood: floodCapability,
 	gas: gasCapability,
+	groupActive: groupActiveCapability,
 	groupCommands: groupCommandsCapability,
 	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
@@ -69753,6 +70742,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	lawnMowerControl: lawnMowerControlCapability,
 	lockControl: lockControlCapability,
 	mediaPlayer: mediaPlayerCapability,
+	meter: meterCapability,
 	motion: motionCapability,
 	motionTrigger: motionTriggerCapability,
 	motionZones: motionZonesCapability,
@@ -69815,7 +70805,7 @@ var BaseDevice = class {
 	* `device-local-state.ts`. Drivers access via:
 	*
 	*   `this.state.battery.sleeping = true`        // patches the battery slice
-	*   `const pct = this.state.battery.percentage` // reads the battery slice
+	*   `const pct = this.state.battery.level` // reads the battery slice
 	*   `this.state.deviceStatus.online = true`     // mirrors `markOnline(true)`
 	*
 	* Adding a new cap with `runtimeState:` automatically extends this
@@ -69855,7 +70845,7 @@ var BaseDevice = class {
 	* shape; drivers don't redeclare it, they just write through.
 	*
 	* Read: `this.runtimeState.getCapState('battery')` →
-	*   `{percentage, charging, sleeping, lastUpdated}` for any
+	*   `{level, charging, sleeping, lastUpdated}` for any
 	*   provider that registers `batteryCapability`.
 	* Write: `this.runtimeState.setCapState('battery', { … })`.
 	*
@@ -71012,7 +72002,7 @@ var BaseDeviceProvider = class extends BaseAddon {
 		return toDeviceSummary(device, this.addonId);
 	}
 };
-DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer;
 new Set(Object.values(DeviceType));
 Object.freeze({
 	"accessories.getStatus": {
@@ -71029,6 +72019,104 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"actions.create": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"actions.delete": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
+	"actions.get": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"actions.getLinks": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"actions.getTraces": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"actions.list": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"actions.listForCamera": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"actions.run": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "viewer"
+	},
+	"actions.setLinks": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"actions.stop": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"actions.update": {
+		capName: "actions",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"actionSource.listActions": {
+		capName: "action-source",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"actionSource.runAction": {
+		capName: "action-source",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"actionSource.stopAction": {
+		capName: "action-source",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"addonPages.listPages": {
 		capName: "addon-pages",
 		capScope: "system",
@@ -72310,6 +73398,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"coreBlocks.getAutomationRunState": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"coreBlocks.getBlockSettings": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -72331,6 +73426,13 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"coreBlocks.getTraces": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"coreBlocks.getTypeDefs": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -72366,6 +73468,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"coreBlocks.reportAutomationRun": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"coreBlocks.restart": {
 		capName: "core-blocks",
 		capScope: "system",
@@ -74235,6 +75344,13 @@ Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"groupActive.getStatus": {
+		capName: "group-active",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"groupCommands.getStatus": {
 		capName: "group-commands",
 		capScope: "device",
@@ -75201,6 +76317,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"meter.getStatus": {
+		capName: "meter",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"metricsProvider.collectSnapshot": {
 		capName: "metrics-provider",
 		capScope: "system",
@@ -80925,7 +82048,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				label: t("Full brightness", "Luminosità massima"),
 				phrase: t("Set {device} to full brightness", "Porta {device} alla massima luminosità"),
 				icon: "sun",
-				args: { percentage: 100 }
+				args: { level: 100 }
 			},
 			{
 				id: "brightness.half",
@@ -80933,7 +82056,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				label: t("Half brightness", "Luminosità a metà"),
 				phrase: t("Dim {device} to half", "Abbassa {device} a metà luminosità"),
 				icon: "sun-dim",
-				args: { percentage: 50 }
+				args: { level: 50 }
 			},
 			{
 				id: "brightness.off",
@@ -80941,16 +82064,16 @@ var ACTUATOR_CAP_VOCABULARY = {
 				label: t("Brightness off", "Luminosità a zero"),
 				phrase: t("Dim {device} to zero", "Abbassa {device} a zero"),
 				icon: "lightbulb-off",
-				args: { percentage: 0 }
+				args: { level: 0 }
 			},
 			{
 				id: "brightness.set",
 				method: "setBrightness",
 				label: t("Set brightness", "Imposta la luminosità"),
-				phrase: t("Set the brightness of {device} to {percentage}", "Imposta la luminosità di {device} a {percentage}"),
+				phrase: t("Set the brightness of {device} to {level}", "Imposta la luminosità di {device} a {level}"),
 				icon: "sun-medium",
 				openArgs: [{
-					key: "percentage",
+					key: "level",
 					label: PERCENT,
 					offer: {
 						kind: "number",
@@ -80964,13 +82087,13 @@ var ACTUATOR_CAP_VOCABULARY = {
 		],
 		state: [{
 			kind: "numeric",
-			field: "percentage",
+			field: "level",
 			quantity: t("the brightness", "la luminosità"),
 			label: t("Brightness", "Luminosità"),
 			unit: "%",
 			icon: "sun"
 		}],
-		events: { onBrightnessChanged: { notOperatorFacing: "the `percentage` state trigger reads the same change" } }
+		events: { onBrightnessChanged: { notOperatorFacing: "the `level` state trigger reads the same change" } }
 	},
 	color: {
 		scope: "device",
@@ -80984,7 +82107,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				icon: "sun",
 				args: { color: {
 					mode: "mired",
-					mireds: 370
+					colorTemperature: 370
 				} }
 			},
 			{
@@ -80995,7 +82118,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				icon: "snowflake",
 				args: { color: {
 					mode: "mired",
-					mireds: 200
+					colorTemperature: 200
 				} }
 			},
 			{
@@ -81609,7 +82732,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				label: t("Fan off", "Ventilatore spento"),
 				phrase: t("Stop {device}", "Ferma {device}"),
 				icon: "power-off",
-				args: { percentage: 0 }
+				args: { speed: 0 }
 			},
 			{
 				id: "fan.full",
@@ -81617,16 +82740,16 @@ var ACTUATOR_CAP_VOCABULARY = {
 				label: t("Fan full", "Ventilatore al massimo"),
 				phrase: t("Run {device} at full speed", "Porta {device} alla massima velocità"),
 				icon: "fan",
-				args: { percentage: 100 }
+				args: { speed: 100 }
 			},
 			{
 				id: "fan.speed",
 				method: "setPercentage",
 				label: t("Set speed", "Imposta la velocità"),
-				phrase: t("Set the speed of {device} to {percentage}", "Imposta la velocità di {device} al {percentage}"),
+				phrase: t("Set the speed of {device} to {speed}", "Imposta la velocità di {device} al {speed}"),
 				icon: "fan",
 				openArgs: [{
-					key: "percentage",
+					key: "speed",
 					label: t("Speed", "Velocità"),
 					offer: {
 						kind: "number",
@@ -81688,7 +82811,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 		],
 		state: [{
 			kind: "numeric",
-			field: "percentage",
+			field: "speed",
 			quantity: t("the speed", "la velocità"),
 			label: t("Speed", "Velocità"),
 			unit: "%",
@@ -82486,7 +83609,7 @@ var APPLIANCE_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "progressPercent",
+				field: "progress",
 				quantity: t("the cycle progress", "l’avanzamento del lavaggio"),
 				label: t("Progress", "Avanzamento"),
 				unit: "%",
@@ -82844,10 +83967,10 @@ var APPLIANCE_CAP_VOCABULARY = {
 				id: "media.seek",
 				method: "seek",
 				label: t("Seek", "Vai al punto"),
-				phrase: t("Move {device} to {positionMs}", "Porta {device} al punto {positionMs}"),
+				phrase: t("Move {device} to {position}", "Porta {device} al punto {position}"),
 				icon: "fast-forward",
 				openArgs: [{
-					key: "positionMs",
+					key: "position",
 					label: t("Position", "Posizione"),
 					offer: {
 						kind: "number",
@@ -83299,7 +84422,39 @@ var APPLIANCE_CAP_VOCABULARY = {
 				phrase: t("When {device} finishes", "Quando {device} finisce"),
 				icon: "square"
 			}
-		}
+		},
+		overrides: { byType: {
+			[DeviceType.Washer]: {
+				state: { running: {
+					whenTrue: t("When the washing machine starts", "Quando la lavatrice inizia"),
+					whenFalse: t("When the washing machine has finished", "Quando la lavatrice ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the washing machine starts", "Quando la lavatrice inizia") },
+					onFinished: { phrase: t("When the washing machine has finished", "Quando la lavatrice ha finito") }
+				}
+			},
+			[DeviceType.Dryer]: {
+				state: { running: {
+					whenTrue: t("When the dryer starts", "Quando l'asciugatrice inizia"),
+					whenFalse: t("When the dryer has finished", "Quando l'asciugatrice ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the dryer starts", "Quando l'asciugatrice inizia") },
+					onFinished: { phrase: t("When the dryer has finished", "Quando l'asciugatrice ha finito") }
+				}
+			},
+			[DeviceType.Dishwasher]: {
+				state: { running: {
+					whenTrue: t("When the dishwasher starts", "Quando la lavastoviglie inizia"),
+					whenFalse: t("When the dishwasher has finished", "Quando la lavastoviglie ha finito")
+				} },
+				events: {
+					onStarted: { phrase: t("When the dishwasher starts", "Quando la lavastoviglie inizia") },
+					onFinished: { phrase: t("When the dishwasher has finished", "Quando la lavastoviglie ha finito") }
+				}
+			}
+		} }
 	},
 	update: {
 		scope: "device",
@@ -83864,7 +85019,7 @@ var SENSOR_CAP_VOCABULARY = {
 		state: [
 			{
 				kind: "numeric",
-				field: "co2Ppm",
+				field: "co2",
 				quantity: t("the CO₂", "la CO₂"),
 				label: t("CO₂", "CO₂"),
 				unit: "ppm",
@@ -83872,7 +85027,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "vocPpb",
+				field: "voc",
 				quantity: t("the VOC level", "il livello di COV"),
 				label: t("VOC", "COV"),
 				unit: "ppb",
@@ -83908,7 +85063,7 @@ var SENSOR_CAP_VOCABULARY = {
 		noun: t("Light level", "Luminosità ambiente"),
 		state: [{
 			kind: "numeric",
-			field: "lux",
+			field: "illuminance",
 			quantity: t("the light level", "la luminosità"),
 			label: t("Illuminance", "Illuminamento"),
 			unit: "lx",
@@ -84071,6 +85226,10 @@ var SENSOR_CAP_VOCABULARY = {
 			icon: "flame"
 		}]
 	},
+	"group-active": {
+		scope: "device",
+		noun: t("Group state", "Stato del gruppo")
+	},
 	"group-commands": {
 		scope: "device",
 		noun: t("Group command", "Comando di gruppo")
@@ -84107,7 +85266,7 @@ var SENSOR_CAP_VOCABULARY = {
 		noun: t("Humidity", "Umidità"),
 		state: [{
 			kind: "numeric",
-			field: "percent",
+			field: "humidity",
 			quantity: t("the humidity", "l’umidità"),
 			label: t("Humidity", "Umidità"),
 			unit: "%",
@@ -84127,6 +85286,17 @@ var SENSOR_CAP_VOCABULARY = {
 		}],
 		events: { onMotionChanged: { notOperatorFacing: "the `detected` state trigger phrases both edges, from the mirror that survives a dropped event (D49)" } }
 	},
+	meter: {
+		scope: "device",
+		noun: t("Meter", "Contatore"),
+		state: [{
+			kind: "numeric",
+			field: "value",
+			quantity: t("the total", "il totale"),
+			label: t("Total", "Totale"),
+			icon: "gauge"
+		}]
+	},
 	"numeric-sensor": {
 		scope: "device",
 		noun: t("Sensor", "Sensore"),
@@ -84144,7 +85314,7 @@ var SENSOR_CAP_VOCABULARY = {
 		state: [
 			{
 				kind: "numeric",
-				field: "watts",
+				field: "power",
 				quantity: t("the power draw", "il consumo"),
 				label: t("Power", "Potenza"),
 				unit: "W",
@@ -84152,7 +85322,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "kwhTotal",
+				field: "energy",
 				quantity: t("the energy used", "l’energia consumata"),
 				label: t("Energy", "Energia"),
 				unit: "kWh",
@@ -84160,7 +85330,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "volts",
+				field: "voltage",
 				quantity: t("the voltage", "la tensione"),
 				label: t("Voltage", "Tensione"),
 				unit: "V",
@@ -84168,7 +85338,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "amps",
+				field: "current",
 				quantity: t("the current", "la corrente"),
 				label: t("Current", "Corrente"),
 				unit: "A",
@@ -84185,13 +85355,6 @@ var SENSOR_CAP_VOCABULARY = {
 			label: t("Where", "Posizione"),
 			phrase: t("When {device} is at {value}", "Quando {device} è in {value}"),
 			icon: "map-pin"
-		}, {
-			kind: "numeric",
-			field: "batteryPercent",
-			quantity: t("the phone battery", "la batteria del telefono"),
-			label: t("Battery", "Batteria"),
-			unit: "%",
-			icon: "battery"
 		}]
 	},
 	"pressure-sensor": {
@@ -84199,7 +85362,7 @@ var SENSOR_CAP_VOCABULARY = {
 		noun: t("Pressure", "Pressione"),
 		state: [{
 			kind: "numeric",
-			field: "hpa",
+			field: "pressure",
 			quantity: t("the pressure", "la pressione"),
 			label: t("Pressure", "Pressione"),
 			unit: "hPa",
@@ -84235,7 +85398,7 @@ var SENSOR_CAP_VOCABULARY = {
 		noun: t("Temperature", "Temperatura"),
 		state: [{
 			kind: "numeric",
-			field: "celsius",
+			field: "temperature",
 			quantity: t("the temperature", "la temperatura"),
 			label: t("Temperature", "Temperatura"),
 			unit: "°C",
@@ -84306,7 +85469,7 @@ var SENSOR_CAP_VOCABULARY = {
 		state: [
 			{
 				kind: "numeric",
-				field: "percentage",
+				field: "level",
 				quantity: t("the battery level", "il livello della batteria"),
 				label: t("Battery", "Batteria"),
 				unit: "%",
@@ -84348,7 +85511,7 @@ var SENSOR_CAP_VOCABULARY = {
 				icon: "battery-charging"
 			}
 		],
-		events: { onStatusChanged: { notOperatorFacing: "the percentage / sleeping / charging state triggers each read one field of this change" } },
+		events: { onStatusChanged: { notOperatorFacing: "the level / sleeping / charging state triggers each read one field of this change" } },
 		extraEvents: [{
 			category: EventCategory.DeviceAwake,
 			label: t("Woke up", "Risvegliato"),
@@ -84366,7 +85529,7 @@ var SENSOR_CAP_VOCABULARY = {
 		noun: t("Network link", "Collegamento di rete"),
 		state: [{
 			kind: "numeric",
-			field: "signalPercent",
+			field: "signal",
 			quantity: t("the signal strength", "l’intensità del segnale"),
 			label: t("Signal", "Segnale"),
 			unit: "%",
@@ -84459,6 +85622,8 @@ var ML = "model and training machinery — no device action";
 var INTERNAL = "internal plumbing between addons — never operator-facing";
 /** Every system-scoped cap, with why it is not a device's vocabulary. */
 var SYSTEM_CAP_VOCABULARY = {
+	"action-source": system(INTERNAL),
+	actions: system("declared actions — run from the Actions page and from the cameras that link them"),
 	"addon-pages": system(UI_PLUMBING),
 	"addon-pages-source": system(UI_PLUMBING),
 	"addon-routes": system(UI_PLUMBING),
@@ -84599,8 +85764,47 @@ function projectAction(cap, action) {
 	};
 }
 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.Thermostat, 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.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, 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.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer;
 DeviceFeature.BatteryOperated;
+DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
+var HA_AS = "a power sensor (device_class power). Home Assistant has no laundry domain. running-state stays unexported until a null reading can be published as unavailable.";
+var HOMEKIT_REASON = "HomeKit has no laundry-appliance service. The export tab would pair an accessory with nothing on it: running-state is withheld until a null reading can be unavailable, and power is not a HomeKit service this export honours.";
+var ALEXA_REASON = "Alexa has no laundry category in this export, and neither power nor running has an Alexa interface.";
+var GOOGLE_REASON = "Google WASHER, DRYER and DISHWASHER require RunCycle. A power threshold is not that trait, and this export does not publish RunCycle.";
+var MATTER_REASON = "No Matter export is built. The closest device types are Laundry Washer (0x0073) and Laundry Dryer (0x0074); a power threshold is not the Laundry Washer Mode cluster.";
+function withheld(reason) {
+	return {
+		[DeviceType.Washer]: {
+			exported: false,
+			reason
+		},
+		[DeviceType.Dryer]: {
+			exported: false,
+			reason
+		},
+		[DeviceType.Dishwasher]: {
+			exported: false,
+			reason
+		}
+	};
+}
+function offered(received) {
+	return {
+		[DeviceType.Washer]: {
+			exported: true,
+			as: received
+		},
+		[DeviceType.Dryer]: {
+			exported: true,
+			as: received
+		},
+		[DeviceType.Dishwasher]: {
+			exported: true,
+			as: received
+		}
+	};
+}
+offered(HA_AS), withheld(HOMEKIT_REASON), withheld(ALEXA_REASON), withheld(GOOGLE_REASON), withheld(MATTER_REASON);
 Object.freeze({
 	"accessories.getStatus": [{
 		name: "deviceId",
@@ -84616,6 +85820,31 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"actions.get": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"actions.getLinks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"actions.listForCamera": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"actions.run": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
+	"actions.setLinks": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"addonSettings.getDeviceSettings": [{
 		name: "deviceId",
 		form: "single",
@@ -85567,6 +86796,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"groupActive.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"groupCommands.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -85777,6 +87011,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"meter.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"motion.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -87384,7 +88623,6 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
-DeviceType.Camera;
 /**
 * A saved Customize assignment (D936). The schema is the type: callers use
 * `z.infer`, they do not restate the shape.
@@ -88688,6 +89926,7 @@ DEFAULT_NATIVE_LEASE_SETTINGS.activityMs;
 DEFAULT_NATIVE_LEASE_SETTINGS.tileBudgetMb;
 DEFAULT_NATIVE_LEASE_SETTINGS.sceneBudgetMb;
 DEFAULT_NATIVE_LEASE_SETTINGS.admission;
+String.raw`(?<=^|["'(\s>,\[{])`;
 var MB = 1024 * 1024;
 1024 * MB, 3072 * MB;
 //#endregion
@@ -89451,7 +90690,6 @@ var COLD_PRESENCE = {
 	state: "not_home",
 	location: null,
 	gps: null,
-	batteryPercent: null,
 	lastChangedAt: 0
 };
 /**
@@ -89582,7 +90820,7 @@ var UnifiFeatureDevice = class extends BaseDevice {
 		switch (capForMetric(this.metric)) {
 			case "temperature-sensor":
 				this.runtimeState.setCapState("temperature-sensor", {
-					celsius: infra.cpuTempC ?? 0,
+					temperature: infra.cpuTempC ?? 0,
 					lastFetchedAt: now
 				});
 				return;
@@ -89619,7 +90857,6 @@ var UnifiFeatureDevice = class extends BaseDevice {
 			state: client.connected ? "home" : "not_home",
 			location: client.ip,
 			gps: null,
-			batteryPercent: null,
 			lastChangedAt: Date.now()
 		};
 		this.runtimeState.setCapState("presence", status);
@@ -89659,7 +90896,7 @@ var UnifiFeatureDevice = class extends BaseDevice {
 		switch (capForMetric(this.metric)) {
 			case "temperature-sensor": {
 				const COLD = {
-					celsius: 0,
+					temperature: 0,
 					lastFetchedAt: 0
 				};
 				this.ctx.registerNativeCap(temperatureSensorCapability, { getStatus: async () => this.runtimeState.getCapState("temperature-sensor") ?? COLD });