@camstack/addon-provider-dreame 0.2.159 → 0.2.160

package/dist/addon.js

@@ -52902,7 +52902,7 @@ var DreameCameraStream = class extends TypedEmitter {
 	}
 };
 //#endregion
-//#region ../types/dist/event-category-CT-hz5Rb.mjs
+//#region ../types/dist/event-category-hdMR7CTW.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -53667,6 +53667,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.
@@ -58345,7 +58350,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-BE7IAR2p.mjs
+//#region ../types/dist/sleep-BHjNez61.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -61465,6 +61470,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",
@@ -68593,7 +68600,23 @@ 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("interval"),
+		minutes: number().int().min(1).max(1440)
+	})
 ]);
 /**
 * One action step.
@@ -68613,28 +68636,47 @@ var AutomationTriggerSchema = discriminatedUnion("kind", [
 * is called. The runner still receives a number and is untouched; the
 * resolution is the recipe's job, not the runner's.
 */
+var AutomationWaitStepSchema = object({
+	kind: literal("wait"),
+	seconds: number().min(0).max(300)
+});
+var AutomationCapStepSchema = object({
+	kind: literal("cap"),
+	/**
+	* One device, several same-family devices (locks / climate family / …),
+	* or `{ $var }` for the device that triggered the run. An array is
+	* fan-out at codegen — each id gets the same cap.method call.
+	*/
+	deviceId: union([
+		number().int(),
+		array(number().int()).min(1),
+		object({ $var: string().min(1) })
+	]),
+	cap: string().min(1),
+	method: string().min(1),
+	/** Values may carry `{{vars.x}}` slots, or be exactly `{ $var: 'name' }`, which
+	*  SUBSTITUTE and do not evaluate (§3.2.3). Anything beyond substitution is
+	*  the expression leaf. */
+	args: record(string(), unknown()).optional()
+});
+/**
+* The steps an internal Action may contain: cap and wait, and nothing that can
+* call back into an Action — so an Action can never reach itself (no cycles).
+*/
+var ActionStepSchema = discriminatedUnion("kind", [AutomationWaitStepSchema, AutomationCapStepSchema]);
 var AutomationActionSchema = discriminatedUnion("kind", [
+	AutomationWaitStepSchema,
+	AutomationCapStepSchema,
 	object({
-		kind: literal("wait"),
-		seconds: number().min(0).max(300)
-	}),
-	object({
-		kind: literal("cap"),
-		/**
-		* One device, several same-family devices (locks / climate family / …),
-		* or `{ $var }` for the device that triggered the run. An array is
-		* fan-out at codegen — each id gets the same cap.method call.
-		*/
-		deviceId: union([
-			number().int(),
-			array(number().int()).min(1),
-			object({ $var: string().min(1) })
-		]),
-		cap: string().min(1),
-		method: string().min(1),
-		/** Values may carry `{{vars.x}}` slots, which SUBSTITUTE and do not
-		*  evaluate (§3.2.3). Anything beyond substitution is the expression leaf. */
-		args: record(string(), unknown()).optional()
+		kind: literal("action"),
+		/** An entry of the `actions` surface (`internal:<uuid>` or `<addonId>:<localId>`). */
+		actionId: string().min(1),
+		/** Values for the action's declared variables; the others take their default. */
+		variables: record(string(), union([
+			string(),
+			number(),
+			boolean()
+		])).optional()
 	}),
 	object({
 		kind: literal("code"),
@@ -68643,10 +68685,356 @@ var AutomationActionSchema = discriminatedUnion("kind", [
 		code: string().min(1).max(2e4)
 	})
 ]);
+/**
+* How a trigger that arrives while the automation is busy (or cooling down) is
+* handled. One of the automation's execution modes, never a property of its
+* actions. Absent means `single`.
+*
+*  - `single`   — drop the trigger while a run is in progress (traced + logged).
+*  - `restart`  — abort the run in progress (at its next step boundary), start fresh.
+*  - `queued`   — queue up to `max` triggers, drop the rest (traced).
+*  - `parallel` — up to `max` runs at once, drop the rest (traced).
+*  - `cooldown` — `single`, and no new run until `minutes` after the last run
+*    STARTED; persisted across a restart. A manual trigger bypasses only this
+*    wait, never the single/queued limits.
+*/
+var AutomationRunModeSchema = discriminatedUnion("mode", [
+	object({ mode: literal("single") }),
+	object({ mode: literal("restart") }),
+	object({
+		mode: literal("queued"),
+		max: number().int().min(1).max(10)
+	}),
+	object({
+		mode: literal("parallel"),
+		max: number().int().min(1).max(10)
+	}),
+	object({
+		mode: literal("cooldown"),
+		minutes: number().int().min(1).max(1440)
+	})
+]);
 var AutomationRecipeSchema = object({
 	triggers: array(AutomationTriggerSchema),
 	conditions: AutomationConditionSchema.optional(),
-	actions: array(AutomationActionSchema)
+	actions: array(AutomationActionSchema),
+	runMode: AutomationRunModeSchema.optional(),
+	/** How many run traces the automation keeps (default {@link DEFAULT_TRACE_KEEP}). */
+	keepTraces: number().int().min(1).max(100).optional()
+});
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
+new Set(Object.values(COCO_TO_MACRO.mapping));
+/**
+* Run traces — what an automation (or, later, an Action run) DID, node by node,
+* so the editor can paint every block green or red with its reason.
+*
+* A trace is data, not a log: it covers the WHOLE tree — the trigger stage,
+* every condition node (containers and leaves, including the ones a
+* short-circuit never reached), the run-mode verdict and every action step —
+* each addressed by a stable path (`conditions.0.1`, `actions.2`, or `steps.N`
+* for an Action run). Skipped
+* evaluations are traced too, and identical consecutive skips collapse into a
+* repeat count so a trigger that fails every 5 minutes cannot flush real runs.
+*
+* {@link AutomationStepTraceSchema} is deliberately free of automation
+* vocabulary so an Action run records the same step shape.
+*/
+/** A value a trace may show: JSON primitives and short lists, nothing deeper. */
+var TraceValueSchema = union([
+	string(),
+	number(),
+	boolean(),
+	_null(),
+	array(union([string(), number()]))
+]);
+var AutomationRunOutcomeSchema = _enum([
+	"ran",
+	"skipped-trigger",
+	"skipped-conditions",
+	"skipped-cooldown",
+	"skipped-overlap",
+	"failed",
+	"aborted"
+]);
+/** `not-evaluated` = a short-circuit never reached the node. */
+var TraceNodeOutcomeSchema = _enum([
+	"pass",
+	"fail",
+	"not-evaluated"
+]);
+var AutomationTriggerTraceSchema = object({
+	kind: string().min(1),
+	outcome: _enum(["pass", "fail"]),
+	/** Why an event was rejected ("class person not in [dog]") or what fired. */
+	reason: string(),
+	/** deviceId, className, trackId, score … — only what the trigger exposes. */
+	vars: record(string(), TraceValueSchema)
+});
+var AutomationConditionTraceNodeSchema = object({
+	/** `conditions` for the root, `conditions.<i>` for its i-th child, … */
+	path: string().min(1),
+	kind: _enum([
+		"all",
+		"any",
+		"not",
+		"condition",
+		"expression"
+	]),
+	outcome: TraceNodeOutcomeSchema,
+	reason: string(),
+	deviceId: number().int().optional(),
+	cap: string().optional(),
+	fieldPath: string().optional(),
+	operator: string().optional(),
+	expected: TraceValueSchema.optional(),
+	/** What the mirror held; `null` when it held nothing (unknown). */
+	observed: TraceValueSchema.optional()
+});
+var AutomationRunVerdictSchema = object({
+	mode: AutomationRunModeSchema,
+	decision: _enum([
+		"run",
+		"queued",
+		"restart",
+		"drop",
+		"cooldown",
+		"bypass"
+	]),
+	reason: string()
+});
+/** One executed (or not-run) step — shared by automations and Action runs. */
+var AutomationStepTraceSchema = object({
+	/** `actions.<i>` */
+	path: string().min(1),
+	kind: string().min(1),
+	cap: string().optional(),
+	method: string().optional(),
+	deviceId: number().int().optional(),
+	startedAt: number().optional(),
+	endedAt: number().optional(),
+	outcome: _enum([
+		"ok",
+		"error",
+		"not-run"
+	]),
+	message: string().optional()
+});
+var AutomationRunTraceSchema = object({
+	runId: string().min(1),
+	startedAt: number(),
+	endedAt: number(),
+	trigger: AutomationTriggerTraceSchema,
+	conditions: array(AutomationConditionTraceNodeSchema),
+	verdict: AutomationRunVerdictSchema.optional(),
+	steps: array(AutomationStepTraceSchema),
+	outcome: AutomationRunOutcomeSchema,
+	/** How many identical consecutive skips this trace stands for (>= 1). */
+	repeat: number().int().min(1),
+	/** When the latest of those repeats happened. */
+	lastAt: number()
+});
+/**
+* What the hub's `runs` ledger holds for one owner (`automation:<blockId>` or
+* `action:<actionId>`): the cooldown stamp and the trace ring.
+*/
+var AutomationStateDocSchema = object({
+	version: literal(1),
+	lastRunStartedAt: number().nullable(),
+	traces: array(AutomationRunTraceSchema)
+});
+/**
+* Actions — named, runnable things an operator (or an automation) can start,
+* declared as LIST ENTRIES, never as devices.
+*
+* An entry is either **internal** (a short list of cap/wait steps kept in the
+* hub's `actions` record kind) or declared by an addon through the
+* `action-source` collection (a Home Assistant script, a scene …). The one
+* surface the UI and automations talk to is the `actions` cap; it keeps no
+* catalog of its own (D3) — every `list` asks the providers live.
+*
+* This file is the data half: the entry schema, the variables an entry may
+* declare, and the pure resolution of the values a run was given. It holds no
+* runtime.
+*/
+/** What a variable's value is. `select` takes one of `options`. */
+var ActionVariableTypeSchema = _enum([
+	"string",
+	"number",
+	"boolean",
+	"select"
+]);
+var ACTION_VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ActionVariableValueSchema = union([
+	string(),
+	number(),
+	boolean()
+]);
+/**
+* One declared variable. Steps reference it as `{ $var: 'name' }` (the whole
+* value) or `{{vars.name}}` (inside a string) in their args.
+*/
+var ActionVariableSchema = object({
+	name: string().regex(ACTION_VARIABLE_NAME_RE),
+	label: string().min(1).max(120).optional(),
+	type: ActionVariableTypeSchema,
+	required: boolean().optional(),
+	default: ActionVariableValueSchema.optional(),
+	/** The allowed values of a `select`. */
+	options: array(string().min(1)).min(1).optional()
+}).superRefine((v, ctx) => {
+	if (v.type === "select" && v.options === void 0) ctx.addIssue({
+		code: "custom",
+		message: "a select variable needs options",
+		path: ["options"]
+	});
+	if (v.default !== void 0 && variableValueError(v, v.default) !== null) ctx.addIssue({
+		code: "custom",
+		message: variableValueError(v, v.default) ?? "invalid default",
+		path: ["default"]
+	});
+});
+/** Why `value` is not a legal value for the variable, or null when it is. */
+function variableValueError(variable, value) {
+	switch (variable.type) {
+		case "string": return typeof value === "string" ? null : `variable "${variable.name}" must be a string`;
+		case "number": return typeof value === "number" && Number.isFinite(value) ? null : `variable "${variable.name}" must be a number`;
+		case "boolean": return typeof value === "boolean" ? null : `variable "${variable.name}" must be true or false`;
+		case "select": return typeof value === "string" && (variable.options ?? []).includes(value) ? null : `variable "${variable.name}" must be one of ${(variable.options ?? []).join(", ")}`;
+	}
+}
+var ActionSourceKindSchema = _enum(["internal", "addon"]);
+function isInternalActionId(actionId) {
+	return actionId.startsWith("internal:") && actionId.length > 9;
+}
+/** The addon behind a `<addonId>:<localId>` id, or null for anything else (internal included). */
+function addonIdOfActionId(actionId) {
+	if (isInternalActionId(actionId)) return null;
+	const at = actionId.indexOf(":");
+	return at > 0 && at < actionId.length - 1 ? actionId.slice(0, at) : null;
+}
+var ActionStatusSchema = object({
+	isRunning: boolean(),
+	/** Ms epoch the latest run STARTED; null when it never ran. */
+	lastRunAt: number().nullable(),
+	/** The latest run's failure; null on success or when it never ran. */
+	lastError: string().nullable()
+});
+var ActionEntrySchema = object({
+	/** `internal:<uuid>` or `<addonId>:<localId>`. */
+	id: string().min(3),
+	name: string().min(1).max(120),
+	/** The addon that declared it; `core-blocks` for an internal one. */
+	addonId: string().min(1),
+	source: ActionSourceKindSchema,
+	/** An addon-declared entry is edited where it was declared. */
+	readOnly: boolean(),
+	/** Internal only: cap and wait steps. No action-in-action, so no cycles. */
+	steps: array(ActionStepSchema).min(1).max(50).optional(),
+	variables: array(ActionVariableSchema).max(20).optional(),
+	status: ActionStatusSchema
+}).superRefine((entry, ctx) => {
+	if (entry.source === "internal") {
+		if (!isInternalActionId(entry.id)) ctx.addIssue({
+			code: "custom",
+			message: "an internal action id is internal:<uuid>",
+			path: ["id"]
+		});
+		return;
+	}
+	if (entry.steps !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "only an internal action carries steps",
+		path: ["steps"]
+	});
+	if (!entry.readOnly) ctx.addIssue({
+		code: "custom",
+		message: "an addon action is read-only here",
+		path: ["readOnly"]
+	});
+	if (addonIdOfActionId(entry.id) === null) ctx.addIssue({
+		code: "custom",
+		message: "an addon action id is <addonId>:<localId>",
+		path: ["id"]
+	});
+});
+/** What an operator writes for an internal action. */
+var ActionInputSchema = object({
+	name: string().min(1).max(120),
+	steps: array(ActionStepSchema).min(1).max(50),
+	variables: array(ActionVariableSchema).max(20).optional()
+});
+/** Who started a run. Absent = the operator pressed it. */
+var ActionRunOriginSchema = object({ 
+/** The automation block whose step started it. */
+blockId: string().min(1).optional() });
+/** `started` = the caller did not ask to wait. */
+var ActionRunOutcomeSchema = union([AutomationRunOutcomeSchema, literal("started")]);
+var ActionRunResultSchema = object({
+	runId: string().min(1),
+	outcome: ActionRunOutcomeSchema,
+	/** Why it did not run, or what failed. */
+	message: string().optional()
+});
+_enum([
+	"not-found",
+	"read-only",
+	"invalid-variables",
+	"invalid-steps",
+	"not-linked",
+	"busy"
+]);
+object({
+	actionId: string(),
+	runId: string(),
+	isRunning: boolean(),
+	/** Set when the run ended. */
+	outcome: AutomationRunOutcomeSchema.optional(),
+	lastRunAt: number().nullable(),
+	lastError: string().nullable()
 });
 /**
 * `addon-pages` — system-scoped singleton aggregator cap. Public-facing
@@ -72296,7 +72684,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`)
@@ -97684,51 +98083,6 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	kind: "mutation",
 	auth: "admin"
 });
-new Set([
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-].map((l) => l.id));
-var COCO_TO_MACRO = {
-	mapping: {
-		person: "person",
-		bicycle: "vehicle",
-		car: "vehicle",
-		motorcycle: "vehicle",
-		airplane: "vehicle",
-		bus: "vehicle",
-		train: "vehicle",
-		truck: "vehicle",
-		boat: "vehicle",
-		bird: "animal",
-		cat: "animal",
-		dog: "animal",
-		horse: "animal",
-		sheep: "animal",
-		cow: "animal",
-		elephant: "animal",
-		bear: "animal",
-		zebra: "animal",
-		giraffe: "animal",
-		suitcase: "package",
-		backpack: "package",
-		handbag: "package"
-	},
-	preserveOriginal: false
-};
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
@@ -110534,6 +110888,84 @@ var audioMetricsCapability = {
 	*/
 	history: "none"
 };
