@camstack/types 1.2.432 → 1.2.434

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-5zRztaHa.js");
-const require_event_category = require("./event-category-BhzwWQCH.js");
+const require_sleep = require("./sleep-CO61AfwW.js");
+const require_event_category = require("./event-category-E17zaHjN.js");
 const require_composition = require("./composition-CpAc0YfQ.js");
 const require_node_color = require("./node-color.js");
 const require_err_msg = require("./err-msg-U7lLUMNz.js");
@@ -8074,10 +8074,10 @@ var ExpressionSourceSchema = zod.z.object({
 *
 * Three vocabularies, each salvaged rather than invented:
 *
-*  - **Triggers** — the only genuinely new surface. Six members, none of which
+*  - **Triggers** — the only genuinely new surface. Seven members, none of which
 *    touches notification delivery. The NC keeps its four *pipeline* triggers;
 *    these are device/time triggers and the two sets do not overlap.
-*  - **Conditions** — `ALL`/`ANY`/`NOT` over two leaf kinds, bounded. The
+*  - **Conditions** — `ALL`/`ANY`/`NOT` over three leaf kinds, bounded. The
 *    expression leaf is the bounded engine at `../expression/`, which is where
 *    arithmetic between two device fields lives and the only place it lives.
 *  - **Actions** — `NcRuleActionSchema`'s two steps, plus the `{kind:'code'}`
@@ -8124,6 +8124,14 @@ var AutomationConditionLeafSchema = zod.z.object({
 		zod.z.array(zod.z.union([zod.z.string(), zod.z.number()]))
 	])
 });
+var AutomationConditionStationaryPresentSchema = zod.z.object({
+	kind: zod.z.literal("stationary-present"),
+	deviceId: zod.z.number().int().nonnegative(),
+	/** Class names; a macro class matches every raw class that maps to it. */
+	classes: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+	/** The parked object must be in at least one of these zones. */
+	zones: zod.z.array(zod.z.string().min(1)).min(1).optional()
+});
 /**
 * The expression leaf, declared as a plain object rather than an intersection
 * with {@link ExpressionSourceSchema}: a discriminated union has to be able to
@@ -8157,7 +8165,8 @@ var AutomationConditionSchema = zod.z.lazy(() => zod.z.discriminatedUnion("kind"
 		child: AutomationConditionSchema
 	}),
 	AutomationConditionLeafSchema,
-	AutomationConditionExpressionSchema
+	AutomationConditionExpressionSchema,
+	AutomationConditionStationaryPresentSchema
 ]));
 /**
 * What starts a run.
@@ -8211,6 +8220,17 @@ var AutomationTriggerSchema = zod.z.discriminatedUnion("kind", [
 		/** Best-so-far confidence the track must reach. */
 		minScore: zod.z.number().min(0).max(1).optional()
 	}),
+	zod.z.object({
+		kind: zod.z.literal("stationary"),
+		deviceIds: zod.z.array(zod.z.number().int().nonnegative()).min(1),
+		/** Class names; a macro class matches like the detection trigger. */
+		classes: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+		/** The parked object must be in at least one of these zones. */
+		zones: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+		/** `appeared`: it became parked. `departed`: the registry retired it.
+		*  The vocabulary of `PipelineAnalyticsStationaryChanged`. */
+		phase: zod.z.enum(["appeared", "departed"])
+	}),
 	zod.z.object({
 		kind: zod.z.literal("interval"),
 		minutes: zod.z.number().int().min(1).max(1440)
@@ -8323,9 +8343,12 @@ var AutomationRecipeSchema = zod.z.object({
 	/** How many run traces the automation keeps (default {@link DEFAULT_TRACE_KEEP}). */
 	keepTraces: zod.z.number().int().min(1).max(100).optional()
 });
+function isLeaf(cond) {
+	return cond.kind === "condition" || cond.kind === "expression" || cond.kind === "stationary-present";
+}
 /** Depth of a tree, root container = 1. A bare leaf is depth 1. */
 function conditionDepth(cond) {
-	if (cond.kind === "condition" || cond.kind === "expression") return 1;
+	if (isLeaf(cond)) return 1;
 	if (cond.kind === "not") return 1 + conditionDepth(cond.child);
 	const children = cond.children;
 	if (children.length === 0) return 1;
@@ -8338,14 +8361,14 @@ function conditionDepth(cond) {
 }
 /** Leaves only — containers do not count toward the leaf budget. */
 function countConditionLeaves(cond) {
-	if (cond.kind === "condition" || cond.kind === "expression") return 1;
+	if (isLeaf(cond)) return 1;
 	if (cond.kind === "not") return countConditionLeaves(cond.child);
 	let total = 0;
 	for (const child of cond.children) total += countConditionLeaves(child);
 	return total;
 }
 function findEmptyContainer(cond) {
-	if (cond.kind === "condition" || cond.kind === "expression") return false;
+	if (isLeaf(cond)) return false;
 	if (cond.kind === "not") return findEmptyContainer(cond.child);
 	if (cond.children.length === 0) return true;
 	return cond.children.some(findEmptyContainer);
@@ -8504,6 +8527,32 @@ function emitTrigger(trigger, index) {
         },
       ),
     )
+  }`;
+		case "stationary": return `  // trigger ${index}: stationary — a parked object appeared / departed. Stateless:
+  // the registry emits one event per transition. A dropped event only misses a fire;
+  // the stationary-present CONDITION reads the registry, not this event.
+  {
+    const trigger = ${j(trigger)} as const
+    disposers.push(
+      ctx.eventBus.subscribe(
+        { category: EventCategory.PipelineAnalyticsStationaryChanged },
+        (event) => {
+          const decision = evaluateStationaryTrigger(trigger, event.data)
+          if (decision.kind === 'ignore') return
+          if (decision.kind === 'reject') {
+            ctx.logger.debug('stationary trigger rejected an event', {
+              tags: { deviceId: decision.vars.deviceId },
+              reason: decision.reason,
+            })
+          }
+          void run(
+            { kind: 'stationary', at: Date.now(), ...decision.vars },
+            decision.reason,
+            decision.kind === 'fire',
+          )
+        },
+      ),
+    )
   }`;
 	}
 }
@@ -8570,6 +8619,7 @@ import {
   collectMirrorSources,
   coreBlockIdFromAddonId,
   evaluateConditionTree,
+  evaluateStationaryTrigger,
   isSkippedTrace,
   mergeSkipTraces,
   resolveDeviceTarget,
@@ -9064,310 +9114,6 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
 `;
 }
 //#endregion
