@camstack/system 1.2.473 → 1.2.475

package/dist/{dist-Bmah6waF.js → dist-BtDdPdZ7.js}

@@ -1,6 +1,6 @@
 let zod = require("zod");
 require("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";
@@ -472,6 +472,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
@@ -761,7 +765,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#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).
@@ -1152,7 +1156,7 @@ var WELL_KNOWN_TAB_MAP = 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 {
@@ -5480,7 +5484,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-CB6PMT9p.mjs
+//#region ../types/dist/composition-BJ8iAZb3.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -5932,7 +5936,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.
 *
@@ -6011,7 +6015,7 @@ var ExpressionEvalError = class extends Error {
 	}
 };
 function isStatefulBuiltin(name) {
-	return name === "rose" || name === "count";
+	return name === "rose" || name === "count" || name === "dwell" || name === "latchedAt";
 }
 function asFiniteNumber(value, name, index) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
@@ -6102,6 +6106,57 @@ function disarmRoseMemory(memory) {
 * input is its own `lastPressedAt`, which only advances on a `rose` edge that
 * also emits the press — but an external input can overcount by one.
 */
+function asNonNegativeMs(value, name, index) {
+	const ms = asFiniteNumber(value, name, index);
+	if (ms < 0) throw new ExpressionEvalError(`${name}: delay must be a non-negative finite number`);
+	return ms;
+}
+/**
+* `dwell(active, onForMs, offForMs)`: unknown until a delay elapses, then holds
+* the latched boolean through gaps shorter than the opposing delay (D933).
+*/
+function evaluateDwell(activeRaw, onForMsRaw, offForMsRaw, call, nowMs, hooks) {
+	const active = asBoolean(activeRaw, "dwell", 0);
+	const onForMs = asNonNegativeMs(onForMsRaw, "dwell", 1);
+	const offForMs = asNonNegativeMs(offForMsRaw, "dwell", 2);
+	if (call.latched === null) {
+		if (call.seenSince === null) call.seenSince = nowMs;
+		const delay = active ? onForMs : offForMs;
+		if (nowMs - call.seenSince >= delay) {
+			call.latched = active;
+			return call.latched;
+		}
+		hooks?.noteDeadline?.(call.seenSince + delay);
+		return null;
+	}
+	if (active === call.latched) {
+		call.pendingSince = null;
+		return call.latched;
+	}
+	if (call.pendingSince === null) call.pendingSince = nowMs;
+	const delay = active ? onForMs : offForMs;
+	if (nowMs - call.pendingSince >= delay) {
+		call.latched = active;
+		call.pendingSince = null;
+		return call.latched;
+	}
+	hooks?.noteDeadline?.(call.pendingSince + delay);
+	return call.latched;
+}
+/** `latchedAt(value)`: epoch ms when `value` last changed; null clears the stamp. */
+function evaluateLatchedAt(value, call, nowMs) {
+	if (value === null) {
+		call.last = null;
+		call.at = null;
+		return null;
+	}
+	if (typeof value !== "boolean" && typeof value !== "number" && typeof value !== "string") return call.at;
+	if (call.last !== value) {
+		call.last = value;
+		call.at = nowMs;
+	}
+	return call.at;
+}
 function evaluateCount(input, call, currentOutput) {
 	const currentCount = typeof currentOutput === "number" && Number.isFinite(currentOutput) && currentOutput >= 0 ? currentOutput : 0;
 	if (input === null) {
@@ -6271,6 +6326,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");
+		}
 	}
 };
 /** Frozen, null-prototype builtin table. */
@@ -6816,7 +6885,7 @@ function cloneStatefulExpressionMemory(memory) {
 		disarmRoseNext: memory.disarmRoseNext
 	};
 }
