@camstack/addon-provider-bosch 0.1.20 → 0.1.22

package/dist/{dist-B75tWQLF.mjs → dist-DGlq0nuG.mjs}

@@ -1,5 +1,5 @@
 import "node:crypto";
-//#region ../types/dist/event-category-fDPduoeC.mjs
+//#region ../types/dist/event-category-Ceif8n-v.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -471,6 +471,10 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	* on the device detail page.
 	*/
 	EventCategory["DoorbellOnPressed"] = "doorbell.onPressed";
+	/** Mirrors `runningStateCapability.events.onStarted`. */
+	EventCategory["RunningStarted"] = "running.started";
+	/** Mirrors `runningStateCapability.events.onFinished`. */
+	EventCategory["RunningFinished"] = "running.finished";
 	/**
 	* Cap event fired by every device that registers the `event-emitter`
 	* capability. Mirrors `eventEmitterCapability.events.onEvent`. Carries
@@ -5430,7 +5434,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CHIEEJkY.mjs
+//#region ../types/dist/sleep-CYfIZzGv.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -5773,7 +5777,7 @@ Object.fromEntries([
 * `hydrateSchema` to skip the `value` injection for structural-only fields.
 */
 function isValuelessField(field) {
-	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
+	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button" || field.type === "account-sign-in" || field.type === "secret-presence";
 }
 function hydrateSchema(schema, values, options = {}) {
 	return {
@@ -8837,7 +8841,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-CB6PMT9p.mjs
+//#region ../types/dist/composition-BJ8iAZb3.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -8897,7 +8901,7 @@ portable("linux64"), portable("linuxarm64"), portable("macarm64"), portable("mac
 * ONE table for everyone who asks "is this device HIGH?": the
 * recorder's `RecordingTriggers.sensorDeviceIds` trigger, the post-analysis
 * sensor markers, the orchestrator's camera-sensors bridge and
-* the sources of a composite doorbell (`doorbellFeatureSources`, D671).
+* the sources of a pulse (`compilePulseOverride`, D936).
 * A second copy would diverge at the first cap added, and the symptom — "the
 * sensor rings the doorbell but does not record" — is exactly D62.
 *
@@ -9138,6 +9142,20 @@ var table = {
 		apply: () => {
 			throw new ExpressionEvalError("count: stateful evaluation context is required");
 		}
+	},
+	dwell: {
+		minArgs: 3,
+		maxArgs: 3,
+		apply: () => {
+			throw new ExpressionEvalError("dwell: stateful evaluation context is required");
+		}
+	},
+	latchedAt: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: () => {
+			throw new ExpressionEvalError("latchedAt: stateful evaluation context is required");
+		}
 	}
 };
 Object.freeze(Object.assign(Object.create(null), table));
@@ -16087,7 +16105,15 @@ Object.freeze({
 		kind: "fixed",
 		result: ["number", "null"]
 	},
-	count: NUMBER
+	count: NUMBER,
+	dwell: {
+		kind: "fixed",
+		result: ["boolean", "null"]
+	},
+	latchedAt: {
+		kind: "fixed",
+		result: ["number", "null"]
+	}
 });
 `${COMPOSED_DEVICE_STABLE_ID_PREFIX}`;
 /**
@@ -42534,9 +42560,6 @@ var NcSystemEventKindSchema = _enum([
 	"device-battery-normal",
 	"device-consumable-low",
 	"device-consumable-normal",
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -42583,13 +42606,14 @@ var NcSystemEventKindSchema = _enum([
 	"camera-enabled"
 ]);
 /** The legacy tail of {@link NcSystemEventKindSchema} — see its docblock. */
-var NC_LEGACY_SYSTEM_EVENT_KINDS = new Set([
+var NC_LEGACY_SYSTEM_EVENT_KINDS = [
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
 	"camera-enabled"
-]);
-NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KINDS.has(kind));
+];
+var NC_LEGACY_SYSTEM_EVENT_KIND_SET = new Set(NC_LEGACY_SYSTEM_EVENT_KINDS);
+NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KIND_SET.has(kind));
 /**
 * The panel's transitions, as ONE list.
 *
@@ -43708,18 +43732,11 @@ var NcRuleSchema = NcRuleInputSchema.extend({
 	*/
 	disabledTargetIds: array(string()).default([])
 });