-//#region src/automation/condition-eval.ts
-/**
-* Evaluating an automation's condition tree against the ConditionMirror.
-*
-* D49: a trigger is a one-shot event, so its gate must never hang on a read
-* that can fail. Every field a condition leaf names is therefore kept in
-* memory — filled at start, updated off device state-changed events, reconciled
-* on a timer — and evaluation reads that memory ONLY. A value the mirror does
-* not hold is UNKNOWN, which is `fail` with a reason, never a throw and never a
-* `pass`. A failed refresh changes nothing: the previous value stays.
-*
-* The evaluator returns a node per tree position (containers, leaves, and the
-* ones a short-circuit never reached) with a stable path and a human reason, so
-* the editor can paint each block.
-*/
-function collectInto(cond, out) {
-	switch (cond.kind) {
-		case "all":
-		case "any":
-			for (const child of cond.children) collectInto(child, out);
-			return;
-		case "not":
-			collectInto(cond.child, out);
-			return;
-		case "condition":
-			out.push({
-				kind: "device",
-				deviceId: cond.deviceId,
-				cap: cond.cap
-			});
-			return;
-		case "expression":
-			for (const binding of Object.values(cond.bindings)) if (binding.kind === "global") out.push({
-				kind: "stable",
-				stableId: binding.sourceStableId,
-				cap: binding.cap
-			});
-			return;
-	}
-}
-/** Every (device, cap) a tree reads, deduplicated. */
-function collectMirrorSources(cond) {
-	if (cond === void 0) return [];
-	const all = [];
-	collectInto(cond, all);
-	const seen = /* @__PURE__ */ new Set();
-	return all.filter((s) => {
-		const key = s.kind === "device" ? `d|${s.deviceId}|${s.cap}` : `s|${s.stableId}|${s.cap}`;
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-function sliceKey(deviceId, cap) {
-	return `${deviceId}|${cap}`;
-}
-function pick$1(slice, fieldPath) {
-	let cursor = slice;
-	for (const part of fieldPath.split(".")) {
-		if (cursor === null || typeof cursor !== "object") return void 0;
-		cursor = Reflect.get(cursor, part);
-	}
-	return cursor;
-}
-function isSliceObject(value) {
-	return typeof value === "object" && value !== null;
-}
-var ConditionMirror = class {
-	sources;
-	slices = /* @__PURE__ */ new Map();
-	stableIds = /* @__PURE__ */ new Map();
-	watched;
-	constructor(sources) {
-		this.sources = sources;
-		this.watched = new Set(sources.filter((s) => s.kind === "device").map((s) => sliceKey(s.deviceId, s.cap)));
-	}
-	/** A `device.state-changed` event. Slices nobody reads are ignored. */
-	apply(deviceId, cap, slice) {
-		const key = sliceKey(deviceId, cap);
-		if (!isSliceObject(slice)) return;
-		if (!this.watched.has(key) && !this.isStableTarget(deviceId, cap)) return;
-		this.slices.set(key, slice);
-	}
-	isStableTarget(deviceId, cap) {
-		for (const s of this.sources) if (s.kind === "stable" && s.cap === cap && this.stableIds.get(s.stableId) === deviceId) return true;
-		return false;
-	}
-	read(deviceId, cap, fieldPath) {
-		const slice = this.slices.get(sliceKey(deviceId, cap));
-		return slice === void 0 ? void 0 : pick$1(slice, fieldPath);
-	}
-	readStable(stableId, cap, fieldPath) {
-		const deviceId = this.stableIds.get(stableId);
-		return deviceId === void 0 ? void 0 : this.read(deviceId, cap, fieldPath);
-	}
-	/** Fill / reconcile. A read that fails or answers nothing keeps the old value. */
-	async refresh(fetchers) {
-		let updated = 0;
-		let kept = 0;
-		if (this.sources.some((s) => s.kind === "stable")) try {
-			this.stableIds = await fetchers.fetchStableIds();
-		} catch {}
-		const targets = /* @__PURE__ */ new Map();
-		for (const s of this.sources) {
-			const deviceId = s.kind === "device" ? s.deviceId : this.stableIds.get(s.stableId);
-			if (deviceId === void 0) {
-				kept += 1;
-				continue;
-			}
-			targets.set(sliceKey(deviceId, s.cap), {
-				deviceId,
-				cap: s.cap
-			});
-		}
-		for (const [key, target] of targets) try {
-			const slice = await fetchers.fetchSlice(target.deviceId, target.cap);
-			if (isSliceObject(slice)) {
-				this.slices.set(key, slice);
-				updated += 1;
-			} else kept += 1;
-		} catch {
-			kept += 1;
-		}
-		return {
-			updated,
-			kept
-		};
-	}
-};
-var OPERATOR_SYMBOL = {
-	eq: "=",
-	ne: "≠",
-	gt: ">",
-	gte: "≥",
-	lt: "<",
-	lte: "≤",
-	contains: "contains",
-	in: "in"
-};
-function compare(actual, operator, expected) {
-	switch (operator) {
-		case "eq": return actual === expected;
-		case "ne": return actual !== expected;
-		case "gt": return typeof actual === "number" && typeof expected === "number" && actual > expected;
-		case "gte": return typeof actual === "number" && typeof expected === "number" && actual >= expected;
-		case "lt": return typeof actual === "number" && typeof expected === "number" && actual < expected;
-		case "lte": return typeof actual === "number" && typeof expected === "number" && actual <= expected;
-		case "contains": return typeof actual === "string" && typeof expected === "string" && actual.includes(expected);
-		case "in": return Array.isArray(expected) && expected.some((v) => v === actual);
-	}
-}
-function toTraceValue(value) {
-	if (value === void 0 || value === null) return null;
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-	if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) return value;
-	return JSON.stringify(value);
-}
-function show(value) {
-	return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
-}
-function markSkipped(cond, path, why, out) {
-	out.push({
-		path,
-		kind: cond.kind,
-		outcome: "not-evaluated",
-		reason: why
-	});
-	if (cond.kind === "all" || cond.kind === "any") cond.children.forEach((c, i) => {
-		markSkipped(c, `${path}.${i}`, why, out);
-	});
-	else if (cond.kind === "not") markSkipped(cond.child, `${path}.0`, why, out);
-}
-function evalNode(cond, path, reader, now, out) {
-	switch (cond.kind) {
-		case "condition": {
-			const observed = reader.read(cond.deviceId, cond.cap, cond.fieldPath);
-			const base = {
-				path,
-				kind: cond.kind,
-				deviceId: cond.deviceId,
-				cap: cond.cap,
-				fieldPath: cond.fieldPath,
-				operator: cond.operator,
-				expected: toTraceValue(cond.value),
-				observed: toTraceValue(observed)
-			};
-			if (observed === void 0) {
-				out.push({
-					...base,
-					outcome: "fail",
-					reason: `${cond.fieldPath} value unknown → fail`
-				});
-				return false;
-			}
-			const ok = compare(observed, cond.operator, cond.value);
-			out.push({
-				...base,
-				outcome: ok ? "pass" : "fail",
-				reason: `${cond.fieldPath} ${show(observed)}, expected ${OPERATOR_SYMBOL[cond.operator]} ${show(cond.value)} → ${ok ? "pass" : "fail"}`
-			});
-			return ok;
-		}
-		case "expression": {
-			const values = {};
-			for (const [alias, binding] of Object.entries(cond.bindings)) {
-				if (binding.kind === "literal") {
-					values[alias] = require_composition.toExpressionValue(binding.value) ?? null;
-					continue;
-				}
-				const raw = binding.kind === "global" ? reader.readStable(binding.sourceStableId, binding.cap, binding.fieldPath) : void 0;
-				if (raw === void 0) {
-					out.push({
-						path,
-						kind: cond.kind,
-						outcome: "fail",
-						reason: `${alias} value unknown → fail`
-					});
-					return false;
-				}
-				values[alias] = require_composition.toExpressionValue(raw) ?? null;
-			}
-			const result = require_composition.evaluateExpressionSource(cond.expr, values, now);
-			if (!result.ok) {
-				out.push({
-					path,
-					kind: cond.kind,
-					outcome: "fail",
-					reason: `${cond.expr}: ${result.error} → fail`
-				});
-				return false;
-			}
-			const ok = result.value === true;
-			out.push({
-				path,
-				kind: cond.kind,
-				outcome: ok ? "pass" : "fail",
-				reason: `${cond.expr} with ${JSON.stringify(values)} → ${ok ? "pass" : "fail"}`
-			});
-			return ok;
-		}
-		case "not": {
-			const at = out.length;
-			out.push({
-				path,
-				kind: "not",
-				outcome: "not-evaluated",
-				reason: ""
-			});
-			const inner = evalNode(cond.child, `${path}.0`, reader, now, out);
-			const ok = !inner;
-			out.splice(at, 1, {
-				path,
-				kind: "not",
-				outcome: ok ? "pass" : "fail",
-				reason: `not (${inner ? "pass" : "fail"}) → ${ok ? "pass" : "fail"}`
-			});
-			return ok;
-		}
-		case "all":
-		case "any": {
-			const isAll = cond.kind === "all";
-			const at = out.length;
-			out.push({
-				path,
-				kind: cond.kind,
-				outcome: "not-evaluated",
-				reason: ""
-			});
-			let decided = null;
-			for (let i = 0; i < cond.children.length; i += 1) {
-				const child = cond.children[i];
-				if (child === void 0) continue;
-				if (decided !== null) {
-					markSkipped(child, `${path}.${i}`, `short-circuited by ${path}.${decided}`, out);
-					continue;
-				}
-				const ok = evalNode(child, `${path}.${i}`, reader, now, out);
-				if (isAll ? !ok : ok) decided = i;
-			}
-			const ok = isAll ? decided === null : decided !== null;
-			const reason = isAll ? ok ? `all ${cond.children.length} passed → pass` : `${path}.${decided} failed → fail` : ok ? `${path}.${decided} passed → pass` : `none of ${cond.children.length} passed → fail`;
-			out.splice(at, 1, {
-				path,
-				kind: cond.kind,
-				outcome: ok ? "pass" : "fail",
-				reason
-			});
-			return ok;
-		}
-	}
-}
-/** No condition tree is a pass with no nodes. */
-function evaluateConditionTree(cond, reader, now) {
-	if (cond === void 0) return {
-		pass: true,
-		nodes: []
-	};
-	const nodes = [];
-	return {
-		pass: evalNode(cond, "conditions", reader, now, nodes),
-		nodes
-	};
-}
-//#endregion
 //#region src/catalogs/coco-classmap.ts
 var COCO_80_LABELS = [
 	{
@@ -9770,7 +9516,7 @@ function detectionClassMatches(wanted, actual) {
 	if (w === a) return true;
 	return MACRO_NAMES.has(w) && macroOf(a) === w;
 }
-function isPhase(value) {
+function isPhase$1(value) {
 	return value === "start" || value === "update" || value === "end";
 }
 var DetectionTriggerFilter = class {
@@ -9785,7 +9531,7 @@ var DetectionTriggerFilter = class {
 	}
 	evaluate(event, now) {
 		const { deviceId, trackId, phase } = event;
-		if (typeof deviceId !== "number" || typeof trackId !== "string" || !isPhase(phase)) return {
+		if (typeof deviceId !== "number" || typeof trackId !== "string" || !isPhase$1(phase)) return {
 			kind: "ignore",
 			why: "malformed track-lifecycle event"
 		};
@@ -9856,6 +9602,433 @@ var DetectionTriggerFilter = class {
 	}
 };
 //#endregion
+//#region src/automation/condition-eval.ts
+/**
+* Evaluating an automation's condition tree against the ConditionMirror.
+*
+* D49: a trigger is a one-shot event, so its gate must never hang on a read
+* that can fail. Every field a condition leaf names is therefore kept in
+* memory — filled at start, updated off device state-changed events, reconciled
+* on a timer — and evaluation reads that memory ONLY. A value the mirror does
+* not hold is UNKNOWN, which is `fail` with a reason, never a throw and never a
+* `pass`. A failed refresh changes nothing: the previous value stays.
+*
+* The evaluator returns a node per tree position (containers, leaves, and the
+* ones a short-circuit never reached) with a stable path and a human reason, so
+* the editor can paint each block.
+*/
+/** The cap whose runtime-state slice IS the occupancy snapshot, parked objects included. */
+var ZONE_ANALYTICS_CAP = "zone-analytics";
+function collectInto(cond, out) {
+	switch (cond.kind) {
+		case "all":
+		case "any":
+			for (const child of cond.children) collectInto(child, out);
+			return;
+		case "not":
+			collectInto(cond.child, out);
+			return;
+		case "condition":
+			out.push({
+				kind: "device",
+				deviceId: cond.deviceId,
+				cap: cond.cap
+			});
+			return;
+		case "stationary-present":
+			out.push({
+				kind: "device",
+				deviceId: cond.deviceId,
+				cap: ZONE_ANALYTICS_CAP
+			});
+			return;
+		case "expression":
+			for (const binding of Object.values(cond.bindings)) if (binding.kind === "global") out.push({
+				kind: "stable",
+				stableId: binding.sourceStableId,
+				cap: binding.cap
+			});
+			return;
+	}
+}
+/** Every (device, cap) a tree reads, deduplicated. */
+function collectMirrorSources(cond) {
+	if (cond === void 0) return [];
+	const all = [];
+	collectInto(cond, all);
+	const seen = /* @__PURE__ */ new Set();
+	return all.filter((s) => {
+		const key = s.kind === "device" ? `d|${s.deviceId}|${s.cap}` : `s|${s.stableId}|${s.cap}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function sliceKey(deviceId, cap) {
+	return `${deviceId}|${cap}`;
+}
+function pick$1(slice, fieldPath) {
+	let cursor = slice;
+	for (const part of fieldPath.split(".")) {
+		if (cursor === null || typeof cursor !== "object") return void 0;
+		cursor = Reflect.get(cursor, part);
+	}
+	return cursor;
+}
+function isSliceObject(value) {
+	return typeof value === "object" && value !== null;
+}
+var ConditionMirror = class {
+	sources;
+	slices = /* @__PURE__ */ new Map();
+	stableIds = /* @__PURE__ */ new Map();
+	watched;
+	constructor(sources) {
+		this.sources = sources;
+		this.watched = new Set(sources.filter((s) => s.kind === "device").map((s) => sliceKey(s.deviceId, s.cap)));
+	}
+	/** A `device.state-changed` event. Slices nobody reads are ignored. */
+	apply(deviceId, cap, slice) {
+		const key = sliceKey(deviceId, cap);
+		if (!isSliceObject(slice)) return;
+		if (!this.watched.has(key) && !this.isStableTarget(deviceId, cap)) return;
+		this.slices.set(key, slice);
+	}
+	isStableTarget(deviceId, cap) {
+		for (const s of this.sources) if (s.kind === "stable" && s.cap === cap && this.stableIds.get(s.stableId) === deviceId) return true;
+		return false;
+	}
+	read(deviceId, cap, fieldPath) {
+		const slice = this.slices.get(sliceKey(deviceId, cap));
+		return slice === void 0 ? void 0 : pick$1(slice, fieldPath);
+	}
+	readStable(stableId, cap, fieldPath) {
+		const deviceId = this.stableIds.get(stableId);
+		return deviceId === void 0 ? void 0 : this.read(deviceId, cap, fieldPath);
+	}
+	/** Fill / reconcile. A read that fails or answers nothing keeps the old value. */
+	async refresh(fetchers) {
+		let updated = 0;
+		let kept = 0;
+		if (this.sources.some((s) => s.kind === "stable")) try {
+			this.stableIds = await fetchers.fetchStableIds();
+		} catch {}
+		const targets = /* @__PURE__ */ new Map();
+		for (const s of this.sources) {
+			const deviceId = s.kind === "device" ? s.deviceId : this.stableIds.get(s.stableId);
+			if (deviceId === void 0) {
+				kept += 1;
+				continue;
+			}
+			targets.set(sliceKey(deviceId, s.cap), {
+				deviceId,
+				cap: s.cap
+			});
+		}
+		for (const [key, target] of targets) try {
+			const slice = await fetchers.fetchSlice(target.deviceId, target.cap);
+			if (isSliceObject(slice)) {
+				this.slices.set(key, slice);
+				updated += 1;
+			} else kept += 1;
+		} catch {
+			kept += 1;
+		}
+		return {
+			updated,
+			kept
+		};
+	}
+};
+var OPERATOR_SYMBOL = {
+	eq: "=",
+	ne: "≠",
+	gt: ">",
+	gte: "≥",
+	lt: "<",
+	lte: "≤",
+	contains: "contains",
+	in: "in"
+};
+function compare(actual, operator, expected) {
+	switch (operator) {
+		case "eq": return actual === expected;
+		case "ne": return actual !== expected;
+		case "gt": return typeof actual === "number" && typeof expected === "number" && actual > expected;
+		case "gte": return typeof actual === "number" && typeof expected === "number" && actual >= expected;
+		case "lt": return typeof actual === "number" && typeof expected === "number" && actual < expected;
+		case "lte": return typeof actual === "number" && typeof expected === "number" && actual <= expected;
+		case "contains": return typeof actual === "string" && typeof expected === "string" && actual.includes(expected);
+		case "in": return Array.isArray(expected) && expected.some((v) => v === actual);
+	}
+}
+function toTraceValue(value) {
+	if (value === void 0 || value === null) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) return value;
+	return JSON.stringify(value);
+}
+function show(value) {
+	return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
+}
+function markSkipped(cond, path, why, out) {
+	out.push({
+		path,
+		kind: cond.kind,
+		outcome: "not-evaluated",
+		reason: why
+	});
+	if (cond.kind === "all" || cond.kind === "any") cond.children.forEach((c, i) => {
+		markSkipped(c, `${path}.${i}`, why, out);
+	});
+	else if (cond.kind === "not") markSkipped(cond.child, `${path}.0`, why, out);
+}
+function parkedObjectsOf(value) {
+	if (!Array.isArray(value)) return [];
+	const rows = [];
+	for (const item of value) {
+		const id = Reflect.get(Object(item), "id");
+		const className = Reflect.get(Object(item), "className");
+		if (typeof id === "string" && typeof className === "string") rows.push({
+			id,
+			className
+		});
+	}
+	return rows;
+}
+/** `zoneId`s whose `trackIds` list the parked object (`stationary:<id>`, as the snapshot builds it). */
+function zonesOfParked(zones, parkedId) {
+	if (!Array.isArray(zones)) return [];
+	const out = [];
+	for (const zone of zones) {
+		const zoneId = Reflect.get(Object(zone), "zoneId");
+		const trackIds = Reflect.get(Object(zone), "trackIds");
+		if (typeof zoneId === "string" && Array.isArray(trackIds) && trackIds.includes(`stationary:${parkedId}`)) out.push(zoneId);
+	}
+	return out;
+}
+/**
+* Is a matching parked object there NOW? Read off the mirrored zone-analytics
+* snapshot: `frame` is always present in a snapshot, so its absence means the
+* slice was never read (UNKNOWN, a fail that says so), while a snapshot without
+* `stationaryObjects` is a definite "nothing parked" (the provider omits an
+* empty list).
+*/
+function judgeStationaryPresent(cond, reader) {
+	if (reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "frame") === void 0) return {
+		pass: false,
+		why: `device ${cond.deviceId} occupancy snapshot unknown`
+	};
+	const parked = parkedObjectsOf(reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "stationaryObjects"));
+	if (parked.length === 0) return {
+		pass: false,
+		why: `no parked objects on device ${cond.deviceId}`
+	};
+	const zones = reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "zones");
+	for (const obj of parked) {
+		if (cond.classes !== void 0 && !cond.classes.some((c) => detectionClassMatches(c, obj.className))) continue;
+		if (cond.zones !== void 0) {
+			const inZones = zonesOfParked(zones, obj.id);
+			if (!cond.zones.some((z) => inZones.includes(z))) continue;
+		}
+		return {
+			pass: true,
+			why: `parked ${obj.className} (${obj.id}) on device ${cond.deviceId}`
+		};
+	}
+	return {
+		pass: false,
+		why: `${parked.length} parked on device ${cond.deviceId}, none matching the class/zone filter`
+	};
+}
+function evalNode(cond, path, reader, now, out) {
+	switch (cond.kind) {
+		case "condition": {
+			const observed = reader.read(cond.deviceId, cond.cap, cond.fieldPath);
+			const base = {
+				path,
+				kind: cond.kind,
+				deviceId: cond.deviceId,
+				cap: cond.cap,
+				fieldPath: cond.fieldPath,
+				operator: cond.operator,
+				expected: toTraceValue(cond.value),
+				observed: toTraceValue(observed)
+			};
+			if (observed === void 0) {
+				out.push({
+					...base,
+					outcome: "fail",
+					reason: `${cond.fieldPath} value unknown → fail`
+				});
+				return false;
+			}
+			const ok = compare(observed, cond.operator, cond.value);
+			out.push({
+				...base,
+				outcome: ok ? "pass" : "fail",
+				reason: `${cond.fieldPath} ${show(observed)}, expected ${OPERATOR_SYMBOL[cond.operator]} ${show(cond.value)} → ${ok ? "pass" : "fail"}`
+			});
+			return ok;
+		}
+		case "stationary-present": {
+			const verdict = judgeStationaryPresent(cond, reader);
+			out.push({
+				path,
+				kind: cond.kind,
+				outcome: verdict.pass ? "pass" : "fail",
+				reason: `${verdict.why} → ${verdict.pass ? "pass" : "fail"}`,
+				deviceId: cond.deviceId,
+				cap: ZONE_ANALYTICS_CAP
+			});
+			return verdict.pass;
+		}
+		case "expression": {
+			const values = {};
+			for (const [alias, binding] of Object.entries(cond.bindings)) {
+				if (binding.kind === "literal") {
+					values[alias] = require_composition.toExpressionValue(binding.value) ?? null;
+					continue;
+				}
+				const raw = binding.kind === "global" ? reader.readStable(binding.sourceStableId, binding.cap, binding.fieldPath) : void 0;
+				if (raw === void 0) {
+					out.push({
+						path,
+						kind: cond.kind,
+						outcome: "fail",
+						reason: `${alias} value unknown → fail`
+					});
+					return false;
+				}
+				values[alias] = require_composition.toExpressionValue(raw) ?? null;
+			}
+			const result = require_composition.evaluateExpressionSource(cond.expr, values, now);
+			if (!result.ok) {
+				out.push({
+					path,
+					kind: cond.kind,
+					outcome: "fail",
+					reason: `${cond.expr}: ${result.error} → fail`
+				});
+				return false;
+			}
+			const ok = result.value === true;
+			out.push({
+				path,
+				kind: cond.kind,
+				outcome: ok ? "pass" : "fail",
+				reason: `${cond.expr} with ${JSON.stringify(values)} → ${ok ? "pass" : "fail"}`
+			});
+			return ok;
+		}
+		case "not": {
+			const at = out.length;
+			out.push({
+				path,
+				kind: "not",
+				outcome: "not-evaluated",
+				reason: ""
+			});
+			const inner = evalNode(cond.child, `${path}.0`, reader, now, out);
+			const ok = !inner;
+			out.splice(at, 1, {
+				path,
+				kind: "not",
+				outcome: ok ? "pass" : "fail",
+				reason: `not (${inner ? "pass" : "fail"}) → ${ok ? "pass" : "fail"}`
+			});
+			return ok;
+		}
+		case "all":
+		case "any": {
+			const isAll = cond.kind === "all";
+			const at = out.length;
+			out.push({
+				path,
+				kind: cond.kind,
+				outcome: "not-evaluated",
+				reason: ""
+			});
+			let decided = null;
+			for (let i = 0; i < cond.children.length; i += 1) {
+				const child = cond.children[i];
+				if (child === void 0) continue;
+				if (decided !== null) {
+					markSkipped(child, `${path}.${i}`, `short-circuited by ${path}.${decided}`, out);
+					continue;
+				}
+				const ok = evalNode(child, `${path}.${i}`, reader, now, out);
+				if (isAll ? !ok : ok) decided = i;
+			}
+			const ok = isAll ? decided === null : decided !== null;
+			const reason = isAll ? ok ? `all ${cond.children.length} passed → pass` : `${path}.${decided} failed → fail` : ok ? `${path}.${decided} passed → pass` : `none of ${cond.children.length} passed → fail`;
+			out.splice(at, 1, {
+				path,
+				kind: cond.kind,
+				outcome: ok ? "pass" : "fail",
+				reason
+			});
+			return ok;
+		}
+	}
+}
+/** No condition tree is a pass with no nodes. */
+function evaluateConditionTree(cond, reader, now) {
+	if (cond === void 0) return {
+		pass: true,
+		nodes: []
+	};
+	const nodes = [];
+	return {
+		pass: evalNode(cond, "conditions", reader, now, nodes),
+		nodes
+	};
+}
+//#endregion
+//#region src/automation/stationary-trigger.ts
+function isPhase(value) {
+	return value === "appeared" || value === "departed";
+}
+function evaluateStationaryTrigger(trigger, event) {
+	const { deviceId, entryId, phase } = event;
+	if (typeof deviceId !== "number" || typeof entryId !== "string" || !isPhase(phase)) return {
+		kind: "ignore",
+		why: "malformed stationary-changed event"
+	};
+	if (!trigger.deviceIds.includes(deviceId)) return {
+		kind: "ignore",
+		why: `device ${deviceId} is not one of the trigger's devices`
+	};
+	if (phase !== trigger.phase) return {
+		kind: "ignore",
+		why: `phase ${phase}, the trigger wants ${trigger.phase}`
+	};
+	const className = typeof event.className === "string" ? event.className : "";
+	const zones = Array.isArray(event.zones) ? event.zones.filter((z) => typeof z === "string") : [];
+	const vars = {
+		deviceId,
+		className,
+		zones,
+		phase,
+		entryId
+	};
+	if (trigger.classes !== void 0 && !trigger.classes.some((c) => detectionClassMatches(c, className))) return {
+		kind: "reject",
+		reason: `class ${className || "unknown"} not in [${trigger.classes.join(", ")}]`,
+		vars
+	};
+	if (trigger.zones !== void 0 && !trigger.zones.some((z) => zones.includes(z))) return {
+		kind: "reject",
+		reason: `zone mismatch: in [${zones.join(", ")}], wanted [${trigger.zones.join(", ")}]`,
+		vars
+	};
+	return {
+		kind: "fire",
+		reason: `${className} ${phase} on device ${deviceId}`,
+		vars
+	};
+}
+//#endregion
 //#region src/automation/run-gate.ts
 var MINUTE_MS$1 = 6e4;
 function minutes(ms) {
@@ -10032,7 +10205,8 @@ var AutomationConditionTraceNodeSchema = zod.z.object({
 		"any",
 		"not",
 		"condition",
-		"expression"
+		"expression",
+		"stationary-present"
 	]),
 	outcome: TraceNodeOutcomeSchema,
 	reason: zod.z.string(),
@@ -10159,7 +10333,7 @@ function appendTrace(ring, trace, keep) {
 }
 /**
 * The trigger stage of a trace from the bag a trigger handed to `run()`:
-* primitives only (a device-state `to` that is an object is left out), minus the
+* primitives and short lists of them (a device-state `to` that is an object is left out), minus the
 * bookkeeping keys `kind` and `at`.
 */
 function buildTriggerTrace(trigger, outcome, reason) {
@@ -10167,6 +10341,7 @@ function buildTriggerTrace(trigger, outcome, reason) {
 	for (const [key, value] of Object.entries(trigger)) {
 		if (key === "kind" || key === "at") continue;
 		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) vars[key] = value;
+		else if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) vars[key] = value;
 	}
 	return {
 		kind: typeof trigger["kind"] === "string" ? trigger["kind"] : "unknown",
@@ -113507,7 +113682,41 @@ function packagePickerItems(packages) {
 	return [...pinned, ...addons];
 }
 //#endregion
+//#region src/i18n/humanize-id.ts
+/**
+* Make a raw wire id readable when no dictionary knows it: `delivery_truck`
+* becomes "Delivery truck", `open-door` becomes "Open door". It invents no
+* translation — the words stay the id's own, only separators and the first
+* letter change. An empty id stays empty.
+*/
+function humanizeId(id) {
+	const spaced = id.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+//#endregion
 //#region src/i18n/state-labels.ts
+/**
+* ONE dictionary of human labels for the state words the rule editors show
+* (R7, D690).
+*
+* A device-state gate offers the words the engine compares against —
+* `armed_away`, `not_home`, `unlocking` — and both rule editors printed them
+* verbatim. The words are the WIRE vocabulary and must stay what they are (a
+* rule stores them); what the operator reads is a label, and two editors that
+* each translate on their own are two editors that disagree. Both the admin UI
+* and the viewer resolve through {@link stateLabel}.
+*
+* Keys are the raw values themselves, flat: the vocabularies are disjoint where
+* they differ and agree where they overlap (`open` is the same word on a cover
+* and on a contact). An OPEN vocabulary (a presence zone the operator named,
+* a cover state a new integration invents) falls back to the raw word — never
+* an exception, never an empty chip.
+*
+* Covered, and held to their sources by the spec: the alarm panel's states,
+* the cover's, the lock's, the boolean readers' words
+* (`DEVICE_STATE_READERS`), presence's canonical `home`/`not_home`, and the
+* scene gate's verdicts and read modes.
+*/
 /** Every key the dictionary answers for, in a stable order. */
 var STATE_LABEL_KEYS = [
 	"disarmed",
@@ -113668,11 +113877,23 @@ function isStateLabelKey(key) {
 * dictionary does not know it. Never throws.
 */
 function stateLabel(key, locale) {
-	return isStateLabelKey(key) ? STATE_LABELS[key][locale] : key;
+	return isStateLabelKey(key) ? STATE_LABELS[key][locale] : humanizeId(key);
 }
 //#endregion
 //#region src/i18n/event-kind-labels.ts
 /**
+* ONE dictionary of human labels for event kinds (detection macros/subs,
+* sensors, audio macros, …) — the same vocabulary the viewer filters and the
+* notification centre speak (R7).
+*
+* Wire ids stay raw (`cat`, `animal`, `audio-dog`). What a human reads is a
+* label, and a surface that translates on its own is a surface that disagrees
+* with the next one. Admin UI, viewer and NC resolve through {@link eventKindLabel}.
+*
+* Keys match {@link EVENT_TAXONOMY}. An OPEN kind (a custom model class) falls
+* back to the raw word — never an exception, never an empty chip.
+*/
+/**
 * Every kind the dictionary answers for. Order is stable; the set is held to
 * {@link EVENT_TAXONOMY} by the spec.
 */
@@ -114042,7 +114263,7 @@ function isEventKindLabelKey(key) {
 */
 function eventKindLabel(kind, locale) {
 	const key = kind.trim().toLowerCase();
-	return isEventKindLabelKey(key) ? EVENT_KIND_LABELS[key][locale] : kind;
+	return isEventKindLabelKey(key) ? EVENT_KIND_LABELS[key][locale] : humanizeId(kind);
 }
 //#endregion
 //#region src/i18n/translation.ts
@@ -121775,6 +121996,7 @@ exports.evaluateRose = require_composition.evaluateRose;
 exports.evaluateSensorEdge = require_composition.evaluateSensorEdge;
 exports.evaluateSensorLevelEdge = require_composition.evaluateSensorLevelEdge;
 exports.evaluateStatefulExpressionCall = require_composition.evaluateStatefulExpressionCall;
+exports.evaluateStationaryTrigger = evaluateStationaryTrigger;
 exports.evaluateStatistic = require_composition.evaluateStatistic;
 exports.evaluateZoneRules = evaluateZoneRules;
 exports.event = require_sleep.event;