-function evaluateStatefulExpressionCall(invocation, memory, env) {
+function evaluateStatefulExpressionCall(invocation, memory, env, hooks) {
 	const existing = memory.calls.get(invocation.path);
 	switch (invocation.name) {
 		case "rose": {
@@ -6838,6 +6907,25 @@ function evaluateStatefulExpressionCall(invocation, memory, env) {
 			memory.calls.set(invocation.path, call);
 			return evaluateCount(invocation.args[0], call, env.currentOutput);
 		}
+		case "dwell": {
+			const call = existing?.kind === "dwell" ? existing : {
+				kind: "dwell",
+				pendingSince: null,
+				latched: null,
+				seenSince: null
+			};
+			memory.calls.set(invocation.path, call);
+			return evaluateDwell(invocation.args[0], invocation.args[1], invocation.args[2], call, env.nowMs, hooks);
+		}
+		case "latchedAt": {
+			const call = existing?.kind === "latchedAt" ? existing : {
+				kind: "latchedAt",
+				last: void 0,
+				at: null
+			};
+			memory.calls.set(invocation.path, call);
+			return evaluateLatchedAt(invocation.args[0], call, env.nowMs);
+		}
 	}
 }
 /**
@@ -15531,7 +15619,15 @@ var BUILTIN_RESULT_KINDS = Object.freeze({
 		kind: "fixed",
 		result: ["number", "null"]
 	},
-	count: NUMBER
+	count: NUMBER,
+	dwell: {
+		kind: "fixed",
+		result: ["boolean", "null"]
+	},
+	latchedAt: {
+		kind: "fixed",
+		result: ["number", "null"]
+	}
 });
 var KindInferenceError = class extends Error {};
 function kindOfValue(value) {
@@ -45183,9 +45279,6 @@ var NcSystemEventKindSchema = zod.z.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",
@@ -45232,13 +45325,14 @@ var NcSystemEventKindSchema = zod.z.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.
 *
@@ -46368,18 +46462,11 @@ var NcRuleSchema = NcRuleInputSchema.extend({
 	*/
 	disabledTargetIds: zod.z.array(zod.z.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 = zod.z.enum([
 	"device-state",
 	"streams",
 	"battery",
 	"consumables",
-	"tanks",
 	"detection-blind",
 	"nodes",
 	"addons",
@@ -60064,20 +60151,68 @@ var BatteryStatusSchema = zod.z.object({
 	*/
 	binary: zod.z.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
@@ -60161,6 +60296,7 @@ onStatusChanged: { data: zod.z.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"]
@@ -61226,6 +61362,106 @@ var ConsumablesStatusSchema = zod.z.object({
 	items: zod.z.array(ConsumableItemSchema),
 	lastChangedAt: zod.z.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",
@@ -61263,10 +61499,7 @@ reset: method(zod.z.object({
 	status: {
 		schema: ConsumablesStatusSchema,
 		kind: "push",
-		empty: {
-			items: [],
-			lastChangedAt: 0
-		},
+		empty: EMPTY_STATUS,
 		itemArray: {
 			path: "items",
 			keyField: "key",
@@ -61302,6 +61535,7 @@ reset: method(zod.z.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: {
@@ -62090,6 +62324,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 = zod.z.object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
 	lastPressedAt: zod.z.number().nullable(),
@@ -62156,7 +62420,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.
@@ -64862,6 +65127,38 @@ authKey: zod.z.string().optional() }), zod.z.object({
 		}), { 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
+	}]
+};
 /**
 * Hardware / firmware motion sensor cap — binary detected state plus
 * a timestamp of the last observation. Distinct from
@@ -65026,7 +65323,8 @@ onMotionChanged: { data: MotionOnMotionChangedDataSchema } },
 	history: { fields: { detected: {
 		kind: "boolean",
 		excludeDeviceTypes: [DeviceType.Camera]
-	} } }
+	} } },
+	customize: motionCustomize
 };
 /**
 * Motion-trigger toggle for accessory devices.
@@ -68115,6 +68413,125 @@ var ptzAutotrackCapability = {
 	*/
 	history: "none"
 };
+var RUNNING_POWER_START_DELAY_MS = 3e4;
+var RUNNING_POWER_STOP_DELAY_MS = 18e4;
+var RunningStateSourceSchema = zod.z.enum(["native", "assigned"]);
+var RunningStateStatusSchema = zod.z.object({
+	/** null = unknown — never coerced to false (D393). */
+	running: zod.z.boolean().nullable(),
+	/** Epoch ms the current boolean began; null while `running` is null. */
+	since: zod.z.number().nullable(),
+	source: RunningStateSourceSchema,
+	phase: zod.z.string().nullable(),
+	/** null until a reading has been published (D393). */
+	lastFetchedAt: zod.z.number().nullable()
+});
+var RunningFlipEventDataSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	since: zod.z.number().nullable(),
+	phase: zod.z.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
+};
 /**
 * reboot — device-scoped capability for "soft" device reboots (firmware
 * reboot via vendor protocol; cameras, NVRs, doorbells). Surfaces a
@@ -74167,11 +74584,12 @@ function expressionOutcome(source, read, now, stateful) {
 		return unavailable;
 	}
 	const deadlines = [];
+	const hooks = {
+		noteDeadline: (at) => deadlines.push(at),
+		convert: (value, from, to) => tryConvertUnit(value, normalizeUnit(from) ?? from, normalizeUnit(to) ?? to) ?? null
+	};
 	const result = evaluateExpressionSource(source.expr, values, now, {
-		hooks: {
-			noteDeadline: (at) => deadlines.push(at),
-			convert: (value, from, to) => tryConvertUnit(value, normalizeUnit(from) ?? from, normalizeUnit(to) ?? to) ?? null
-		},
+		hooks,
 		...stateful === void 0 ? {} : { invokeStateful: (invocation) => evaluateStatefulExpressionCall(stateful.callPathPrefix === void 0 ? invocation : {
 			...invocation,
 			path: `${stateful.callPathPrefix}@${invocation.path}`
@@ -74179,7 +74597,7 @@ function expressionOutcome(source, read, now, stateful) {
 			currentOutput: stateful.currentOutput,
 			startedAtMs: stateful.startedAtMs,
 			nowMs: now
-		}) }
+		}, hooks) }
 	});
 	if (!result.ok) return {
 		state: "unavailable",
@@ -74561,6 +74979,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	ptzAutotrack: ptzAutotrackCapability,
 	recordingOnboard: recordingOnboardCapability,
 	recordingSignal: recordingSignalCapability,
+	runningState: runningStateCapability,
 	sceneMonitor: sceneMonitorCapability,
 	scriptRunner: scriptRunnerCapability,
 	smoke: smokeCapability,
@@ -83081,6 +83500,13 @@ var METHOD_ACCESS_MAP = 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",
@@ -87795,6 +88221,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"),
@@ -89130,6 +89582,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"recording-archive",
 	"recording-onboard",
 	"recording-signal",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"smoke",
@@ -89292,6 +89745,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	recordingOnboardCapability,
 	recordingSignalCapability,
 	recordsCapability,
+	runningStateCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
@@ -91606,6 +92060,11 @@ Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"runningState.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"sceneMonitor.captureReference": [{
 		name: "deviceId",
 		form: "single",
@@ -92105,7 +92564,7 @@ Object.freeze({
 });
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 71 caps: 37 `restored`, 34 `session`.
+* `runtimeState`. 72 caps: 38 `restored`, 34 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -92323,6 +92782,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "session",
 		volatileFields: []
 	},
+	"running-state": {
+		durability: "restored",
+		volatileFields: ["lastFetchedAt"]
+	},
 	"scene-monitor": {
 		durability: "session",
 		volatileFields: []
@@ -92413,7 +92876,7 @@ var SESSION_ONLY_POLICY = {
 };
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 40 caps with series (73 series), 30 caps answered `'none'`.
+* 41 caps with series (74 series), 30 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -92690,6 +93153,7 @@ var HISTORY_CATALOG = {
 		unit: "hPa",
 		deadband: .1
 	} },
+	"running-state": { "running": { kind: "boolean" } },
 	"smoke": { "detected": { kind: "boolean" } },
 	"stream-params": {
 		"main.bitrate": {
@@ -92797,6 +93261,103 @@ var HISTORY_ITEM_CATALOG = { "consumables": {
 		}
 	}
 } };
+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 = zod.z.object({
+	addonId: zod.z.string().min(1),
+	stableId: zod.z.string().min(1),
+	cap: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1)
+});
+var IdentityTransformDraftSchema = zod.z.object({ kind: zod.z.literal("identity") });
+var InvertTransformDraftSchema = zod.z.object({ kind: zod.z.literal("invert") });
+var ThresholdTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("threshold"),
+	comparison: zod.z.enum(["gte", "lte"]),
+	threshold: zod.z.number(),
+	startDwellMs: zod.z.number().nonnegative(),
+	stopDwellMs: zod.z.number().nonnegative()
+});
+var LinearTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("linear"),
+	scale: zod.z.number(),
+	offset: zod.z.number(),
+	clampMin: zod.z.number().optional(),
+	clampMax: zod.z.number().optional()
+});
+var EnumMapTransformDraftSchema = zod.z.object({
+	kind: zod.z.literal("enum-map"),
+	mapping: zod.z.record(zod.z.string(), zod.z.string().nullable())
+});
+var NumberBridgeTransformDraftSchema = zod.z.object({ kind: zod.z.literal("number") });
+var CustomizeTransformDraftSchema = zod.z.discriminatedUnion("kind", [
+	IdentityTransformDraftSchema,
+	InvertTransformDraftSchema,
+	ThresholdTransformDraftSchema,
+	LinearTransformDraftSchema,
+	EnumMapTransformDraftSchema,
+	NumberBridgeTransformDraftSchema
+]);
+var ScalarOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("scalar"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var KeyedArrayOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("keyedArray"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	key: zod.z.string().min(1),
+	label: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1),
+	source: OverrideSourceSchema,
+	transform: CustomizeTransformDraftSchema
+});
+var PulseOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("pulse"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	enabled: zod.z.boolean(),
+	debounceMs: zod.z.number().nonnegative(),
+	sources: zod.z.array(OverrideSourceSchema).min(1)
+});
+var SpanSourceDraftSchema = OverrideSourceSchema.extend({ mode: zod.z.enum([
+	"in-addition",
+	"confirm",
+	"replace"
+]).optional() });
+var SpanOverrideDraftSchema = zod.z.object({
+	kind: zod.z.literal("span"),
+	cap: zod.z.string().min(1),
+	targetId: zod.z.string().min(1),
+	timeoutMs: zod.z.number().nonnegative(),
+	cooldownMs: zod.z.number().nonnegative().optional(),
+	sources: zod.z.array(SpanSourceDraftSchema)
+});
+zod.z.discriminatedUnion("kind", [
+	ScalarOverrideDraftSchema,
+	KeyedArrayOverrideDraftSchema,
+	PulseOverrideDraftSchema,
+	SpanOverrideDraftSchema
+]);
+zod.z.object({
+	targetId: zod.z.string().min(1),
+	configured: zod.z.boolean(),
+	source: zod.z.enum(["native", "assigned"]),
+	state: zod.z.enum([
+		"active",
+		"stale",
+		"released",
+		"unavailable"
+	]),
+	reason: zod.z.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)
@@ -92849,40 +93410,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).
 *
@@ -92908,9 +93436,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",
@@ -92987,16 +93512,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",
@@ -93196,11 +93711,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",
@@ -93232,7 +93742,6 @@ var DEVICE_EVENTS = [
 	"device-enabled",
 	...BATTERY,
 	...CONSUMABLE,
-	...TANK,
 	"stream-online",
 	"stream-offline",
 	"detection-blind",
@@ -93278,12 +93787,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",
@@ -93399,8 +93902,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]),
@@ -93504,15 +94006,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",