+method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
+	actionId: string().min(1),
+	variables: record(string(), ActionVariableValueSchema).optional()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ actionId: string().min(1) }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
+* actions — the ONE surface for runnable actions, for the UI and for
+* automations. Provided by the core-blocks builtin on the hub.
+*
+* An action is a LIST ENTRY, not a device (D883): either internal (cap and wait
+* steps, kept in the hub's `actions` record kind) or declared by an addon over
+* `action-source`. `list` asks every `action-source` provider LIVE and overlays
+* the run status from the hub's `runs` ledger; there is no catalog here to
+* drift (D3).
+*
+* **Permissions follow the camera, as linked devices do.** An action is linked
+* to cameras by the operator (`setLinks`, D356: nothing links itself). A
+* non-admin may `get` / `run` an action only through a camera they may see that
+* links it: they name the camera (`deviceId`, a top-level field so the scope
+* gate sees it) and the provider refuses an action that camera does not link.
+* An admin, and an in-process caller (an automation block), may run any action.
+* Every refusal is typed (`[not-linked] …`) and logged.
+*
+* A second `run` of an action that is already running is REFUSED — traced and
+* logged — never queued.
+*/
+var ActionIdInput = object({ actionId: string().min(1) });
+var ActionLinksSchema = object({
+	deviceId: number().int().nonnegative(),
+	actionIds: array(string().min(1)).max(100)
+});
+method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
+	actionId: string().min(1),
+	deviceId: number().int().nonnegative().optional()
+}), object({ action: ActionEntrySchema.nullable() }), {
+	role: "viewer",
+	auth: "protected",
+	kind: "query",
+	caller: "required"
+}), method(object({
+	actionId: string().min(1),
+	variables: record(string(), ActionVariableValueSchema).optional(),
+	wait: boolean().optional(),
+	origin: ActionRunOriginSchema.optional(),
+	deviceId: number().int().nonnegative().optional()
+}), ActionRunResultSchema, {
+	role: "viewer",
+	auth: "protected",
+	kind: "mutation",
+	caller: "required"
+}), method(ActionIdInput, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ActionIdInput, object({ traces: array(AutomationRunTraceSchema) }), { auth: "admin" }), method(object({ action: ActionInputSchema }), object({ action: ActionEntrySchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	actionId: string().min(1),
+	action: ActionInputSchema.partial()
+}), object({ action: ActionEntrySchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(ActionIdInput, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), array(ActionEntrySchema), {
+	role: "viewer",
+	auth: "protected",
+	kind: "query"
+}), method(object({ deviceId: number().int().nonnegative() }), ActionLinksSchema, { auth: "admin" }), method(ActionLinksSchema, ActionLinksSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
 /**
 * Automation-control cap. Models HA `automation.*` entities on
 * `DeviceType.Automation`. An automation is a trigger+condition+
@@ -125329,6 +125761,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",
@@ -126610,6 +127140,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",
@@ -126631,6 +127168,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",
@@ -126666,6 +127210,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",
@@ -138820,6 +139371,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),
@@ -139016,6 +139569,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",
@@ -143187,6 +143765,7 @@ function ingestReading(input) {
 		value: converted
 	};
 }
+String.raw`(?<=^|["'(\s>,\[{])`;
 var MB = 1024 * 1024;
 1024 * MB, 3072 * MB;
 //#endregion
@@ -143313,6 +143892,334 @@ function buildConnectionFormSchema() {
 	] };
 }
 //#endregion
+//#region src/dreame-vacuum-decode.ts
+/**
+* Pure decode helpers for the Dreame vacuum. Translate the library's MIoT enum
+* values into the camstack `vacuum-control` slice shape. Unit-tested in
+* isolation (no facade, no network) — mirrors `homematic-decode.ts`.
+*/
+/**
+* Map a Dreame {@link MiotState} (siid 2 piid 1) onto the camstack canonical
+* `VacuumState` lifecycle (`idle` / `cleaning` / `paused` / `returning` /
+* `docked` / `error`). A `null` state (not yet observed) settles on `idle`.
+*
+* The MIoT state space is large (~50 values); we collapse it onto the six
+* canonical states by family. Anything unrecognised falls through to `idle`
+* (the safe neutral) so a firmware-added code never throws.
+*/
+function mapMiotStateToVacuumState(state) {
+	if (state === null) return "idle";
+	switch (state) {
+		case MiotState.Charging:
+		case MiotState.ChargingComplete:
+		case MiotState.IntelligentCharging:
+		case MiotState.CleanWashboardBase:
+		case MiotState.AutoRepairBase:
+		case MiotState.WaterSupplyDrainTest:
+		case MiotState.CleanMopRefillWater:
+		case MiotState.AutoEmptying:
+		case MiotState.Emptying:
+		case MiotState.Draining:
+		case MiotState.AutoWaterDraining:
+		case MiotState.Sanitizing: return "docked";
+		case MiotState.MopDrying:
+		case MiotState.DustBagDrying:
+		case MiotState.SanitizingWithDry: return "drying";
+		case MiotState.ReturningToCharge:
+		case MiotState.ReturningToWash:
+		case MiotState.ReturnInstallMop:
+		case MiotState.ReturnRemoveMop:
+		case MiotState.ReturnToEmpty:
+		case MiotState.ReturningToDrain: return "returning";
+		case MiotState.Paused:
+		case MiotState.PausedAlt:
+		case MiotState.PausedCleaning:
+		case MiotState.DustBagDryingPaused:
+		case MiotState.CameraMonitoringPaused:
+		case MiotState.FindingPetPaused:
+		case MiotState.InitialDeepCleanPaused:
+		case MiotState.ChangingMopPaused:
+		case MiotState.FloorMaintainingPaused: return "paused";
+		case MiotState.Standby:
+		case MiotState.WaitingForTask: return "idle";
+		default: return "cleaning";
+	}
+}
+/**
+* The camstack `fanSpeed` token for a Dreame {@link SuctionLevel} — the enum
+* member NAME, lower-cased (`Quiet` → `'quiet'`). Returns `null` for an
+* unobserved / unknown level.
+*/
+function suctionLevelToken(level) {
+	if (level === null) return null;
+	const name = SuctionLevel[level];
+	return typeof name === "string" ? name.toLowerCase() : null;
+}
+/**
+* Resolve a camstack `fanSpeed` token back to the Dreame {@link SuctionLevel}
+* enum value, validated against the model's `supported` levels. Returns null
+* when the token doesn't match a supported level (the caller rejects the set).
+*/
+function tokenToSuctionLevel(token, supported) {
+	const wanted = token.trim().toLowerCase();
+	for (const level of supported) if (suctionLevelToken(level) === wanted) return level;
+	return null;
+}
+/** The list of accepted `fanSpeed` tokens for a model's supported suction set. */
+function supportedFanSpeedTokens(supported) {
+	const tokens = [];
+	for (const level of supported) {
+		const token = suctionLevelToken(level);
+		if (token !== null) tokens.push(token);
+	}
+	return tokens;
+}
+/**
+* Clamp a raw battery reading (already a 0..100 percentage from the library)
+* to the `vacuum-control` slice's `batteryLevel` field. Returns null for a
+* null/NaN/out-of-band reading so the slice stays valid (the schema rejects
+* a number outside 0..100).
+*/
+function clampBatteryLevel$1(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* MiotError codes that are BENIGN completion / reminder states, not active
+* faults. A fresh cloud-shadow read of an idle docked robot legitimately
+* returns `TaskComplete` (68); it is not an error to show. The Error sensor
+* (`dreame-entity-catalog.ts`) and the vacuum card both read this set.
+* Extend it if other non-fault codes surface as spurious "errors".
+*/
+var BENIGN_ERROR_CODES = new Set([MiotError.TaskComplete]);
+/** The card's error label: null for no error and for a benign completion code. */
+function vacuumErrorLabel(code) {
+	if (!code || BENIGN_ERROR_CODES.has(code)) return null;
+	return `Error ${code}`;
+}
+/** Clamp a 0..100 percentage (progress, coverage, …), null-safe. */
+function clampPercent$1(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* Where each {@link VacuumTankProps} field lives (siid/piid). Property ids and
+* enum values are the HA Dreame integration's (Tasshack `dreame-vacuum`
+* `types.py`, `DreameVacuumProperty` → siid/piid map; same on `dev` and
+* v2.0.0b25, checked 2026-09-26). 27/1 and 27/4 were already read here; 27/2 and
+* 27/3 are their neighbours on the same station service. The robot pushes them
+* on change; the consumables refresh also re-reads them from the shadow.
+*/
+var VACUUM_TANK_PROPS = {
+	cleanWaterTankStatus: {
+		siid: 27,
+		piid: 1
+	},
+	waterTank: {
+		siid: 4,
+		piid: 6
+	},
+	detergentStatus: {
+		siid: 27,
+		piid: 4
+	},
+	dustCollection: {
+		siid: 15,
+		piid: 3
+	},
+	dirtyWaterTankStatus: {
+		siid: 27,
+		piid: 2
+	},
+	dustBagStatus: {
+		siid: 27,
+		piid: 3
+	}
+};
+/**
+* Clean-water tank `status`: prefer the richer clean-water-tank-status (27/1),
+* fall back to the coarser water-tank presence (4/6). `null` when neither maps
+* to a known good/low reading (NOT_INSTALLED / CHECKING / unknown). Pure.
+*/
+function cleanWaterTankStatus(props) {
+	if (props.cleanWaterTankStatus !== null) {
+		if (props.cleanWaterTankStatus === 0) return "ok";
+		if (props.cleanWaterTankStatus === 2) return "low";
+		return null;
+	}
+	if (props.waterTank === 1 || props.waterTank === 10) return "ok";
+	return null;
+}
+/** Detergent tank `status` from detergent-status (27/4). Pure. */
+function detergentTankStatus(value) {
+	if (value === 0) return "ok";
+	if (value === 2) return "low";
+	return null;
+}
+/**
+* Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. A dust
+* bag that is missing or asks to be checked (27/3 NOT_INSTALLED / CHECK) is never
+* `ok` — the enum does not say "full" either, so it is unknown. Pure.
+*/
+function dustBinTankStatus(dustCollection, dustBag) {
+	if (dustCollection === 2) return "full";
+	if (dustBag !== null && dustBag !== 0) return null;
+	if (dustCollection === 1) return "ok";
+	return null;
+}
+/**
+* Dirty-water tank `status` from dirty-water-tank-status (27/2). The robot has
+* ONE value for "not installed or full" and cannot tell them apart; lifting the
+* tank out to EMPTY it reads exactly like a full one, so that value is unknown
+* (`null`) — never `full`, which would raise a false "tank full" at the moment
+* someone is fixing it (controller ruling 2026-09-26). Absent or any other
+* value is unknown too, never `ok`.
+*
+* The unambiguous "full" is the robot's own error `MiotError.DirtyWaterTankFull`
+* (86, the library's `errorCode`, siid 2 piid 2): while it is raised the tank is
+* `full` whatever 27/2 says; once it clears, 27/2 decides again. Pure.
+*/
+function dirtyWaterTankStatus(value, errorCode) {
+	if (errorCode === MiotError.DirtyWaterTankFull) return "full";
+	if (value === 0) return "ok";
+	return null;
+}
+/**
+* The four tanks (clean-water / dirty-water / detergent / dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
+* discrete `status` populated from the live MIoT enum props when supplied. Pure.
+*
+* The nodedreame library exposes NO tank FILL-LEVEL telemetry — the cloud shadow
+* (verified against a real `dreame.vacuum.r2538z`) carries only the water-VOLUME
+* *setting* (a mop-flow level, NOT a tank fill). We therefore never fabricate a
+* `level`; `level` is always `null`. The cap contract is honoured on PRESENCE,
+* with `status` derived from the tank-status enums:
+*
+*   - a field is `null` when the hardware HAS NO such tank (capability flags), and
+*   - `{ level: null, status }` when the tank EXISTS — `status` from the enum
+*     prop ('ok' / 'low' / 'full'), or `null` when the device reports none.
+*
+* Presence is derived from the capability record:
+*   - clean-water  ← `canMop` (a mopping robot carries a clean-water reservoir)
+*   - dirty-water  ← `canMopWash` (a self-wash dock has a recovery/dirty tank)
+*   - detergent    ← `hasDetergentReservoir`
+*   - dust-bin     ← `canAutoEmpty` (an auto-empty robot has an onboard dust bin)
+*/
+function decodeVacuumTanks(caps, props, errorCode = null) {
+	const tank = (present, status) => present ? {
+		level: null,
+		status
+	} : null;
+	return {
+		cleanWater: tank(Boolean(caps?.canMop), props ? cleanWaterTankStatus(props) : null),
+		dirtyWater: tank(Boolean(caps?.canMopWash), dirtyWaterTankStatus(props?.dirtyWaterTankStatus ?? null, errorCode)),
+		detergent: tank(Boolean(caps?.hasDetergentReservoir), props ? detergentTankStatus(props.detergentStatus) : null),
+		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection, props.dustBagStatus) : null)
+	};
+}
+/** How each tank is named and what it is, in the order the panel lists them. */
+var TANK_ITEMS = [
+	{
+		key: "cleanWater",
+		label: "Clean water tank",
+		kind: "supply",
+		form: "tank"
+	},
+	{
+		key: "dirtyWater",
+		label: "Dirty water tank",
+		kind: "waste",
+		form: "tank"
+	},
+	{
+		key: "detergent",
+		label: "Detergent",
+		kind: "supply",
+		form: "product"
+	},
+	{
+		key: "dustBin",
+		label: "Dust bin",
+		kind: "waste",
+		form: "bin"
+	}
+];
+/**
+* The tanks as `consumables` items (D915): every PRESENT tank becomes a
+* `supply` (clean water, detergent) or `waste` (dirty water, dust bin) item
+* keyed by its old field name, drawn as a `tank` (the two water tanks), a
+* `product` (detergent) or a `bin` (the dust bin) — the key the notification centre's tank
+* episodes were built on, so an open episode carries on. A tank is never
+* resettable: emptying or refilling it is the reset. Pure.
+*/
+function vacuumTankItems(tanks) {
+	return TANK_ITEMS.flatMap(({ key, label, kind, form }) => {
+		const tank = tanks[key];
+		if (tank === null) return [];
+		return [{
+			key,
+			label,
+			level: tank.level,
+			status: tank.status,
+			kind,
+			form,
+			lastResetAt: null,
+			resettable: false
+		}];
+	});
+}
+/**
+* Clamp a raw consumable percentage to `[0, 100]`, or return `null` when the
+* value is absent / non-finite. The library reports remaining life as a 0..100
+* integer; we clamp defensively so an out-of-range firmware value never violates
+* the cap schema.
+*/
+function clampConsumablePct(value) {
+	if (value === null || !Number.isFinite(value)) return null;
+	return Math.max(0, Math.min(100, value));
+}
+/**
+* The `consumables` cap items for the consumables a vacuum REPORTS.
+*
+* PRESENCE-driven (mirrors HA): the library's `supportedConsumables` enumerates
+* ONLY the consumables this model reports (a present MIoT life property), each
+* with its remaining-life % and whether a reset action exists. No hardcoded
+* per-model list: a consumable the device does not expose never appears.
+*
+* `status` is `null` — the provider reports the level, the notification rule
+* decides what is low. The slice clocks are `nextConsumablesSlice`'s job. Pure.
+*/
+function buildVacuumConsumableItems(readings) {
+	return readings.map((c) => ({
+		key: c.key,
+		label: c.label,
+		level: clampConsumablePct(c.leftPct),
+		status: null,
+		lastResetAt: null,
+		resettable: c.resettable,
+		form: "part"
+	}));
+}
+/** Structural equality of two JSON-shaped values, key order ignored. */
+function jsonEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
+	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	return ka.length === kb.length && ka.every((k) => jsonEqual(Reflect.get(a, k), Reflect.get(b, k)));
+}
+/**
+* The `vacuum-control` slice to write, or `null` when only the clock moved.
+* `recomputeSlice` runs on EVERY push; without this each one was a write (and a
+* `device.state-changed`) even when nothing the robot reported had changed. Pure.
+*/
+function nextVacuumControlSlice(prev, next) {
+	if (prev === void 0) return next;
+	const { lastChangedAt: _prevAt, ...prevContent } = prev;
+	const { lastChangedAt: _nextAt, ...nextContent } = next;
+	return jsonEqual(prevContent, nextContent) ? null : next;
+}
+//#endregion
 //#region src/dreame-entity-catalog.ts
 var STATS = "Statistics";
 var MAINT = "Maintenance";
@@ -143959,14 +144866,6 @@ function enumOptions(e) {
 		label: humanizeEnumName(name)
 	}));
 }
