@camstack/addon-pipeline 1.2.631 → 1.2.632

package/dist/{dist-CVvwej3J.js → dist-CLo3QHtG.js}

@@ -1,5 +1,5 @@
 let node_crypto = require("node:crypto");
-//#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.
@@ -5575,7 +5580,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep--jXS9hWo.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).
@@ -9034,6 +9039,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",
@@ -9222,11 +9229,11 @@ var CAP_NAMES = Object.freeze([
 Object.freeze({
 	"air-quality-sensor": [
 		{
-			"path": "co2Ppm",
+			"path": "co2",
 			"valueType": "number"
 		},
 		{
-			"path": "vocPpb",
+			"path": "voc",
 			"valueType": "number"
 		},
 		{
@@ -9276,7 +9283,7 @@ Object.freeze({
 		}
 	],
 	"ambient-light-sensor": [{
-		"path": "lux",
+		"path": "illuminance",
 		"valueType": "number"
 	}],
 	"audio-metrics": [
@@ -9337,7 +9344,7 @@ Object.freeze({
 	],
 	"battery": [
 		{
-			"path": "percentage",
+			"path": "level",
 			"valueType": "number"
 		},
 		{
@@ -9359,7 +9366,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "volts",
+			"path": "voltage",
 			"valueType": "number"
 		},
 		{
@@ -9380,7 +9387,7 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"brightness": [{
-		"path": "percentage",
+		"path": "level",
 		"valueType": "number"
 	}],
 	"broker": [{
@@ -9581,7 +9588,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "mireds",
+			"path": "colorTemperature",
 			"valueType": "number"
 		}
 	],
@@ -9760,15 +9767,15 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "remainingSeconds",
+			"path": "remaining",
 			"valueType": "number"
 		},
 		{
-			"path": "delayedStartSeconds",
+			"path": "delayedStart",
 			"valueType": "number"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -9882,7 +9889,7 @@ Object.freeze({
 	],
 	"fan-control": [
 		{
-			"path": "percentage",
+			"path": "speed",
 			"valueType": "number"
 		},
 		{
@@ -9982,7 +9989,7 @@ Object.freeze({
 		}
 	],
 	"humidity-sensor": [{
-		"path": "percent",
+		"path": "humidity",
 		"valueType": "number"
 	}],
 	"image": [{
@@ -10092,7 +10099,7 @@ Object.freeze({
 			"valueType": "number"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -10171,11 +10178,11 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "positionMs",
+			"path": "position",
 			"valueType": "number"
 		},
 		{
-			"path": "durationMs",
+			"path": "duration",
 			"valueType": "number"
 		},
 		{
@@ -10277,11 +10284,11 @@ Object.freeze({
 			]
 		},
 		{
-			"path": "signalPercent",
+			"path": "signal",
 			"valueType": "number"
 		},
 		{
-			"path": "rssiDbm",
+			"path": "rssi",
 			"valueType": "number"
 		},
 		{
@@ -10336,6 +10343,18 @@ Object.freeze({
 			"path": "foodLevel",
 			"valueType": "number"
 		},
+		{
+			"path": "bowlFood",
+			"valueType": "number"
+		},
+		{
+			"path": "eating",
+			"valueType": "boolean"
+		},
+		{
+			"path": "supportsMarkRefilled",
+			"valueType": "boolean"
+		},
 		{
 			"path": "food1",
 			"valueType": "number"
@@ -10400,23 +10419,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"
 		},
 		{
@@ -10444,14 +10463,10 @@ Object.freeze({
 		{
 			"path": "gps.accuracyMeters",
 			"valueType": "number"
-		},
-		{
-			"path": "batteryPercent",
-			"valueType": "number"
 		}
 	],
 	"pressure-sensor": [{
-		"path": "hpa",
+		"path": "pressure",
 		"valueType": "number"
 	}],
 	"privacy-mask": [{
@@ -10765,7 +10780,7 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"temperature-sensor": [{
-		"path": "celsius",
+		"path": "temperature",
 		"valueType": "number"
 	}],
 	"update": [
@@ -10813,7 +10828,7 @@ Object.freeze({
 			"valueType": "string"
 		},
 		{
-			"path": "progressPercent",
+			"path": "progress",
 			"valueType": "number"
 		},
 		{
@@ -11450,7 +11465,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-Bb8iwHEJ.mjs
+//#region ../types/dist/composition-CZImLpOI.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -18162,6 +18177,14 @@ var AutomationConditionLeafSchema = object({
 		array(union$1([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
@@ -18195,7 +18218,8 @@ var AutomationConditionSchema = lazy(() => discriminatedUnion("kind", [
 		child: AutomationConditionSchema
 	}),
 	AutomationConditionLeafSchema,
-	AutomationConditionExpressionSchema
+	AutomationConditionExpressionSchema,
+	AutomationConditionStationaryPresentSchema
 ]));
 /**
 * What starts a run.
@@ -18236,7 +18260,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.
@@ -18256,28 +18307,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$1([
+		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$1([
-			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$1([
+			string(),
+			number(),
+			boolean()
+		])).optional()
 	}),
 	object({
 		kind: literal("code"),
@@ -18286,74 +18356,743 @@ 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()
 });
+var COCO_80_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "bicycle",
+		name: "Bicycle"
+	},
+	{
+		id: "car",
+		name: "Car"
+	},
+	{
+		id: "motorcycle",
+		name: "Motorcycle"
+	},
+	{
+		id: "airplane",
+		name: "Airplane"
+	},
+	{
+		id: "bus",
+		name: "Bus"
+	},
+	{
+		id: "train",
+		name: "Train"
+	},
+	{
+		id: "truck",
+		name: "Truck"
+	},
+	{
+		id: "boat",
+		name: "Boat"
+	},
+	{
+		id: "traffic light",
+		name: "Traffic Light"
+	},
+	{
+		id: "fire hydrant",
+		name: "Fire Hydrant"
+	},
+	{
+		id: "stop sign",
+		name: "Stop Sign"
+	},
+	{
+		id: "parking meter",
+		name: "Parking Meter"
+	},
+	{
+		id: "bench",
+		name: "Bench"
+	},
+	{
+		id: "bird",
+		name: "Bird"
+	},
+	{
+		id: "cat",
+		name: "Cat"
+	},
+	{
+		id: "dog",
+		name: "Dog"
+	},
+	{
+		id: "horse",
+		name: "Horse"
+	},
+	{
+		id: "sheep",
+		name: "Sheep"
+	},
+	{
+		id: "cow",
+		name: "Cow"
+	},
+	{
+		id: "elephant",
+		name: "Elephant"
+	},
+	{
+		id: "bear",
+		name: "Bear"
+	},
+	{
+		id: "zebra",
+		name: "Zebra"
+	},
+	{
+		id: "giraffe",
+		name: "Giraffe"
+	},
+	{
+		id: "backpack",
+		name: "Backpack"
+	},
+	{
+		id: "umbrella",
+		name: "Umbrella"
+	},
+	{
+		id: "handbag",
+		name: "Handbag"
+	},
+	{
+		id: "tie",
+		name: "Tie"
+	},
+	{
+		id: "suitcase",
+		name: "Suitcase"
+	},
+	{
+		id: "frisbee",
+		name: "Frisbee"
+	},
+	{
+		id: "skis",
+		name: "Skis"
+	},
+	{
+		id: "snowboard",
+		name: "Snowboard"
+	},
+	{
+		id: "sports ball",
+		name: "Sports Ball"
+	},
+	{
+		id: "kite",
+		name: "Kite"
+	},
+	{
+		id: "baseball bat",
+		name: "Baseball Bat"
+	},
+	{
+		id: "baseball glove",
+		name: "Baseball Glove"
+	},
+	{
+		id: "skateboard",
+		name: "Skateboard"
+	},
+	{
+		id: "surfboard",
+		name: "Surfboard"
+	},
+	{
+		id: "tennis racket",
+		name: "Tennis Racket"
+	},
+	{
+		id: "bottle",
+		name: "Bottle"
+	},
+	{
+		id: "wine glass",
+		name: "Wine Glass"
+	},
+	{
+		id: "cup",
+		name: "Cup"
+	},
+	{
+		id: "fork",
+		name: "Fork"
+	},
+	{
+		id: "knife",
+		name: "Knife"
+	},
+	{
+		id: "spoon",
+		name: "Spoon"
+	},
+	{
+		id: "bowl",
+		name: "Bowl"
+	},
+	{
+		id: "banana",
+		name: "Banana"
+	},
+	{
+		id: "apple",
+		name: "Apple"
+	},
+	{
+		id: "sandwich",
+		name: "Sandwich"
+	},
+	{
+		id: "orange",
+		name: "Orange"
+	},
+	{
+		id: "broccoli",
+		name: "Broccoli"
+	},
+	{
+		id: "carrot",
+		name: "Carrot"
+	},
+	{
+		id: "hot dog",
+		name: "Hot Dog"
+	},
+	{
+		id: "pizza",
+		name: "Pizza"
+	},
+	{
+		id: "donut",
+		name: "Donut"
+	},
+	{
+		id: "cake",
+		name: "Cake"
+	},
+	{
+		id: "chair",
+		name: "Chair"
+	},
+	{
+		id: "couch",
+		name: "Couch"
+	},
+	{
+		id: "potted plant",
+		name: "Potted Plant"
+	},
+	{
+		id: "bed",
+		name: "Bed"
+	},
+	{
+		id: "dining table",
+		name: "Dining Table"
+	},
+	{
+		id: "toilet",
+		name: "Toilet"
+	},
+	{
+		id: "tv",
+		name: "TV"
+	},
+	{
+		id: "laptop",
+		name: "Laptop"
+	},
+	{
+		id: "mouse",
+		name: "Mouse"
+	},
+	{
+		id: "remote",
+		name: "Remote"
+	},
+	{
+		id: "keyboard",
+		name: "Keyboard"
+	},
+	{
+		id: "cell phone",
+		name: "Cell Phone"
+	},
+	{
+		id: "microwave",
+		name: "Microwave"
+	},
+	{
+		id: "oven",
+		name: "Oven"
+	},
+	{
+		id: "toaster",
+		name: "Toaster"
+	},
+	{
+		id: "sink",
+		name: "Sink"
+	},
+	{
+		id: "refrigerator",
+		name: "Refrigerator"
+	},
+	{
+		id: "book",
+		name: "Book"
+	},
+	{
+		id: "clock",
+		name: "Clock"
+	},
+	{
+		id: "vase",
+		name: "Vase"
+	},
+	{
+		id: "scissors",
+		name: "Scissors"
+	},
+	{
+		id: "teddy bear",
+		name: "Teddy Bear"
+	},
+	{
+		id: "hair drier",
+		name: "Hair Drier"
+	},
+	{
+		id: "toothbrush",
+		name: "Toothbrush"
+	}
+];
+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));
 /**
-* `addon-pages` — system-scoped singleton aggregator cap. Public-facing
-* surface that admin-ui consumes through `useAddonPagesListPages()`.
+* 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.
 *
-* The provider iterates every `addon-pages-source` (collection) provider
-* and emits `AddonPageInfo[]` enriched with versioned `bundleUrl` strings
-* pointing at `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. The
-* filesystem `mtime` cache-buster lets the browser pick up addon
-* rebuilds without manual reload.
+* 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.
 *
-* The hub-local builtin `addon-pages-aggregator` (see
-* `@camstack/system/builtins/addon-pages-aggregator`) registers the
-* provider. Splitting the public aggregator from the raw collection
-* keeps both ends in codegen — there's no hand-written
-* `addon-pages.router.ts` wrapper anymore.
+* {@link AutomationStepTraceSchema} is deliberately free of automation
+* vocabulary so an Action run records the same step shape.
 */
-var AddonPageDeclarationSchema$1 = object({
-	id: string(),
-	label: string(),
-	icon: string(),
-	path: string(),
-	remoteName: string(),
-	bundle: string(),
-	section: string().optional(),
-	sectionLabel: string().optional()
+/** A value a trace may show: JSON primitives and short lists, nothing deeper. */
+var TraceValueSchema = union$1([
+	string(),
+	number(),
+	boolean(),
+	_null(),
+	array(union$1([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 AddonPageInfoSchema = object({
-	addonId: string(),
-	page: AddonPageDeclarationSchema$1,
-	bundleUrl: string()
+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()
 });
-method(_void(), array(AddonPageInfoSchema).readonly());
 /**
-* `addon-pages-source` — collection cap exposing per-provider raw page
-* declarations. Every addon that contributes a UI page registers a
-* provider here. The hub-side singleton aggregator (`addon-pages` cap,
-* see `addon-pages.cap.ts`) walks this collection, stamps versioned
-* `bundleUrl` values, and returns the enriched `AddonPageInfo[]` list
-* that admin-ui consumes.
+* 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.
 *
-* The split exists because the public listing has a different output
-* shape than the per-provider raw declarations, and we want both ends
-* to flow through codegen instead of relying on a hand-written wrapper.
+* 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.
 */
-var AddonPageDeclarationSchema = object({
-	id: string(),
-	label: string(),
-	icon: string(),
-	path: string(),
-	/**
-	* Module Federation remote name — must match the `name` field on the
-	* page addon's `federation()` plugin config. Used by admin-ui's
-	* `<AddonPageLoader>` to call `loadRemote('<remoteName>/page')`.
-	* Conventionally `addon_<id>_page` (snake_case; MF names cannot
-	* contain hyphens).
-	*/
-	remoteName: string(),
-	/**
-	* Bundle filename inside the addon's `dist/` dir served at
-	* `/api/addon-pages/<addonId>/<bundle>`. With Module Federation this
-	* is always `'remoteEntry.js'`; the value is kept on the metadata so
-	* the static-file route can compute an mtime-based cache-buster URL
-	* without a separate filesystem stat.
+/** 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$1([
+	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$1([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
+* surface that admin-ui consumes through `useAddonPagesListPages()`.
+*
+* The provider iterates every `addon-pages-source` (collection) provider
+* and emits `AddonPageInfo[]` enriched with versioned `bundleUrl` strings
+* pointing at `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. The
+* filesystem `mtime` cache-buster lets the browser pick up addon
+* rebuilds without manual reload.
+*
+* The hub-local builtin `addon-pages-aggregator` (see
+* `@camstack/system/builtins/addon-pages-aggregator`) registers the
+* provider. Splitting the public aggregator from the raw collection
+* keeps both ends in codegen — there's no hand-written
+* `addon-pages.router.ts` wrapper anymore.
+*/
+var AddonPageDeclarationSchema$1 = object({
+	id: string(),
+	label: string(),
+	icon: string(),
+	path: string(),
+	remoteName: string(),
+	bundle: string(),
+	section: string().optional(),
+	sectionLabel: string().optional()
+});
+var AddonPageInfoSchema = object({
+	addonId: string(),
+	page: AddonPageDeclarationSchema$1,
+	bundleUrl: string()
+});
+method(_void(), array(AddonPageInfoSchema).readonly());
+/**
+* `addon-pages-source` — collection cap exposing per-provider raw page
+* declarations. Every addon that contributes a UI page registers a
+* provider here. The hub-side singleton aggregator (`addon-pages` cap,
+* see `addon-pages.cap.ts`) walks this collection, stamps versioned
+* `bundleUrl` values, and returns the enriched `AddonPageInfo[]` list
+* that admin-ui consumes.
+*
+* The split exists because the public listing has a different output
+* shape than the per-provider raw declarations, and we want both ends
+* to flow through codegen instead of relying on a hand-written wrapper.
+*/
+var AddonPageDeclarationSchema = object({
+	id: string(),
+	label: string(),
+	icon: string(),
+	path: string(),
+	/**
+	* Module Federation remote name — must match the `name` field on the
+	* page addon's `federation()` plugin config. Used by admin-ui's
+	* `<AddonPageLoader>` to call `loadRemote('<remoteName>/page')`.
+	* Conventionally `addon_<id>_page` (snake_case; MF names cannot
+	* contain hyphens).
+	*/
+	remoteName: string(),
+	/**
+	* Bundle filename inside the addon's `dist/` dir served at
+	* `/api/addon-pages/<addonId>/<bundle>`. With Module Federation this
+	* is always `'remoteEntry.js'`; the value is kept on the metadata so
+	* the static-file route can compute an mtime-based cache-buster URL
+	* without a separate filesystem stat.
 	*/
 	bundle: string(),
 	/**
@@ -21342,7 +22081,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",
@@ -21661,7 +22400,7 @@ 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",
@@ -21672,7 +22411,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -21683,7 +22422,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -21694,7 +22433,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -21705,7 +22444,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -21716,7 +22455,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -21727,7 +22466,7 @@ var GROUP_TEMPLATES = [
 		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",
@@ -22305,7 +23044,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`)
@@ -47158,732 +47908,365 @@ method(_void(), NetworkEndpointSchema, { kind: "mutation" }), method(_void(), _v
 *  - Target CRUD lives on THIS cap (`upsertTarget` / `deleteTarget` /
 *    `setTargetEnabled`), each provider persisting via the `settings-store`
 *    cap. Rationale: the admin UI needs one uniform surface across the
-*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
-*    alternative would fork the UI per addon and cannot host the
-*    discovery→adopt flow.
-*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
-*    the generated cap-mount auto-`concatCollection`-fans them across every
-*    registered provider (notifiers addon + HA addon) so one catalog is
-*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
-*    `addonId` the generated collection router extracts from the call input.
-*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
-*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
-*    `storage` / `storage-provider` / `recording` caps over the same path. No
-*    base64 fallback needed.
-*
-* TODO (deferred, closed-set change — separate decision): add
-* `providerKind: 'notify'` so notification providers surface on the unified
-* admin "Integrations" page.
-*/
-/**
-* Zentik-derived typed-media enum — the superset across every kind. Each
-* adapter picks what it supports and the degrade engine filters the rest.
-*/
-var AttachmentMediaTypeSchema = _enum([
-	"image",
-	"video",
-	"gif",
-	"audio",
-	"icon"
-]);
-/**
-* A single attachment. Exactly one of `url` (remote source, most adapters
-* prefer this) or `bytes` (inline source; required for Pushover-style
-* bytes-only kinds) MUST be present — the degrade engine expresses a
-* url→bytes fetch as a `needsFetch` directive the adapter executes.
-*/
-var AttachmentSchema = object({
-	mediaType: AttachmentMediaTypeSchema,
-	url: string().optional(),
-	bytes: _instanceof(Uint8Array).optional(),
-	mime: string().optional(),
-	name: string().optional()
-}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
-var NotificationFormatSchema = _enum([
-	"text",
-	"markdown",
-	"html"
-]);
-/**
-* The CLOSED icon vocabulary an action button may use.
-*
-* A closed set, not a free string, and that is the whole point: an arbitrary
-* icon name is one that ntfy renders, zentik silently drops, and nobody
-* notices — the same class of gap as a zone vocabulary nothing produced
-* ([D35](../../../docs/decisions/adr-0035.md)). Every adapter maps this set or
-* declares `actionIcons: false` and the degrade engine strips the field.
-*
-* Named by INTENT, never by glyph. "check" would tie the vocabulary to one
-* renderer's icon set; "acknowledge" survives an adapter that draws it
-* differently.
-*
-* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
-*
-* These names are for US. **No adapter may forward one verbatim.** Each maps
-* the whole set onto its own renderer's vocabulary through a
-* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
-* fallback, so adding a member here fails every adapter's build until someone
-* decides its glyph, which is the only place that decision can be made
-* honestly.
-*
-* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
-* `disarm` straight through; iOS feeds that string to
-* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
-* and every snooze and alarm button arrived BLANK. A pass-through is not a
-* mapping, and "the field is documented" is not "the value renders".
-*
-* Adding a member is TRAIN-BOUND. The enum lives in the published
-* `@camstack/server` closure and the cap seam validates against the HUB's copy,
-* so an addon that emits a token the running hub does not know does not lose an
-* icon — its whole `send` fails Zod validation and the notification never
-* arrives. Never emit a new token from an addon before the train carrying it.
-*/
-var NotificationActionIconSchema = _enum([
-	"acknowledge",
-	"dismiss",
-	"silence",
-	"snooze",
-	"view",
-	"play",
-	"open",
-	"close",
-	"lock",
-	"unlock",
-	"arm",
-	"arm-home",
-	"arm-away",
-	"arm-night",
-	"disarm",
-	"light",
-	"alert",
-	"camera"
-]);
-/** A single tap-through action button. */
-var NotificationActionSchema = object({
-	id: string(),
-	label: string(),
-	url: string().optional(),
-	/** Dropped by the degrade engine for a kind with `caps.actionIcons: false`. */
-	icon: NotificationActionIconSchema.optional(),
-	/**
-	* Renders in a warning style where the notifier supports it.
-	*
-	* A HINT, never a gate. The callback's authority is its token and nothing
-	* else — see `notification-center/action-token.ts` for what that does and
-	* does not buy.
-	*/
-	destructive: boolean().optional(),
-	/**
-	* How the tap should REACH the url.
-	*
-	* `navigate` (absent, and every button authored before this field) opens it:
-	* the phone leaves the notification and shows whatever the callback returns.
-	* That is right for a button whose answer the operator wants to read.
-	*
-	* `background` fires it as a POST and stays put. It exists for the buttons
-	* whose whole point is not to interrupt — "silence this for 30 minutes" is
-	* an answer to the notification, and being thrown into a browser tab to
-	* confirm it costs more attention than the notification did. A backend that
-	* cannot do a background call renders it as an ordinary link (the adapters
-	* fall back rather than dropping the button), so this is a preference, never
-	* a requirement.
-	*/
-	mode: _enum(["navigate", "background"]).optional()
-});
-/**
-* The canonical notification. `body` is the only hard field (Apprise model).
-* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
-* NOT a fixed severity enum — each kind declares its own `caps.levels` and
-* the adapter maps this ordinal onto its native level. `level?` is an
-* optional kind-native level id (`emergency`, `silent`, …) that overrides
-* `priority` for that one target.
-*/
-var NotificationSchema = object({
-	body: string(),
-	title: string().optional(),
-	format: NotificationFormatSchema.default("text"),
-	priority: number().int().min(1).max(5).default(3),
-	level: string().optional(),
-	attachments: array(AttachmentSchema).optional(),
-	clickUrl: string().optional(),
-	actions: array(NotificationActionSchema).optional(),
-	sound: string().optional(),
-	ttl: number().optional(),
-	tag: string().optional(),
-	deviceId: number().optional(),
-	eventId: string().optional(),
-	metadata: record(string(), unknown()).optional()
-});
-/** One declared native severity/priority level for a kind. */
-var TargetKindLevelSchema = object({
-	id: string(),
-	label: string(),
-	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
-	ordinal: number().int().min(1).max(5).nullable(),
-	flags: object({
-		critical: boolean().optional(),
-		silent: boolean().optional(),
-		noPush: boolean().optional()
-	}).optional(),
-	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
-	requires: array(string()).optional(),
-	description: string().optional()
-});
-/** The full capability block consulted before dispatch. */
-var TargetKindCapsSchema = object({
-	attachments: object({
-		mediaTypes: array(AttachmentMediaTypeSchema),
-		mode: _enum([
-			"url",
-			"bytes",
-			"both"
-		]),
-		max: number().int().nonnegative(),
-		maxBytes: number().int().positive().optional()
-	}),
-	/** Max action buttons (0 = none). */
-	actions: number().int().nonnegative(),
-	/**
-	* Whether this kind renders a per-action ICON.
-	*
-	* `.optional()`, deliberately NOT `.default(false)`: a Zod default does not
-	* run on the addon cap path — three production failures in one day taught
-	* this repo that once. Absent is read as false by the degrade engine, which
-	* is the safe direction: an icon that is not rendered costs nothing, an icon
-	* assumed and dropped costs the operator's trust in the field.
-	*/
-	actionIcons: boolean().optional(),
-	levels: array(TargetKindLevelSchema),
-	format: array(NotificationFormatSchema),
-	clickUrl: boolean(),
-	sound: boolean(),
-	ttl: boolean(),
-	bodyMaxLen: number().int().positive()
-});
-/**
-* `configSchema` is a `ConfigUISchema` tree passed through to the admin
-* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
-* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
-* the union is large and not meant for runtime validation here; the exported
-* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
-*/
-var ConfigSchemaPassthrough$2 = unknown();
-var TargetKindSchema = object({
-	kind: string(),
-	label: string(),
-	icon: string(),
-	/** Stamped by each provider so the concat-fanned catalog stays routable. */
-	addonId: string(),
-	/**
-	* URL of the kind's bundled BRAND icon, served by the providing addon over
-	* its own `addon-routes` surface (`/addon/<addonId>/icons/<kind>`). Absent
-	* when the addon bundles no icon for that kind — the client then falls back
-	* to a neutral glyph rather than rendering the raw `icon` NAME as text.
-	*
-	* Root-relative on purpose: it resolves against whatever origin serves a web
-	* client, and a native client joins it onto its own hub base.
-	*
-	* DECLARED here deliberately. It used to travel as an undeclared passthrough
-	* field that survived only because the runtime cap-router forwards provider
-	* output verbatim — so every consumer had to re-declare it by hand to stop
-	* its own Zod parse from stripping it, and the whole arrangement would have
-	* broken silently the moment output validation was tightened anywhere.
-	*/
-	iconUrl: string().optional(),
-	/**
-	* Media type of {@link iconUrl} (`image/svg+xml`, `image/png`, …).
-	*
-	* The server knows this and therefore says it, because the client cannot
-	* safely guess: a React-Native client renders SVG and raster through two
-	* DIFFERENT components (`react-native-svg` vs `expo-image` — expo-image does
-	* not decode SVG on iOS/Android), so without this it silently fell back to a
-	* placeholder glyph for every vector icon while the web build looked fine.
-	*
-	* Absent when {@link iconUrl} is absent, or for a legacy provider that has
-	* not been updated — a client that cannot determine the type should prefer
-	* its raster path, which is the safe default for an unknown image.
-	*/
-	iconMediaType: string().optional(),
-	configSchema: ConfigSchemaPassthrough$2,
-	/**
-	* The config keys that decide WHERE this kind's secrets are sent (server,
-	* base URL, instance, chat, recipient). A save that changes any of them
-	* while leaving a secret redacted is refused by the provider (D634), so an
-	* editor uses this to ask for the secret on exactly those edits instead of
-	* on every edit.
-	*
-	* Optional: absent from a provider that holds no secret (the Home Assistant
-	* kinds) and from a provider older than this field — an editor that finds
-	* it absent must assume ANY edit may need the secret.
-	*/
-	destinationKeys: array(string()).optional(),
-	supportsDiscovery: boolean(),
-	caps: TargetKindCapsSchema
-});
-/**
-* A persisted target. `config` holds secrets; providers REDACT secret fields
-* (return a presence marker only) when serving `listTargets` — never
-* round-trip a stored secret to the UI.
-*/
-var TargetSchema = object({
-	id: string(),
-	name: string(),
-	kind: string(),
-	addonId: string(),
-	enabled: boolean(),
-	config: record(string(), unknown())
-});
-/** A discovery-surfaced candidate (config is partial + non-secret). */
-var DiscoveredTargetSchema = object({
-	kind: string(),
-	suggestedName: string(),
-	config: record(string(), unknown())
-});
-/** The degrade engine's report — what was resolved / dropped / degraded. */
-var RenderedAsSchema = object({
-	level: string(),
-	format: NotificationFormatSchema,
-	attachmentsSent: number().int().nonnegative(),
-	actionsSent: number().int().nonnegative(),
-	truncated: boolean(),
-	dropped: array(string())
-});
-var SendResultSchema = object({
-	success: boolean(),
-	error: string().optional(),
-	renderedAs: RenderedAsSchema.optional()
-});
-/** Same shape as SendResult — kept as a distinct name for the test panel. */
-var TestResultSchema = SendResultSchema;
-/**
-* Pre-save credential probe against a partial (unsaved) target config.
-* `resolvedUrl` never includes secrets (token stripped from path).
-*/
-var ProbeTargetConfigResultSchema = object({
-	ok: boolean(),
-	resolvedUrl: string(),
-	httpStatus: number().int().optional(),
-	stateInstance: string().optional(),
-	error: string().optional()
-});
-method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSchema), { auth: "admin" }), method(object({ targetId: string() }), TargetSchema, { auth: "admin" }), method(object({
-	kind: string(),
-	config: record(string(), unknown()).optional(),
-	/**
-	* When editing / duplicating, the blank password field never round-trips
-	* the stored token. Pass the source target id so the provider can restore
-	* secrets server-side before dialling (same merge as upsert).
-	*/
-	targetId: string().optional()
-}), array(DiscoveredTargetSchema), { auth: "admin" }), method(object({
-	kind: string(),
-	config: record(string(), unknown()),
-	/** See `discoverTargets.targetId` — restore stored secrets for a blank password. */
-	targetId: string().optional()
-}), ProbeTargetConfigResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	targetId: string(),
-	notification: NotificationSchema
-}), SendResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	targetId: string(),
-	sample: NotificationSchema.optional()
-}), TestResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	target: TargetSchema,
-	/**
-	* Duplicate flow: create a NEW target id while copying secrets from an
-	* existing row. The UI never holds the stored token; blank / redacted
-	* password fields are restored from this source (D634 still applies if
-	* destinations diverge without a re-typed secret).
-	*/
-	cloneSecretsFrom: string().optional()
-}), TargetSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ targetId: string() }), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	targetId: string(),
-	enabled: boolean()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-});
-var COCO_80_LABELS = [
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "bicycle",
-		name: "Bicycle"
-	},
-	{
-		id: "car",
-		name: "Car"
-	},
-	{
-		id: "motorcycle",
-		name: "Motorcycle"
-	},
-	{
-		id: "airplane",
-		name: "Airplane"
-	},
-	{
-		id: "bus",
-		name: "Bus"
-	},
-	{
-		id: "train",
-		name: "Train"
-	},
-	{
-		id: "truck",
-		name: "Truck"
-	},
-	{
-		id: "boat",
-		name: "Boat"
-	},
-	{
-		id: "traffic light",
-		name: "Traffic Light"
-	},
-	{
-		id: "fire hydrant",
-		name: "Fire Hydrant"
-	},
-	{
-		id: "stop sign",
-		name: "Stop Sign"
-	},
-	{
-		id: "parking meter",
-		name: "Parking Meter"
-	},
-	{
-		id: "bench",
-		name: "Bench"
-	},
-	{
-		id: "bird",
-		name: "Bird"
-	},
-	{
-		id: "cat",
-		name: "Cat"
-	},
-	{
-		id: "dog",
-		name: "Dog"
-	},
-	{
-		id: "horse",
-		name: "Horse"
-	},
-	{
-		id: "sheep",
-		name: "Sheep"
-	},
-	{
-		id: "cow",
-		name: "Cow"
-	},
-	{
-		id: "elephant",
-		name: "Elephant"
-	},
-	{
-		id: "bear",
-		name: "Bear"
-	},
-	{
-		id: "zebra",
-		name: "Zebra"
-	},
-	{
-		id: "giraffe",
-		name: "Giraffe"
-	},
-	{
-		id: "backpack",
-		name: "Backpack"
-	},
-	{
-		id: "umbrella",
-		name: "Umbrella"
-	},
-	{
-		id: "handbag",
-		name: "Handbag"
-	},
-	{
-		id: "tie",
-		name: "Tie"
-	},
-	{
-		id: "suitcase",
-		name: "Suitcase"
-	},
-	{
-		id: "frisbee",
-		name: "Frisbee"
-	},
-	{
-		id: "skis",
-		name: "Skis"
-	},
-	{
-		id: "snowboard",
-		name: "Snowboard"
-	},
-	{
-		id: "sports ball",
-		name: "Sports Ball"
-	},
-	{
-		id: "kite",
-		name: "Kite"
-	},
-	{
-		id: "baseball bat",
-		name: "Baseball Bat"
-	},
-	{
-		id: "baseball glove",
-		name: "Baseball Glove"
-	},
-	{
-		id: "skateboard",
-		name: "Skateboard"
-	},
-	{
-		id: "surfboard",
-		name: "Surfboard"
-	},
-	{
-		id: "tennis racket",
-		name: "Tennis Racket"
-	},
-	{
-		id: "bottle",
-		name: "Bottle"
-	},
-	{
-		id: "wine glass",
-		name: "Wine Glass"
-	},
-	{
-		id: "cup",
-		name: "Cup"
-	},
-	{
-		id: "fork",
-		name: "Fork"
-	},
-	{
-		id: "knife",
-		name: "Knife"
-	},
-	{
-		id: "spoon",
-		name: "Spoon"
-	},
-	{
-		id: "bowl",
-		name: "Bowl"
-	},
-	{
-		id: "banana",
-		name: "Banana"
-	},
-	{
-		id: "apple",
-		name: "Apple"
-	},
-	{
-		id: "sandwich",
-		name: "Sandwich"
-	},
-	{
-		id: "orange",
-		name: "Orange"
-	},
-	{
-		id: "broccoli",
-		name: "Broccoli"
-	},
-	{
-		id: "carrot",
-		name: "Carrot"
-	},
-	{
-		id: "hot dog",
-		name: "Hot Dog"
-	},
-	{
-		id: "pizza",
-		name: "Pizza"
-	},
-	{
-		id: "donut",
-		name: "Donut"
-	},
-	{
-		id: "cake",
-		name: "Cake"
-	},
-	{
-		id: "chair",
-		name: "Chair"
-	},
-	{
-		id: "couch",
-		name: "Couch"
-	},
-	{
-		id: "potted plant",
-		name: "Potted Plant"
-	},
-	{
-		id: "bed",
-		name: "Bed"
-	},
-	{
-		id: "dining table",
-		name: "Dining Table"
-	},
-	{
-		id: "toilet",
-		name: "Toilet"
-	},
-	{
-		id: "tv",
-		name: "TV"
-	},
-	{
-		id: "laptop",
-		name: "Laptop"
-	},
-	{
-		id: "mouse",
-		name: "Mouse"
-	},
-	{
-		id: "remote",
-		name: "Remote"
-	},
-	{
-		id: "keyboard",
-		name: "Keyboard"
-	},
-	{
-		id: "cell phone",
-		name: "Cell Phone"
-	},
-	{
-		id: "microwave",
-		name: "Microwave"
-	},
-	{
-		id: "oven",
-		name: "Oven"
-	},
-	{
-		id: "toaster",
-		name: "Toaster"
-	},
-	{
-		id: "sink",
-		name: "Sink"
-	},
-	{
-		id: "refrigerator",
-		name: "Refrigerator"
-	},
-	{
-		id: "book",
-		name: "Book"
-	},
-	{
-		id: "clock",
-		name: "Clock"
-	},
-	{
-		id: "vase",
-		name: "Vase"
-	},
-	{
-		id: "scissors",
-		name: "Scissors"
-	},
-	{
-		id: "teddy bear",
-		name: "Teddy Bear"
-	},
-	{
-		id: "hair drier",
-		name: "Hair Drier"
-	},
-	{
-		id: "toothbrush",
-		name: "Toothbrush"
-	}
-];
-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
-};
+*    notifiers addon AND the HA addon; the addon-`globalSettingsSchema`-array
+*    alternative would fork the UI per addon and cannot host the
+*    discovery→adopt flow.
+*  - `listTargetKinds` / `listTargets` / `discoverTargets` return arrays →
+*    the generated cap-mount auto-`concatCollection`-fans them across every
+*    registered provider (notifiers addon + HA addon) so one catalog is
+*    routable. `send` / `testTarget` / CRUD route to ONE provider by the
+*    `addonId` the generated collection router extracts from the call input.
+*  - `Attachment.bytes` is `Uint8Array`. Transport-safe: superjson (the tRPC
+*    transformer) + UDS MsgPack both round-trip typed arrays — already used by
+*    `storage` / `storage-provider` / `recording` caps over the same path. No
+*    base64 fallback needed.
+*
+* TODO (deferred, closed-set change — separate decision): add
+* `providerKind: 'notify'` so notification providers surface on the unified
+* admin "Integrations" page.
+*/
+/**
+* Zentik-derived typed-media enum — the superset across every kind. Each
+* adapter picks what it supports and the degrade engine filters the rest.
+*/
+var AttachmentMediaTypeSchema = _enum([
+	"image",
+	"video",
+	"gif",
+	"audio",
+	"icon"
+]);
+/**
+* A single attachment. Exactly one of `url` (remote source, most adapters
+* prefer this) or `bytes` (inline source; required for Pushover-style
+* bytes-only kinds) MUST be present — the degrade engine expresses a
+* url→bytes fetch as a `needsFetch` directive the adapter executes.
+*/
+var AttachmentSchema = object({
+	mediaType: AttachmentMediaTypeSchema,
+	url: string().optional(),
+	bytes: _instanceof(Uint8Array).optional(),
+	mime: string().optional(),
+	name: string().optional()
+}).refine((a) => a.url !== void 0 || a.bytes !== void 0, { message: "Attachment requires either `url` or `bytes`" });
+var NotificationFormatSchema = _enum([
+	"text",
+	"markdown",
+	"html"
+]);
+/**
+* The CLOSED icon vocabulary an action button may use.
+*
+* A closed set, not a free string, and that is the whole point: an arbitrary
+* icon name is one that ntfy renders, zentik silently drops, and nobody
+* notices — the same class of gap as a zone vocabulary nothing produced
+* ([D35](../../../docs/decisions/adr-0035.md)). Every adapter maps this set or
+* declares `actionIcons: false` and the degrade engine strips the field.
+*
+* Named by INTENT, never by glyph. "check" would tie the vocabulary to one
+* renderer's icon set; "acknowledge" survives an adapter that draws it
+* differently.
+*
+* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
+*
+* These names are for US. **No adapter may forward one verbatim.** Each maps
+* the whole set onto its own renderer's vocabulary through a
+* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
+* fallback, so adding a member here fails every adapter's build until someone
+* decides its glyph, which is the only place that decision can be made
+* honestly.
+*
+* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
+* `disarm` straight through; iOS feeds that string to
+* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
+* and every snooze and alarm button arrived BLANK. A pass-through is not a
+* mapping, and "the field is documented" is not "the value renders".
+*
+* Adding a member is TRAIN-BOUND. The enum lives in the published
+* `@camstack/server` closure and the cap seam validates against the HUB's copy,
+* so an addon that emits a token the running hub does not know does not lose an
+* icon — its whole `send` fails Zod validation and the notification never
+* arrives. Never emit a new token from an addon before the train carrying it.
+*/
+var NotificationActionIconSchema = _enum([
+	"acknowledge",
+	"dismiss",
+	"silence",
+	"snooze",
+	"view",
+	"play",
+	"open",
+	"close",
+	"lock",
+	"unlock",
+	"arm",
+	"arm-home",
+	"arm-away",
+	"arm-night",
+	"disarm",
+	"light",
+	"alert",
+	"camera"
+]);
+/** A single tap-through action button. */
+var NotificationActionSchema = object({
+	id: string(),
+	label: string(),
+	url: string().optional(),
+	/** Dropped by the degrade engine for a kind with `caps.actionIcons: false`. */
+	icon: NotificationActionIconSchema.optional(),
+	/**
+	* Renders in a warning style where the notifier supports it.
+	*
+	* A HINT, never a gate. The callback's authority is its token and nothing
+	* else — see `notification-center/action-token.ts` for what that does and
+	* does not buy.
+	*/
+	destructive: boolean().optional(),
+	/**
+	* How the tap should REACH the url.
+	*
+	* `navigate` (absent, and every button authored before this field) opens it:
+	* the phone leaves the notification and shows whatever the callback returns.
+	* That is right for a button whose answer the operator wants to read.
+	*
+	* `background` fires it as a POST and stays put. It exists for the buttons
+	* whose whole point is not to interrupt — "silence this for 30 minutes" is
+	* an answer to the notification, and being thrown into a browser tab to
+	* confirm it costs more attention than the notification did. A backend that
+	* cannot do a background call renders it as an ordinary link (the adapters
+	* fall back rather than dropping the button), so this is a preference, never
+	* a requirement.
+	*/
+	mode: _enum(["navigate", "background"]).optional()
+});
+/**
+* The canonical notification. `body` is the only hard field (Apprise model).
+* `priority` is a 5-level ORDINAL (1=lowest … 3=normal(default) … 5=urgent),
+* NOT a fixed severity enum — each kind declares its own `caps.levels` and
+* the adapter maps this ordinal onto its native level. `level?` is an
+* optional kind-native level id (`emergency`, `silent`, …) that overrides
+* `priority` for that one target.
+*/
+var NotificationSchema = object({
+	body: string(),
+	title: string().optional(),
+	format: NotificationFormatSchema.default("text"),
+	priority: number().int().min(1).max(5).default(3),
+	level: string().optional(),
+	attachments: array(AttachmentSchema).optional(),
+	clickUrl: string().optional(),
+	actions: array(NotificationActionSchema).optional(),
+	sound: string().optional(),
+	ttl: number().optional(),
+	tag: string().optional(),
+	deviceId: number().optional(),
+	eventId: string().optional(),
+	metadata: record(string(), unknown()).optional()
+});
+/** One declared native severity/priority level for a kind. */
+var TargetKindLevelSchema = object({
+	id: string(),
+	label: string(),
+	/** Which canonical priority (1..5) this level maps to. `null` = qualitative-only. */
+	ordinal: number().int().min(1).max(5).nullable(),
+	flags: object({
+		critical: boolean().optional(),
+		silent: boolean().optional(),
+		noPush: boolean().optional()
+	}).optional(),
+	/** e.g. Pushover `emergency` requires `retry` / `expire`. */
+	requires: array(string()).optional(),
+	description: string().optional()
+});
+/** The full capability block consulted before dispatch. */
+var TargetKindCapsSchema = object({
+	attachments: object({
+		mediaTypes: array(AttachmentMediaTypeSchema),
+		mode: _enum([
+			"url",
+			"bytes",
+			"both"
+		]),
+		max: number().int().nonnegative(),
+		maxBytes: number().int().positive().optional()
+	}),
+	/** Max action buttons (0 = none). */
+	actions: number().int().nonnegative(),
+	/**
+	* Whether this kind renders a per-action ICON.
+	*
+	* `.optional()`, deliberately NOT `.default(false)`: a Zod default does not
+	* run on the addon cap path — three production failures in one day taught
+	* this repo that once. Absent is read as false by the degrade engine, which
+	* is the safe direction: an icon that is not rendered costs nothing, an icon
+	* assumed and dropped costs the operator's trust in the field.
+	*/
+	actionIcons: boolean().optional(),
+	levels: array(TargetKindLevelSchema),
+	format: array(NotificationFormatSchema),
+	clickUrl: boolean(),
+	sound: boolean(),
+	ttl: boolean(),
+	bodyMaxLen: number().int().positive()
+});
+/**
+* `configSchema` is a `ConfigUISchema` tree passed through to the admin
+* FormBuilder. Stored as `z.unknown()` at the cap seam (mirrors
+* `device-provider.getChildCreationSchema` `CreationSchemaOutputSchema`) —
+* the union is large and not meant for runtime validation here; the exported
+* `TargetKind` type re-tightens `configSchema` to `ConfigUISchema`.
+*/
+var ConfigSchemaPassthrough$2 = unknown();
+var TargetKindSchema = object({
+	kind: string(),
+	label: string(),
+	icon: string(),
+	/** Stamped by each provider so the concat-fanned catalog stays routable. */
+	addonId: string(),
+	/**
+	* URL of the kind's bundled BRAND icon, served by the providing addon over
+	* its own `addon-routes` surface (`/addon/<addonId>/icons/<kind>`). Absent
+	* when the addon bundles no icon for that kind — the client then falls back
+	* to a neutral glyph rather than rendering the raw `icon` NAME as text.
+	*
+	* Root-relative on purpose: it resolves against whatever origin serves a web
+	* client, and a native client joins it onto its own hub base.
+	*
+	* DECLARED here deliberately. It used to travel as an undeclared passthrough
+	* field that survived only because the runtime cap-router forwards provider
+	* output verbatim — so every consumer had to re-declare it by hand to stop
+	* its own Zod parse from stripping it, and the whole arrangement would have
+	* broken silently the moment output validation was tightened anywhere.
+	*/
+	iconUrl: string().optional(),
+	/**
+	* Media type of {@link iconUrl} (`image/svg+xml`, `image/png`, …).
+	*
+	* The server knows this and therefore says it, because the client cannot
+	* safely guess: a React-Native client renders SVG and raster through two
+	* DIFFERENT components (`react-native-svg` vs `expo-image` — expo-image does
+	* not decode SVG on iOS/Android), so without this it silently fell back to a
+	* placeholder glyph for every vector icon while the web build looked fine.
+	*
+	* Absent when {@link iconUrl} is absent, or for a legacy provider that has
+	* not been updated — a client that cannot determine the type should prefer
+	* its raster path, which is the safe default for an unknown image.
+	*/
+	iconMediaType: string().optional(),
+	configSchema: ConfigSchemaPassthrough$2,
+	/**
+	* The config keys that decide WHERE this kind's secrets are sent (server,
+	* base URL, instance, chat, recipient). A save that changes any of them
+	* while leaving a secret redacted is refused by the provider (D634), so an
+	* editor uses this to ask for the secret on exactly those edits instead of
+	* on every edit.
+	*
+	* Optional: absent from a provider that holds no secret (the Home Assistant
+	* kinds) and from a provider older than this field — an editor that finds
+	* it absent must assume ANY edit may need the secret.
+	*/
+	destinationKeys: array(string()).optional(),
+	supportsDiscovery: boolean(),
+	caps: TargetKindCapsSchema
+});
+/**
+* A persisted target. `config` holds secrets; providers REDACT secret fields
+* (return a presence marker only) when serving `listTargets` — never
+* round-trip a stored secret to the UI.
+*/
+var TargetSchema = object({
+	id: string(),
+	name: string(),
+	kind: string(),
+	addonId: string(),
+	enabled: boolean(),
+	config: record(string(), unknown())
+});
+/** A discovery-surfaced candidate (config is partial + non-secret). */
+var DiscoveredTargetSchema = object({
+	kind: string(),
+	suggestedName: string(),
+	config: record(string(), unknown())
+});
+/** The degrade engine's report — what was resolved / dropped / degraded. */
+var RenderedAsSchema = object({
+	level: string(),
+	format: NotificationFormatSchema,
+	attachmentsSent: number().int().nonnegative(),
+	actionsSent: number().int().nonnegative(),
+	truncated: boolean(),
+	dropped: array(string())
+});
+var SendResultSchema = object({
+	success: boolean(),
+	error: string().optional(),
+	renderedAs: RenderedAsSchema.optional()
+});
+/** Same shape as SendResult — kept as a distinct name for the test panel. */
+var TestResultSchema = SendResultSchema;
+/**
+* Pre-save credential probe against a partial (unsaved) target config.
+* `resolvedUrl` never includes secrets (token stripped from path).
+*/
+var ProbeTargetConfigResultSchema = object({
+	ok: boolean(),
+	resolvedUrl: string(),
+	httpStatus: number().int().optional(),
+	stateInstance: string().optional(),
+	error: string().optional()
+});
+method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSchema), { auth: "admin" }), method(object({ targetId: string() }), TargetSchema, { auth: "admin" }), method(object({
+	kind: string(),
+	config: record(string(), unknown()).optional(),
+	/**
+	* When editing / duplicating, the blank password field never round-trips
+	* the stored token. Pass the source target id so the provider can restore
+	* secrets server-side before dialling (same merge as upsert).
+	*/
+	targetId: string().optional()
+}), array(DiscoveredTargetSchema), { auth: "admin" }), method(object({
+	kind: string(),
+	config: record(string(), unknown()),
+	/** See `discoverTargets.targetId` — restore stored secrets for a blank password. */
+	targetId: string().optional()
+}), ProbeTargetConfigResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	targetId: string(),
+	notification: NotificationSchema
+}), SendResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	targetId: string(),
+	sample: NotificationSchema.optional()
+}), TestResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	target: TargetSchema,
+	/**
+	* Duplicate flow: create a NEW target id while copying secrets from an
+	* existing row. The UI never holds the stored token; blank / redacted
+	* password fields are restored from this source (D634 still applies if
+	* destinations diverge without a re-typed secret).
+	*/
+	cloneSecretsFrom: string().optional()
+}), TargetSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ targetId: string() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	targetId: string(),
+	enabled: boolean()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
@@ -61164,9 +61547,9 @@ method(object({ nodeId: string().optional() }).optional(), array(AddonListItemSc
 }), LogStreamEntrySchema, { kind: "subscription" });
 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³. */
@@ -61179,7 +61562,7 @@ object({
 DeviceType.Sensor;
 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"
 	})),
@@ -61276,6 +61659,84 @@ DeviceType.Camera, method(object({ deviceId: number() }), AudioMetricsSnapshotSc
 	*  would produce more than `maxPoints` samples. */
 	sampleEveryMs: number().int().positive().optional()
 }), AudioMetricsHistorySchema);
+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"
+});
 object({
 	/** Whether the automation is currently enabled. Disabled automations
 	*  ignore their trigger block — manual `trigger` still works. */
@@ -61329,7 +61790,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
@@ -61339,7 +61800,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.
 	*/
@@ -61363,7 +61824,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
@@ -61397,7 +61858,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.
 	*/
@@ -61417,15 +61878,15 @@ var BATTERY_DEVICE_TYPES = [
 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"],
@@ -61519,7 +61980,7 @@ onStatusChanged: { data: object({
 		schema: BatteryStatusSchema,
 		kind: "push",
 		empty: {
-			percentage: null,
+			level: null,
 			charging: "unknown",
 			sleeping: false,
 			lastUpdated: 0
@@ -61546,11 +62007,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"
 		}
@@ -61568,19 +62029,19 @@ object({
 DeviceType.Sensor;
 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()
 });
 DeviceType.Light, method(object({
 	deviceId: number().int().nonnegative(),
-	percentage: number().min(0).max(100)
+	level: number().min(0).max(100)
 }), _void(), {
 	kind: "mutation",
 	auth: "protected"
 }), object({
 	deviceId: number(),
-	percentage: number().min(0).max(100),
+	level: number().min(0).max(100),
 	lastChangedAt: number()
 });
 DeviceType.Button, method(object({ deviceId: number().int().nonnegative() }), _void(), {
@@ -62081,11 +62542,11 @@ var ColorInputSchema = discriminatedUnion("mode", [
 	}),
 	object({
 		mode: literal("mired"),
-		mireds: number().int().min(50).max(1e3)
+		colorTemperature: number().int().min(50).max(1e3)
 	})
 ]);
 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",
@@ -62097,7 +62558,7 @@ 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()
 });
@@ -62116,7 +62577,7 @@ DeviceType.Light, method(object({
 	]),
 	rgb: RgbTripletSchema.optional(),
 	hsv: HsvTripletSchema.optional(),
-	mireds: number().int().optional(),
+	colorTemperature: number().int().optional(),
 	lastChangedAt: number()
 });
 var ConnectionTestOutcomeSchema = discriminatedUnion("outcome", [
@@ -62542,11 +63003,11 @@ 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. */
@@ -63164,7 +63625,7 @@ var FanDirectionSchema = _enum(["forward", "reverse"]);
 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")),
@@ -63184,7 +63645,7 @@ object({
 });
 DeviceType.Fan, method(object({
 	deviceId: number().int().nonnegative(),
-	percentage: number().min(0).max(100)
+	speed: number().min(0).max(100)
 }), _void(), {
 	kind: "mutation",
 	auth: "protected"
@@ -63367,7 +63828,7 @@ DeviceType.Humidifier, method(object({
 });
 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"
 	})),
@@ -63810,7 +64271,7 @@ 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")),
@@ -64300,10 +64761,10 @@ 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(),
@@ -64330,7 +64791,7 @@ DeviceType.MediaPlayer, method(object({ deviceId: number().int().nonnegative() }
 	auth: "protected"
 }), method(object({
 	deviceId: number().int().nonnegative(),
-	positionMs: number().int().nonnegative()
+	position: number().int().nonnegative()
 }), _void(), {
 	kind: "mutation",
 	auth: "protected"
@@ -65003,9 +65464,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. */
@@ -65666,10 +66127,20 @@ var PetFeederDeviceStatusSchema = _enum([
 ]);
 var gramsPortion = number().int().min(4).max(200);
 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")),
@@ -65677,8 +66148,8 @@ 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. */
@@ -66145,16 +66616,16 @@ method(_void(), PlatformCapabilitiesSchema), method(_void(), HardwareInfoSchema)
 	auth: "admin"
 });
 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", { label: "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", { label: "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. */
@@ -66209,16 +66680,13 @@ 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()
 });
 DeviceType.Presence;
 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()
 });
@@ -69745,7 +70213,7 @@ object({
 DeviceType.Sensor;
 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"
 	})),
@@ -70009,7 +70477,7 @@ 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. */
@@ -71008,6 +71476,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",
@@ -72289,6 +72855,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",
@@ -72310,6 +72883,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",
@@ -72345,6 +72925,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",
@@ -80918,7 +81505,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",
@@ -80926,7 +81513,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",
@@ -80934,16 +81521,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",
@@ -80957,13 +81544,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",
@@ -80977,7 +81564,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				icon: "sun",
 				args: { color: {
 					mode: "mired",
-					mireds: 370
+					colorTemperature: 370
 				} }
 			},
 			{
@@ -80988,7 +81575,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 				icon: "snowflake",
 				args: { color: {
 					mode: "mired",
-					mireds: 200
+					colorTemperature: 200
 				} }
 			},
 			{
@@ -81602,7 +82189,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",
@@ -81610,16 +82197,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",
@@ -81681,7 +82268,7 @@ var ACTUATOR_CAP_VOCABULARY = {
 		],
 		state: [{
 			kind: "numeric",
-			field: "percentage",
+			field: "speed",
 			quantity: t("the speed", "la velocità"),
 			label: t("Speed", "Velocità"),
 			unit: "%",
@@ -82479,7 +83066,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: "%",
@@ -82837,10 +83424,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",
@@ -83889,7 +84476,7 @@ var SENSOR_CAP_VOCABULARY = {
 		state: [
 			{
 				kind: "numeric",
-				field: "co2Ppm",
+				field: "co2",
 				quantity: t("the CO₂", "la CO₂"),
 				label: t("CO₂", "CO₂"),
 				unit: "ppm",
@@ -83897,7 +84484,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",
@@ -83933,7 +84520,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",
@@ -84136,7 +84723,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: "%",
@@ -84184,7 +84771,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",
@@ -84192,7 +84779,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",
@@ -84200,7 +84787,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "volts",
+				field: "voltage",
 				quantity: t("the voltage", "la tensione"),
 				label: t("Voltage", "Tensione"),
 				unit: "V",
@@ -84208,7 +84795,7 @@ var SENSOR_CAP_VOCABULARY = {
 			},
 			{
 				kind: "numeric",
-				field: "amps",
+				field: "current",
 				quantity: t("the current", "la corrente"),
 				label: t("Current", "Corrente"),
 				unit: "A",
@@ -84225,13 +84812,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": {
@@ -84239,7 +84819,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",
@@ -84275,7 +84855,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",
@@ -84346,7 +84926,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: "%",
@@ -84388,7 +84968,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"),
@@ -84406,7 +84986,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: "%",
@@ -84499,6 +85079,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),
@@ -84695,6 +85277,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",
@@ -89738,6 +90345,7 @@ var BackgroundRunRegistry = class {
 		}
 	}
 };
+String.raw`(?<=^|["'(\s>,\[{])`;
 var MB = 1024 * 1024;
 var DEFAULT_POOL_MEMORY_POLICY = {
 	sampleIntervalMs: 6e4,