-/**
-* The state-summary SECTIONS (D647 / D698 / D708): the D637 kind groups that
-* report a still-true state. `addons` is the crash-looped addons only and
-* `addon-updates` the addons that are behind (D708 split them). `backups-exports` and `alarm` are not sections — a completed
-* job is not an open state, and the alarm stays instant.
-*/
 var NcStateSummarySectionIdSchema = _enum([
 	"device-state",
 	"streams",
 	"battery",
 	"consumables",
-	"tanks",
 	"detection-blind",
 	"nodes",
 	"addons",
@@ -54339,20 +54356,68 @@ var BatteryStatusSchema = object({
 	*/
 	binary: boolean().optional()
 });
+var BATTERY_DEVICE_TYPES = [
+	DeviceType.Camera,
+	DeviceType.Sensor,
+	DeviceType.Button,
+	DeviceType.Switch,
+	DeviceType.PetFeeder,
+	DeviceType.Container,
+	DeviceType.Thermostat
+];
+/** Generic Customize target for the percentage reading (D936). */
+var batteryCustomize = {
+	version: 1,
+	targets: [{
+		id: "percentage",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "battery",
+			stateField: "percentage"
+		},
+		deviceTypes: BATTERY_DEVICE_TYPES,
+		apply: "add-or-replace",
+		path: "percentage",
+		sources: [{
+			kind: "field",
+			valueKinds: ["number", "string"],
+			transforms: [{ kind: "identity" }, {
+				kind: "linear",
+				defaultScale: 1,
+				defaultOffset: 0,
+				clampMin: 0,
+				clampMax: 100
+			}]
+		}],
+		companions: [
+			{
+				kind: "constant",
+				path: "charging",
+				value: "unknown",
+				when: "add"
+			},
+			{
+				kind: "constant",
+				path: "sleeping",
+				value: false,
+				when: "add"
+			},
+			{
+				kind: "clock",
+				path: "lastUpdated",
+				when: "add"
+			}
+		],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	}]
+};
 var batteryCapability = {
 	name: "battery",
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [
-		DeviceType.Camera,
-		DeviceType.Sensor,
-		DeviceType.Button,
-		DeviceType.Switch,
-		DeviceType.PetFeeder,
-		DeviceType.Container,
-		DeviceType.Thermostat
-	],
+	deviceTypes: BATTERY_DEVICE_TYPES,
 	methods: { 
 	/**
 	* Explicitly wake the camera from low-power sleep ahead of a
@@ -54436,6 +54501,7 @@ onStatusChanged: { data: object({
 		kind: "gauge",
 		unit: "%"
 	} } },
+	customize: batteryCustomize,
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastUpdated"]
@@ -55404,6 +55470,106 @@ var ConsumablesStatusSchema = object({
 	items: array(ConsumableItemSchema),
 	lastChangedAt: number()
 });
+/** Synthesize seed for a link-built status (no native provider).
+*
+*  ⚠ NO LIVE CALLER since 2026-08-08 (device-links deleted; see
+*  `CapabilityStatusSchema.empty`). The wiring guidance below was written for
+*  exactly the case the operator is asking about again — a Dreame's HA
+*  consumable-life sensors — so it is kept for that conversation, not because
+*  anything reads it today. */
+var EMPTY_STATUS = {
+	items: [],
+	lastChangedAt: 0
+};
+/** Seed for a NEW link-built consumable item. `key`/`label` are overwritten
+*  with the link's `itemKey` (see `status.itemArray`), so the placeholder
+*  empty strings never survive into a validated item. Link-built items are
+*  not resettable — there is no native provider to receive `reset()`.
+*
+*  Wiring guidance (HA vacuum consumable-life sensors):
+*  - a percent-remaining source (`numeric-sensor`, unit '%') → `level` via
+*    `identity` (or `linear` scale 1 offset 0 clamp [0,100] to be safe);
+*  - an hours-remaining source (e.g. Dreame 'Main Brush Time Left', unit 'h')
+*    → `level` via `linear` with scale = 100 / max-hours for that item
+*    (e.g. main brush 300 h → scale 0.3333) + clamp [0,100];
+*  - a discrete source (`enum-sensor`, e.g. mop pad 'installed') → `status`
+*    via `enum-map` (e.g. { installed: 'ok', missing: 'replace' }).
+*  A numeric→'replace' THRESHOLD (level < 10 → 'replace') is NOT expressible
+*  with the current transform kinds — leave `status` null (valid) until the
+*  expression transform lands. */
+/** Generic Customize target for one consumable item (D936). Native rows stay read-only. */
+var consumablesCustomize = {
+	version: 1,
+	targets: [{
+		id: "items",
+		cardinality: "keyedArray",
+		vocabulary: { cap: "consumables" },
+		deviceTypes: Object.values(DeviceType),
+		apply: "add",
+		path: "items",
+		keyField: "key",
+		labelField: "label",
+		itemSchema: ConsumableItemSchema,
+		nativeItems: "read-only",
+		sourceReport: { status: "assignment-status" },
+		fields: [
+			{
+				path: "level",
+				sources: [{
+					kind: "numeric",
+					transforms: [{ kind: "identity" }, {
+						kind: "linear",
+						defaultScale: 1,
+						defaultOffset: 0,
+						clampMin: 0,
+						clampMax: 100
+					}]
+				}]
+			},
+			{
+				path: "remaining.value",
+				sources: [{
+					kind: "numeric",
+					transforms: [{ kind: "identity" }]
+				}],
+				literals: [{
+					path: "remaining.unit",
+					values: [...ConsumableRemainingUnitSchema.options]
+				}]
+			},
+			{
+				path: "status",
+				sources: [{
+					kind: "enum",
+					transforms: [{
+						kind: "enum-map",
+						outputValues: [...ConsumableStatusSchema.options],
+						unmapped: null
+					}]
+				}]
+			}
+		],
+		traits: [{
+			path: "kind",
+			values: [...ConsumableKindSchema.options],
+			defaultValue: "wear"
+		}, {
+			path: "form",
+			values: [...ConsumableFormSchema.options],
+			defaultValue: "part"
+		}],
+		companions: [{
+			kind: "clock",
+			path: "lastChangedAt",
+			when: "add"
+		}, {
+			kind: "clock",
+			path: "lastFetchedAt",
+			when: "add"
+		}],
+		advancedExpression: true
+	}]
+};
 var consumablesCapability = {
 	name: "consumables",
 	scope: "device",
@@ -55441,10 +55607,7 @@ reset: method(object({
 	status: {
 		schema: ConsumablesStatusSchema,
 		kind: "push",
-		empty: {
-			items: [],
-			lastChangedAt: 0
-		},
+		empty: EMPTY_STATUS,
 		itemArray: {
 			path: "items",
 			keyField: "key",
@@ -55480,6 +55643,7 @@ reset: method(object({
 	* brush's remaining life and a dishwasher's salt are each recorded the moment
 	* their provider reports them; an item that appears later gets its series.
 	*/
+	customize: consumablesCustomize,
 	history: {
 		fields: {},
 		items: {
@@ -56222,6 +56386,36 @@ var dishwasherCapability = {
 		powerOn: { kind: "boolean" }
 	} }
 };
+/** Pulse override: a rising edge advances `lastPressedAt` and the press count. */
+var doorbellCustomize = {
+	version: 1,
+	targets: [{
+		id: "pressed",
+		cardinality: "event",
+		shape: "pulse",
+		vocabulary: {
+			cap: "doorbell",
+			eventName: "onPressed"
+		},
+		deviceTypes: [DeviceType.Camera],
+		apply: "add",
+		applyAuthority: { kind: "composition-claim" },
+		eventName: "onPressed",
+		edges: ["rising"],
+		timestampPath: "lastPressedAt",
+		counterPath: "pressCountSinceStart",
+		highWater: "composer-advance",
+		combine: "any",
+		debounce: {
+			kind: "rising-edge",
+			defaultDebounceMs: 2e3,
+			changedAtRequired: true
+		},
+		sources: [{ kind: "binary" }, { kind: "switch" }],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: true
+	}]
+};
 var DoorbellStatusSchema = object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
 	lastPressedAt: number().nullable(),
@@ -56288,7 +56482,8 @@ onPressed: {
 	/**
 	* History (D850): none — `pressCountSinceStart` resets with the addon, so it is not a monotonic meter; presses live in the events ledger.
 	*/
-	history: "none"
+	history: "none",
+	customize: doorbellCustomize
 };
 /**
 * Enum-state sensor — a string value picked from a finite option set.
@@ -58684,6 +58879,38 @@ authKey: string().optional() }), object({
 	/** Human-readable error when `ok: false`. */
 	error: string().optional()
 }), { kind: "mutation" });
+/** Span override: start on a rising edge, end on a fall or this timeout. */
+var motionCustomize = {
+	version: 1,
+	targets: [{
+		id: "detected",
+		cardinality: "event",
+		shape: "span",
+		vocabulary: {
+			cap: "motion",
+			eventName: "onMotionChanged"
+		},
+		deviceTypes: [DeviceType.Camera],
+		apply: "replace",
+		applyAuthority: {
+			kind: "camera-sensors",
+			timeoutField: "motionCooldownMs"
+		},
+		eventName: "onMotionChanged",
+		start: "rising-edge",
+		end: "falling-edge-or-timeout",
+		timeoutMs: 3e4,
+		combine: "any",
+		sourceModes: [
+			"in-addition",
+			"confirm",
+			"replace"
+		],
+		sources: [{ kind: "binary" }, { kind: "switch" }],
+		sourceReport: { status: "assignment-status" },
+		advancedExpression: false
+	}]
+};
 var MotionStatusSchema = object({
 	detected: boolean(),
 	/** Ms epoch of the last detected-true observation. Null if never detected. */
@@ -58823,7 +59050,8 @@ onMotionChanged: { data: MotionOnMotionChangedDataSchema } },
 	history: { fields: { detected: {
 		kind: "boolean",
 		excludeDeviceTypes: [DeviceType.Camera]
-	} } }
+	} } },
+	customize: motionCustomize
 };
 /**
 * Motion-trigger toggle for accessory devices.
@@ -61549,6 +61777,133 @@ var ptzAutotrackCapability = {
 	*/
 	history: "none"
 };
+var RUNNING_POWER_START_DELAY_MS = 3e4;
+var RUNNING_POWER_STOP_DELAY_MS = 18e4;
+/** Before any provider reading — all fields unknown (D933). */
+var RUNNING_STATE_COLD = {
+	running: null,
+	since: null,
+	source: "native",
+	phase: null,
+	lastFetchedAt: null
+};
+var RunningStateSourceSchema = _enum(["native", "assigned"]);
+var RunningStateStatusSchema = object({
+	/** null = unknown — never coerced to false (D393). */
+	running: boolean().nullable(),
+	/** Epoch ms the current boolean began; null while `running` is null. */
+	since: number().nullable(),
+	source: RunningStateSourceSchema,
+	phase: string().nullable(),
+	/** null until a reading has been published (D393). */
+	lastFetchedAt: number().nullable()
+});
+var RunningFlipEventDataSchema = object({
+	deviceId: number(),
+	since: number().nullable(),
+	phase: string().nullable()
+});
+var RUNNING_DEVICE_TYPES = Object.values(DeviceType);
+/** Generic Customize target for the running boolean (D936). */
+var runningCustomize = {
+	version: 1,
+	targets: [{
+		id: "running",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "running-state",
+			stateField: "running"
+		},
+		deviceTypes: [
+			DeviceType.Dishwasher,
+			DeviceType.Vacuum,
+			DeviceType.LawnMower,
+			DeviceType.MediaPlayer,
+			DeviceType.WaterHeater,
+			DeviceType.Humidifier,
+			DeviceType.Fan,
+			DeviceType.Climate,
+			DeviceType.Thermostat,
+			DeviceType.PetFeeder
+		],
+		apply: "add-or-replace",
+		path: "running",
+		sources: [
+			{
+				kind: "switch",
+				transforms: [{ kind: "identity" }]
+			},
+			{
+				kind: "binary",
+				transforms: [{ kind: "identity" }, { kind: "invert" }]
+			},
+			{
+				kind: "numeric",
+				requiredUnit: "W",
+				transforms: [{
+					kind: "threshold",
+					comparison: "gte",
+					defaultThreshold: 5,
+					defaultStartDwellMs: RUNNING_POWER_START_DELAY_MS,
+					defaultStopDwellMs: RUNNING_POWER_STOP_DELAY_MS,
+					thresholdUnit: "W"
+				}]
+			}
+		],
+		companions: [
+			{
+				kind: "constant",
+				path: "source",
+				value: "assigned",
+				when: "always"
+			},
+			{
+				kind: "constant",
+				path: "phase",
+				value: null,
+				when: "always"
+			},
+			{
+				kind: "clock",
+				path: "lastFetchedAt",
+				when: "always"
+			},
+			{
+				kind: "transition-time",
+				path: "since",
+				sourceChangedAt: "prefer"
+			}
+		],
+		sourceReport: {
+			status: "assignment-status",
+			runtimeField: "source",
+			nativeValue: "native",
+			assignedValue: "assigned"
+		},
+		advancedExpression: true
+	}]
+};
+var runningStateCapability = {
+	name: "running-state",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: RUNNING_DEVICE_TYPES,
+	methods: {},
+	events: {
+		onStarted: { data: RunningFlipEventDataSchema },
+		onFinished: { data: RunningFlipEventDataSchema }
+	},
+	status: {
+		schema: RunningStateStatusSchema,
+		kind: "push"
+	},
+	runtimeState: RunningStateStatusSchema,
+	durability: "restored",
+	history: { fields: { running: { kind: "boolean" } } },
+	volatileStateFields: ["lastFetchedAt"],
+	customize: runningCustomize
+};
 DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceId: number().int().nonnegative() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -66179,6 +66534,37 @@ method(object({}), array(TrainingBaseModelSchema).readonly(), { auth: "admin" })
 	kind: "mutation",
 	auth: "admin"
 });
+function programStartFromRemaining(running, remainingSeconds, fetchedAt) {
+	if (!running || remainingSeconds === null || remainingSeconds === void 0) return null;
+	if (remainingSeconds <= 0) return null;
+	return fetchedAt - remainingSeconds * 1e3;
+}
+function resolveSince(running, previous, transitionAtMs, bootstrapSinceMs) {
+	if (running === null) return null;
+	const prevRunning = previous?.running ?? null;
+	if (prevRunning === null) return bootstrapSinceMs;
+	if (prevRunning !== running) return transitionAtMs;
+	return previous?.since ?? null;
+}
+function nativeSlice(running, phase, previous, transitionAtMs, fetchedAt, bootstrapSinceMs) {
+	return {
+		running,
+		since: resolveSince(running, previous, transitionAtMs, bootstrapSinceMs),
+		source: "native",
+		phase: running === null ? null : phase,
+		lastFetchedAt: fetchedAt
+	};
+}
+function runningFromDishwasherOperation(operation, program, previous, fetchedAt, remainingSeconds, transitionAt) {
+	const transitionAtMs = transitionAt ?? fetchedAt;
+	if (operation === null) return nativeSlice(null, null, previous, transitionAtMs, fetchedAt, null);
+	if (operation === "Run" || operation === "Aborting") {
+		const bootstrap = programStartFromRemaining(true, remainingSeconds, fetchedAt);
+		return nativeSlice(true, program ?? operation, previous, transitionAtMs, fetchedAt, bootstrap);
+	}
+	if (operation === "Pause") return nativeSlice(false, "Pause", previous, transitionAtMs, fetchedAt, null);
+	return nativeSlice(false, operation, previous, transitionAtMs, fetchedAt, null);
+}
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
 Object.freeze({
 	person: .5,
@@ -66530,6 +66916,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	ptzAutotrack: ptzAutotrackCapability,
 	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
+	runningState: runningStateCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
@@ -75272,6 +75659,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"runningState.getStatus": {
+		capName: "running-state",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -79986,6 +80380,32 @@ var APPLIANCE_CAP_VOCABULARY = {
 		}],
 		events: { onSent: { notOperatorFacing: "a delivery receipt of a send this system made — not a fact about the world" } }
 	},
+	"running-state": {
+		scope: "device",
+		noun: t("Running", "In funzione"),
+		state: [{
+			kind: "boolean",
+			field: "running",
+			label: t("Running", "In funzione"),
+			whenTrue: t("When {device} starts", "Quando {device} inizia"),
+			whenFalse: t("When {device} finishes", "Quando {device} finisce"),
+			icon: "play"
+		}],
+		events: {
+			onStarted: {
+				category: EventCategory.RunningStarted,
+				label: t("Started running", "Ha iniziato a funzionare"),
+				phrase: t("When {device} starts running", "Quando {device} inizia a funzionare"),
+				icon: "play"
+			},
+			onFinished: {
+				category: EventCategory.RunningFinished,
+				label: t("Finished", "Ha finito"),
+				phrase: t("When {device} finishes", "Quando {device} finisce"),
+				icon: "square"
+			}
+		}
+	},
 	update: {
 		scope: "device",
 		noun: t("Firmware update", "Aggiornamento firmware"),
@@ -83526,6 +83946,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"runningState.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.captureReference": [{
 		name: "deviceId",
 		form: "single",
@@ -84024,6 +84449,96 @@ Object.freeze({
 	"smtp-provider": "email"
 });
 DeviceType.Camera;
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher, DeviceType.Camera, DeviceType.Camera, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder;
+/**
+* A saved Customize assignment (D936). The schema is the type: callers use
+* `z.infer`, they do not restate the shape.
+*/
+var OverrideSourceSchema = object({
+	addonId: string().min(1),
+	stableId: string().min(1),
+	cap: string().min(1),
+	fieldPath: string().min(1)
+});
+var CustomizeTransformDraftSchema = discriminatedUnion("kind", [
+	object({ kind: literal("identity") }),
+	object({ kind: literal("invert") }),
+	object({
+		kind: literal("threshold"),
+		comparison: _enum(["gte", "lte"]),
+		threshold: number(),
+		startDwellMs: number().nonnegative(),
+		stopDwellMs: number().nonnegative()
+	}),
+	object({
+		kind: literal("linear"),
+		scale: number(),
+		offset: number(),
+		clampMin: number().optional(),
+		clampMax: number().optional()
+	}),
+	object({
+		kind: literal("enum-map"),
+		mapping: record(string(), string().nullable())
+	}),
+	object({ kind: literal("number") })
+]);
+var ScalarOverrideDraftSchema = object({
+	kind: literal("scalar"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var KeyedArrayOverrideDraftSchema = object({
+	kind: literal("keyedArray"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	key: string().min(1),
+	label: string().min(1),
+	fieldPath: string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var PulseOverrideDraftSchema = object({
+	kind: literal("pulse"),
+	cap: string().min(1),
+	targetId: string().min(1),
+	enabled: boolean(),
+	debounceMs: number().nonnegative(),
+	sources: array(OverrideSourceSchema).min(1)
+});
+var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: _enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]).optional() });
+discriminatedUnion("kind", [
+	ScalarOverrideDraftSchema,
+	KeyedArrayOverrideDraftSchema,
+	PulseOverrideDraftSchema,
+	object({
+		kind: literal("span"),
+		cap: string().min(1),
+		targetId: string().min(1),
+		timeoutMs: number().nonnegative(),
+		cooldownMs: number().nonnegative().optional(),
+		sources: array(SpanSourceDraftSchema)
+	})
+]);
+object({
+	targetId: string().min(1),
+	configured: boolean(),
+	source: _enum(["native", "assigned"]),
+	state: _enum([
+		"active",
+		"stale",
+		"released",
+		"unavailable"
+	]),
+	reason: string().nullable()
+});
+String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 var G711_SCALE_CORRECTION_DB = {
 	PCMU: 20 * Math.log10(4),
 	PCMA: 20 * Math.log10(8)
@@ -84076,40 +84591,7 @@ var NC_AUDIO_DEFAULTS = {
 	samplingSeconds: 10
 };
 new Set(["devices", "classes"]);
-/**
-* WHICH narrowing filter speaks about WHICH system-event kind — one predicate,
-* consumed by the rule ENGINE and by every rule EDITOR.
-*
-* ── The failure this file exists for ───────────────────────────────────────
-* `NcSystemEventConditionSchema` carries four optional narrowing lists
-* (`deviceIds`, `deviceTypes`, `nodeIds`, `packageNames`) beside a required
-* `kinds` gate. They are not four filters over one vocabulary: each belongs to
-* a FAMILY of kinds and is meaningless outside it. A node going away has no
-* device type; a completed export has no package; `stream-offline` deliberately
-* carries no device type at all (a stream belongs to a camera by construction).
-*
-* The engine applied all four to every kind, so a filter from one family failed
-* a kind from another family CLOSED. The operator's live rule "Eventi di
-* sistema" selected eleven kinds and set `deviceTypes: ['camera']` — the only
-* way to say "only my cameras" about the two liveness kinds — and NINE of the
-* eleven silently stopped being deliverable. Four days of history contained
-* `device-online` and `device-offline` and nothing else, across a window in
-* which agents were restarted and addons were updated.
-*
-* Both editors already computed this scoping, to decide which filter boxes to
-* render; the cap's own docblock already promised it ("Narrow a `device-*` kind
-* to these device TYPES"). Only the engine disagreed, and it disagreed in the
-* destructive direction. So the rule is stated ONCE, here, and the engine and
-* the editors are readers of it rather than three independent authors.
-*
-* ── The direction ─────────────────────────────────────────────────────────
-* Out of family ⇒ the filter is IGNORED, never fail-closed. An editor that
-* hides a box has already told the operator this filter does not speak about
-* these kinds, so honouring it as an exclusion contradicts the only
-* explanation the operator was ever given. Inside its family the filter still
-* narrows, and still fails CLOSED on a subject that cannot produce the identity
-* it tests (a device the mirror cannot name is not evidence of a camera).
-*/
+new Set(NC_LEGACY_SYSTEM_EVENT_KINDS);
 /**
 * Every filter, for the callers that must cover all of them (guards, tests).
 *
@@ -84135,9 +84617,6 @@ new Map(Object.entries({
 	"device-battery-normal": "device-events",
 	"device-consumable-low": "device-events",
 	"device-consumable-normal": "device-events",
-	"device-tank-low": "device-events",
-	"device-tank-full": "device-events",
-	"device-tank-normal": "device-events",
 	"stream-online": "device-events",
 	"stream-offline": "device-events",
 	"detection-blind": "device-events",
@@ -84214,16 +84693,6 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Consumables",
 		kinds: ["device-consumable-low", "device-consumable-normal"]
 	},
-	{
-		id: "tanks",
-		family: "device-events",
-		label: "Tanks",
-		kinds: [
-			"device-tank-low",
-			"device-tank-full",
-			"device-tank-normal"
-		]
-	},
 	{
 		id: "detection-blind",
 		family: "device-events",
@@ -84381,11 +84850,6 @@ var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];
 var CONSUMABLE = ["device-consumable-low", "device-consumable-normal"];
-var TANK = [
-	"device-tank-low",
-	"device-tank-full",
-	"device-tank-normal"
-];
 var ALERT_EPISODE = [
 	"alert-critical",
 	"alert-error",
@@ -84417,7 +84881,6 @@ var DEVICE_EVENTS = [
 	"device-enabled",
 	...BATTERY,
 	...CONSUMABLE,
-	...TANK,
 	"stream-online",
 	"stream-offline",
 	"detection-blind",
@@ -84463,12 +84926,6 @@ var STATE_SUMMARY_SECTION_VARS = [
 		example: "Robot — filter 10 %",
 		kinds: CONSUMABLE
 	},
-	{
-		name: "summaryTanks",
-		label: "Summary: tanks",
-		example: "Robot — clean water low",
-		kinds: TANK
-	},
 	{
 		name: "summaryDetection",
 		label: "Summary: cameras detecting nothing",
@@ -84584,8 +85041,7 @@ var STATE_SUMMARY_VARS = [
 	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...BATTERY, ...CONSUMABLE]),
-	([...RULE_TEXT], [...CONSUMABLE, ...TANK]),
-	([...RULE_TEXT], [...TANK]),
+	([...RULE_TEXT], [...CONSUMABLE]),
 	[...RULE_TEXT],
 	([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
 	([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
@@ -84689,15 +85145,6 @@ new Map([
 		snapshotLabel: "Consumables low now",
 		snapshotSection: "consumables"
 	},
-	{
-		id: "tanks",
-		family: "device-events",
-		label: "Tanks (low or full / back to normal)",
-		bad: ["device-tank-low", "device-tank-full"],
-		recovery: ["device-tank-normal"],
-		snapshotLabel: "Tanks low or full now",
-		snapshotSection: "tanks"
-	},
 	{
 		id: "motion-noise",
 		family: "device-events",
@@ -85286,4 +85733,4 @@ DEFAULT_NATIVE_LEASE_SETTINGS.admission;
 var MB = 1024 * 1024;
 1024 * MB, 3072 * MB;
 //#endregion
-export { number as A, customAction as C, _enum as D, isSecretMarkerLike as E, unknown as F, EventCategory as I, record as M, string as N, array as O, union as P, createEvent as S, isSecretMarker as T, temperatureSensorCapability as _, binaryCapability as a, DeviceType as b, consumablesCapability as c, enumSensorCapability as d, eventEmitterCapability as f, switchCapability as g, powerMeterCapability as h, batteryCapability as i, object as j, literal as k, deviceAdoptionCapability as l, numericSensorCapability as m, BaseDeviceProvider as n, climateControlCapability as o, heatingValveCapability as p, DishwasherOperationStateSchema as r, connectionTestCapability as s, BaseDevice as t, dishwasherCapability as u, waterHeaterCapability as v, defineCustomActions as w, errMsg as x, DeviceRole as y };
+export { _enum as A, DeviceType as C, defineCustomActions as D, customAction as E, record as F, string as I, union as L, literal as M, number as N, isSecretMarker as O, object as P, unknown as R, DeviceRole as S, createEvent as T, runningFromDishwasherOperation as _, batteryCapability as a, temperatureSensorCapability as b, connectionTestCapability as c, dishwasherCapability as d, enumSensorCapability as f, powerMeterCapability as g, numericSensorCapability as h, RUNNING_STATE_COLD as i, array as j, isSecretMarkerLike as k, consumablesCapability as l, heatingValveCapability as m, BaseDeviceProvider as n, binaryCapability as o, eventEmitterCapability as p, DishwasherOperationStateSchema as r, climateControlCapability as s, BaseDevice as t, deviceAdoptionCapability as u, runningStateCapability as v, errMsg as w, waterHeaterCapability as x, switchCapability as y, EventCategory as z };