-/**
-* MiotError codes that are BENIGN completion / reminder states, not active
-* faults. HA does not surface these as errors — a fresh cloud-shadow read of an
-* idle docked robot legitimately returns `TaskComplete` (68). We relabel them to
-* the `Clear` label so the Error sensor only shows real faults (HA parity).
-* Extend this set if other non-fault codes surface as spurious "errors".
-*/
-var BENIGN_ERROR_CODES = new Set([MiotError.TaskComplete]);
 /** `MiotError` options with the benign completion codes remapped to the `Clear`
 *  label, so the Error sensor reads as no-error for them (matches HA). */
 function errorEnumOptions() {
@@ -145324,321 +146223,6 @@ var DreameButtonDevice = class extends DreameChildDevice {
 	recomputeSlice() {}
 };
 //#endregion
-//#region src/dreame-vacuum-decode.ts
-/**
-* Pure decode helpers for the Dreame vacuum. Translate the library's MIoT enum
-* values into the camstack `vacuum-control` slice shape. Unit-tested in
-* isolation (no facade, no network) — mirrors `homematic-decode.ts`.
-*/
-/**
-* Map a Dreame {@link MiotState} (siid 2 piid 1) onto the camstack canonical
-* `VacuumState` lifecycle (`idle` / `cleaning` / `paused` / `returning` /
-* `docked` / `error`). A `null` state (not yet observed) settles on `idle`.
-*
-* The MIoT state space is large (~50 values); we collapse it onto the six
-* canonical states by family. Anything unrecognised falls through to `idle`
-* (the safe neutral) so a firmware-added code never throws.
-*/
-function mapMiotStateToVacuumState(state) {
-	if (state === null) return "idle";
-	switch (state) {
-		case MiotState.Charging:
-		case MiotState.ChargingComplete:
-		case MiotState.IntelligentCharging:
-		case MiotState.CleanWashboardBase:
-		case MiotState.AutoRepairBase:
-		case MiotState.WaterSupplyDrainTest:
-		case MiotState.CleanMopRefillWater:
-		case MiotState.AutoEmptying:
-		case MiotState.Emptying:
-		case MiotState.Draining:
-		case MiotState.AutoWaterDraining:
-		case MiotState.Sanitizing: return "docked";
-		case MiotState.MopDrying:
-		case MiotState.DustBagDrying:
-		case MiotState.SanitizingWithDry: return "drying";
-		case MiotState.ReturningToCharge:
-		case MiotState.ReturningToWash:
-		case MiotState.ReturnInstallMop:
-		case MiotState.ReturnRemoveMop:
-		case MiotState.ReturnToEmpty:
-		case MiotState.ReturningToDrain: return "returning";
-		case MiotState.Paused:
-		case MiotState.PausedAlt:
-		case MiotState.PausedCleaning:
-		case MiotState.DustBagDryingPaused:
-		case MiotState.CameraMonitoringPaused:
-		case MiotState.FindingPetPaused:
-		case MiotState.InitialDeepCleanPaused:
-		case MiotState.ChangingMopPaused:
-		case MiotState.FloorMaintainingPaused: return "paused";
-		case MiotState.Standby:
-		case MiotState.WaitingForTask: return "idle";
-		default: return "cleaning";
-	}
-}
-/**
-* The camstack `fanSpeed` token for a Dreame {@link SuctionLevel} — the enum
-* member NAME, lower-cased (`Quiet` → `'quiet'`). Returns `null` for an
-* unobserved / unknown level.
-*/
-function suctionLevelToken(level) {
-	if (level === null) return null;
-	const name = SuctionLevel[level];
-	return typeof name === "string" ? name.toLowerCase() : null;
-}
-/**
-* Resolve a camstack `fanSpeed` token back to the Dreame {@link SuctionLevel}
-* enum value, validated against the model's `supported` levels. Returns null
-* when the token doesn't match a supported level (the caller rejects the set).
-*/
-function tokenToSuctionLevel(token, supported) {
-	const wanted = token.trim().toLowerCase();
-	for (const level of supported) if (suctionLevelToken(level) === wanted) return level;
-	return null;
-}
-/** The list of accepted `fanSpeed` tokens for a model's supported suction set. */
-function supportedFanSpeedTokens(supported) {
-	const tokens = [];
-	for (const level of supported) {
-		const token = suctionLevelToken(level);
-		if (token !== null) tokens.push(token);
-	}
-	return tokens;
-}
-/**
-* Clamp a raw battery reading (already a 0..100 percentage from the library)
-* to the `vacuum-control` slice's `batteryLevel` field. Returns null for a
-* null/NaN/out-of-band reading so the slice stays valid (the schema rejects
-* a number outside 0..100).
-*/
-function clampBatteryLevel$1(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/** Clamp a 0..100 percentage (progress, coverage, …), null-safe. */
-function clampPercent$1(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/**
-* Where each {@link VacuumTankProps} field lives (siid/piid). Property ids and
-* enum values are the HA Dreame integration's (Tasshack `dreame-vacuum`
-* `types.py`, `DreameVacuumProperty` → siid/piid map; same on `dev` and
-* v2.0.0b25, checked 2026-09-26). 27/1 and 27/4 were already read here; 27/2 and
-* 27/3 are their neighbours on the same station service. The robot pushes them
-* on change; the consumables refresh also re-reads them from the shadow.
-*/
-var VACUUM_TANK_PROPS = {
-	cleanWaterTankStatus: {
-		siid: 27,
-		piid: 1
-	},
-	waterTank: {
-		siid: 4,
-		piid: 6
-	},
-	detergentStatus: {
-		siid: 27,
-		piid: 4
-	},
-	dustCollection: {
-		siid: 15,
-		piid: 3
-	},
-	dirtyWaterTankStatus: {
-		siid: 27,
-		piid: 2
-	},
-	dustBagStatus: {
-		siid: 27,
-		piid: 3
-	}
-};
-/**
-* Clean-water tank `status`: prefer the richer clean-water-tank-status (27/1),
-* fall back to the coarser water-tank presence (4/6). `null` when neither maps
-* to a known good/low reading (NOT_INSTALLED / CHECKING / unknown). Pure.
-*/
-function cleanWaterTankStatus(props) {
-	if (props.cleanWaterTankStatus !== null) {
-		if (props.cleanWaterTankStatus === 0) return "ok";
-		if (props.cleanWaterTankStatus === 2) return "low";
-		return null;
-	}
-	if (props.waterTank === 1 || props.waterTank === 10) return "ok";
-	return null;
-}
-/** Detergent tank `status` from detergent-status (27/4). Pure. */
-function detergentTankStatus(value) {
-	if (value === 0) return "ok";
-	if (value === 2) return "low";
-	return null;
-}
-/**
-* Dust-bin `status` from dust-collection (15/3); OVER_USE reads as `full`. A dust
-* bag that is missing or asks to be checked (27/3 NOT_INSTALLED / CHECK) is never
-* `ok` — the enum does not say "full" either, so it is unknown. Pure.
-*/
-function dustBinTankStatus(dustCollection, dustBag) {
-	if (dustCollection === 2) return "full";
-	if (dustBag !== null && dustBag !== 0) return null;
-	if (dustCollection === 1) return "ok";
-	return null;
-}
-/**
-* Dirty-water tank `status` from dirty-water-tank-status (27/2). The robot has
-* ONE value for "not installed or full" and cannot tell them apart; lifting the
-* tank out to EMPTY it reads exactly like a full one, so that value is unknown
-* (`null`) — never `full`, which would raise a false "tank full" at the moment
-* someone is fixing it (controller ruling 2026-09-26). Absent or any other
-* value is unknown too, never `ok`.
-*
-* The unambiguous "full" is the robot's own error `MiotError.DirtyWaterTankFull`
-* (86, the library's `errorCode`, siid 2 piid 2): while it is raised the tank is
-* `full` whatever 27/2 says; once it clears, 27/2 decides again. Pure.
-*/
-function dirtyWaterTankStatus(value, errorCode) {
-	if (errorCode === MiotError.DirtyWaterTankFull) return "full";
-	if (value === 0) return "ok";
-	return null;
-}
-/**
-* The four tanks (clean-water / dirty-water / detergent / dust-bin) decoded from the model's {@link VacuumCapabilities}, with the
-* discrete `status` populated from the live MIoT enum props when supplied. Pure.
-*
-* The nodedreame library exposes NO tank FILL-LEVEL telemetry — the cloud shadow
-* (verified against a real `dreame.vacuum.r2538z`) carries only the water-VOLUME
-* *setting* (a mop-flow level, NOT a tank fill). We therefore never fabricate a
-* `level`; `level` is always `null`. The cap contract is honoured on PRESENCE,
-* with `status` derived from the tank-status enums:
-*
-*   - a field is `null` when the hardware HAS NO such tank (capability flags), and
-*   - `{ level: null, status }` when the tank EXISTS — `status` from the enum
-*     prop ('ok' / 'low' / 'full'), or `null` when the device reports none.
-*
-* Presence is derived from the capability record:
-*   - clean-water  ← `canMop` (a mopping robot carries a clean-water reservoir)
-*   - dirty-water  ← `canMopWash` (a self-wash dock has a recovery/dirty tank)
-*   - detergent    ← `hasDetergentReservoir`
-*   - dust-bin     ← `canAutoEmpty` (an auto-empty robot has an onboard dust bin)
-*/
-function decodeVacuumTanks(caps, props, errorCode = null) {
-	const tank = (present, status) => present ? {
-		level: null,
-		status
-	} : null;
-	return {
-		cleanWater: tank(Boolean(caps?.canMop), props ? cleanWaterTankStatus(props) : null),
-		dirtyWater: tank(Boolean(caps?.canMopWash), dirtyWaterTankStatus(props?.dirtyWaterTankStatus ?? null, errorCode)),
-		detergent: tank(Boolean(caps?.hasDetergentReservoir), props ? detergentTankStatus(props.detergentStatus) : null),
-		dustBin: tank(Boolean(caps?.canAutoEmpty), props ? dustBinTankStatus(props.dustCollection, props.dustBagStatus) : null)
-	};
-}
-/** How each tank is named and what it is, in the order the panel lists them. */
-var TANK_ITEMS = [
-	{
-		key: "cleanWater",
-		label: "Clean water tank",
-		kind: "supply",
-		form: "tank"
-	},
-	{
-		key: "dirtyWater",
-		label: "Dirty water tank",
-		kind: "waste",
-		form: "tank"
-	},
-	{
-		key: "detergent",
-		label: "Detergent",
-		kind: "supply",
-		form: "product"
-	},
-	{
-		key: "dustBin",
-		label: "Dust bin",
-		kind: "waste",
-		form: "bin"
-	}
-];
-/**
-* The tanks as `consumables` items (D915): every PRESENT tank becomes a
-* `supply` (clean water, detergent) or `waste` (dirty water, dust bin) item
-* keyed by its old field name, drawn as a `tank` (the two water tanks), a
-* `product` (detergent) or a `bin` (the dust bin) — the key the notification centre's tank
-* episodes were built on, so an open episode carries on. A tank is never
-* resettable: emptying or refilling it is the reset. Pure.
-*/
-function vacuumTankItems(tanks) {
-	return TANK_ITEMS.flatMap(({ key, label, kind, form }) => {
-		const tank = tanks[key];
-		if (tank === null) return [];
-		return [{
-			key,
-			label,
-			level: tank.level,
-			status: tank.status,
-			kind,
-			form,
-			lastResetAt: null,
-			resettable: false
-		}];
-	});
-}
-/**
-* Clamp a raw consumable percentage to `[0, 100]`, or return `null` when the
-* value is absent / non-finite. The library reports remaining life as a 0..100
-* integer; we clamp defensively so an out-of-range firmware value never violates
-* the cap schema.
-*/
-function clampConsumablePct(value) {
-	if (value === null || !Number.isFinite(value)) return null;
-	return Math.max(0, Math.min(100, value));
-}
-/**
-* The `consumables` cap items for the consumables a vacuum REPORTS.
-*
-* PRESENCE-driven (mirrors HA): the library's `supportedConsumables` enumerates
-* ONLY the consumables this model reports (a present MIoT life property), each
-* with its remaining-life % and whether a reset action exists. No hardcoded
-* per-model list: a consumable the device does not expose never appears.
-*
-* `status` is `null` — the provider reports the level, the notification rule
-* decides what is low. The slice clocks are `nextConsumablesSlice`'s job. Pure.
-*/
-function buildVacuumConsumableItems(readings) {
-	return readings.map((c) => ({
-		key: c.key,
-		label: c.label,
-		level: clampConsumablePct(c.leftPct),
-		status: null,
-		lastResetAt: null,
-		resettable: c.resettable,
-		form: "part"
-	}));
-}
-/** Structural equality of two JSON-shaped values, key order ignored. */
-function jsonEqual(a, b) {
-	if (a === b) return true;
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
-	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
-	const ka = Object.keys(a);
-	const kb = Object.keys(b);
-	return ka.length === kb.length && ka.every((k) => jsonEqual(Reflect.get(a, k), Reflect.get(b, k)));
-}
-/**
-* The `vacuum-control` slice to write, or `null` when only the clock moved.
-* `recomputeSlice` runs on EVERY push; without this each one was a write (and a
-* `device.state-changed`) even when nothing the robot reported had changed. Pure.
-*/
-function nextVacuumControlSlice(prev, next) {
-	if (prev === void 0) return next;
-	const { lastChangedAt: _prevAt, ...prevContent } = prev;
-	const { lastChangedAt: _nextAt, ...nextContent } = next;
-	return jsonEqual(prevContent, nextContent) ? null : next;
-}
-//#endregion
 //#region src/devices/dreame-camera-stream.ts
 /**
 * The robot camera as a stream the broker can pull — the pure facts.
@@ -194499,7 +195083,7 @@ var DreameVacuumDevice = class extends DreameChildDevice {
 			availableFanSpeeds: supportedFanSpeedTokens(vacuum.supportedSuctionLevels),
 			progressPercent: clampPercent$1(vacuum.taskProgressPct),
 			errorCode: vacuum.errorCode,
-			errorLabel: vacuum.errorCode ? `Error ${vacuum.errorCode}` : null,
+			errorLabel: vacuumErrorLabel(vacuum.errorCode),
 			lastChangedAt: Date.now()
 		};
 		const toWrite = nextVacuumControlSlice(this.runtimeState.getCapState(CAP_NAME$1), controlSlice);