@camstack/types 1.2.451 → 1.2.452

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BSPhInRm.js");
+const require_sleep = require("./sleep-CewR0zRz.js");
 const require_event_category = require("./event-category-E17zaHjN.js");
 const require_composition = require("./composition-tP-vAKqU.js");
 const require_node_color = require("./node-color.js");
@@ -8845,47 +8845,664 @@ function paramMetaOf(field) {
 	return metaOf(field) ?? metaOf(unwrapSchema(field));
 }
 //#endregion
-//#region src/automation/recipe.ts
+//#region src/catalogs/coco-classmap.ts
+var COCO_80_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "bicycle",
+		name: "Bicycle"
+	},
+	{
+		id: "car",
+		name: "Car"
+	},
+	{
+		id: "motorcycle",
+		name: "Motorcycle"
+	},
+	{
+		id: "airplane",
+		name: "Airplane"
+	},
+	{
+		id: "bus",
+		name: "Bus"
+	},
+	{
+		id: "train",
+		name: "Train"
+	},
+	{
+		id: "truck",
+		name: "Truck"
+	},
+	{
+		id: "boat",
+		name: "Boat"
+	},
+	{
+		id: "traffic light",
+		name: "Traffic Light"
+	},
+	{
+		id: "fire hydrant",
+		name: "Fire Hydrant"
+	},
+	{
+		id: "stop sign",
+		name: "Stop Sign"
+	},
+	{
+		id: "parking meter",
+		name: "Parking Meter"
+	},
+	{
+		id: "bench",
+		name: "Bench"
+	},
+	{
+		id: "bird",
+		name: "Bird"
+	},
+	{
+		id: "cat",
+		name: "Cat"
+	},
+	{
+		id: "dog",
+		name: "Dog"
+	},
+	{
+		id: "horse",
+		name: "Horse"
+	},
+	{
+		id: "sheep",
+		name: "Sheep"
+	},
+	{
+		id: "cow",
+		name: "Cow"
+	},
+	{
+		id: "elephant",
+		name: "Elephant"
+	},
+	{
+		id: "bear",
+		name: "Bear"
+	},
+	{
+		id: "zebra",
+		name: "Zebra"
+	},
+	{
+		id: "giraffe",
+		name: "Giraffe"
+	},
+	{
+		id: "backpack",
+		name: "Backpack"
+	},
+	{
+		id: "umbrella",
+		name: "Umbrella"
+	},
+	{
+		id: "handbag",
+		name: "Handbag"
+	},
+	{
+		id: "tie",
+		name: "Tie"
+	},
+	{
+		id: "suitcase",
+		name: "Suitcase"
+	},
+	{
+		id: "frisbee",
+		name: "Frisbee"
+	},
+	{
+		id: "skis",
+		name: "Skis"
+	},
+	{
+		id: "snowboard",
+		name: "Snowboard"
+	},
+	{
+		id: "sports ball",
+		name: "Sports Ball"
+	},
+	{
+		id: "kite",
+		name: "Kite"
+	},
+	{
+		id: "baseball bat",
+		name: "Baseball Bat"
+	},
+	{
+		id: "baseball glove",
+		name: "Baseball Glove"
+	},
+	{
+		id: "skateboard",
+		name: "Skateboard"
+	},
+	{
+		id: "surfboard",
+		name: "Surfboard"
+	},
+	{
+		id: "tennis racket",
+		name: "Tennis Racket"
+	},
+	{
+		id: "bottle",
+		name: "Bottle"
+	},
+	{
+		id: "wine glass",
+		name: "Wine Glass"
+	},
+	{
+		id: "cup",
+		name: "Cup"
+	},
+	{
+		id: "fork",
+		name: "Fork"
+	},
+	{
+		id: "knife",
+		name: "Knife"
+	},
+	{
+		id: "spoon",
+		name: "Spoon"
+	},
+	{
+		id: "bowl",
+		name: "Bowl"
+	},
+	{
+		id: "banana",
+		name: "Banana"
+	},
+	{
+		id: "apple",
+		name: "Apple"
+	},
+	{
+		id: "sandwich",
+		name: "Sandwich"
+	},
+	{
+		id: "orange",
+		name: "Orange"
+	},
+	{
+		id: "broccoli",
+		name: "Broccoli"
+	},
+	{
+		id: "carrot",
+		name: "Carrot"
+	},
+	{
+		id: "hot dog",
+		name: "Hot Dog"
+	},
+	{
+		id: "pizza",
+		name: "Pizza"
+	},
+	{
+		id: "donut",
+		name: "Donut"
+	},
+	{
+		id: "cake",
+		name: "Cake"
+	},
+	{
+		id: "chair",
+		name: "Chair"
+	},
+	{
+		id: "couch",
+		name: "Couch"
+	},
+	{
+		id: "potted plant",
+		name: "Potted Plant"
+	},
+	{
+		id: "bed",
+		name: "Bed"
+	},
+	{
+		id: "dining table",
+		name: "Dining Table"
+	},
+	{
+		id: "toilet",
+		name: "Toilet"
+	},
+	{
+		id: "tv",
+		name: "TV"
+	},
+	{
+		id: "laptop",
+		name: "Laptop"
+	},
+	{
+		id: "mouse",
+		name: "Mouse"
+	},
+	{
+		id: "remote",
+		name: "Remote"
+	},
+	{
+		id: "keyboard",
+		name: "Keyboard"
+	},
+	{
+		id: "cell phone",
+		name: "Cell Phone"
+	},
+	{
+		id: "microwave",
+		name: "Microwave"
+	},
+	{
+		id: "oven",
+		name: "Oven"
+	},
+	{
+		id: "toaster",
+		name: "Toaster"
+	},
+	{
+		id: "sink",
+		name: "Sink"
+	},
+	{
+		id: "refrigerator",
+		name: "Refrigerator"
+	},
+	{
+		id: "book",
+		name: "Book"
+	},
+	{
+		id: "clock",
+		name: "Clock"
+	},
+	{
+		id: "vase",
+		name: "Vase"
+	},
+	{
+		id: "scissors",
+		name: "Scissors"
+	},
+	{
+		id: "teddy bear",
+		name: "Teddy Bear"
+	},
+	{
+		id: "hair drier",
+		name: "Hair Drier"
+	},
+	{
+		id: "toothbrush",
+		name: "Toothbrush"
+	}
+];
+var MACRO_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+];
 /**
-* The automation RECIPE — what a visually-authored automation is, before it
-* becomes code.
+* The class names a per-class COUNT can ever be keyed on — the macro ids, and
+* only those.
 *
-* This is the data half of `docs/design/2026-08-08-automation-scripts-custom-devices.md`
-* Phase 6. A recipe is not an engine and never evaluates anything: it is a
-* declarative description that {@link generateAutomationBlock} compiles to the
-* TypeScript of an ordinary core block. There is therefore no second rule
-* engine, no second store and no second runtime — the block runner is the
-* runtime, `core_blocks` is the store (§2.1).
+* `preserveOriginal: false` below is the whole reason this set exists: the
+* executor maps each raw COCO label onto its macro and DROPS everything else,
+* so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
+* Any surface that indexes counts by class name — the ZoneAnalytics occupancy
+* snapshot's `byClass`, and therefore every occupancy rule — can match nothing
+* else. Derived from the catalog, never hand-listed, so a new macro joins it by
+* being declared once.
+*
+* Cost of not having it, 2026-08-12: the notification rule editor offered the
+* full taxonomy for an occupancy class (occupancy is the one condition that
+* does not go through the engine's macro-expanding `expandClassSelector`), two
+* live rules were authored on `car`, and both counters read 0 forever.
+*/
+var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
+/** True when `className` is a macro the detector can actually emit (and hence a
+*  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
+function isDetectionMacroClass(className) {
+	return DETECTION_MACRO_CLASSES.has(className.trim().toLowerCase());
+}
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
+//#endregion
+//#region src/automation/detection-subject.ts
+/**
+* WHAT a detection-shaped leaf is about: one MACRO class (person, vehicle,
+* animal, package) plus an OPTIONAL label that narrows it.
 *
-* Three vocabularies, each salvaged rather than invented:
+* The taxonomy is `COCO_TO_MACRO` (and `CLASS_MAP_MACRO_TARGETS`) — never a
+* second list. The label that fits depends on the macro class:
 *
-*  - **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 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'}`
-*    fragment of §3.2.2. See {@link AutomationActionSchema} for the ONE place
-*    this had to diverge from "verbatim", and why.
+*  - `animal`  → a sub-class (`dog`, `cat`, …);
+*  - `person`  → a known face (an identity of the `face-gallery`);
+*  - `vehicle` → a plate (its text) or a sub-class (`car`, `truck`, …);
+*  - `package` → a sub-class.
+*
+* `other` exists only so a class the taxonomy does not know (a custom model's
+* `forklift`) survives the conversion of a stored recipe without widening.
+*
+* A label is decided LATE (D683): face recognition and LPR land after the
+* detection starts. The track-lifecycle `update` event carries the newly
+* resolved `label` / `plateText`, which is why a leaf with a label fires when
+* the subject GETS it — not at the first detection.
+*/
+var SubClassLabelSchema = zod.z.object({
+	kind: zod.z.literal("sub-class"),
+	className: zod.z.string().min(1)
+});
+var IdentityLabelSchema = zod.z.object({
+	kind: zod.z.literal("identity"),
+	/** The `face-gallery` identity id (stable across a rename). */
+	identityId: zod.z.string().min(1),
+	/** The identity's name — what a track-lifecycle event carries as `label`. */
+	name: zod.z.string().min(1)
+});
+var PlateLabelSchema = zod.z.object({
+	kind: zod.z.literal("plate"),
+	text: zod.z.string().min(1)
+});
+function macroOf$1(className) {
+	return COCO_TO_MACRO.mapping[className.toLowerCase()] ?? className.toLowerCase();
+}
+/** A sub-class label must belong to the macro it is under. */
+function subClassBelongs(macro, label) {
+	return label === void 0 || macroOf$1(label.className) === macro;
+}
+var subClassOf = (macro) => SubClassLabelSchema.refine((l) => subClassBelongs(macro, l), { message: `that class is not a kind of ${macro} in the detection taxonomy` });
+var DetectionSubjectSchema = zod.z.discriminatedUnion("macro", [
+	zod.z.object({
+		macro: zod.z.literal("animal"),
+		label: subClassOf("animal").optional()
+	}),
+	zod.z.object({
+		macro: zod.z.literal("person"),
+		label: IdentityLabelSchema.optional()
+	}),
+	zod.z.object({
+		macro: zod.z.literal("vehicle"),
+		label: zod.z.discriminatedUnion("kind", [SubClassLabelSchema.refine((l) => subClassBelongs("vehicle", l), { message: "that class is not a kind of vehicle in the detection taxonomy" }), PlateLabelSchema]).optional()
+	}),
+	zod.z.object({
+		macro: zod.z.literal("package"),
+		label: subClassOf("package").optional()
+	}),
+	zod.z.object({
+		macro: zod.z.literal("other"),
+		className: zod.z.string().min(1)
+	})
+]);
+/**
+* The subject of a PARKED object. The stationary registry's event carries a
+* class and a zone, no face and no plate — an identity or plate label there
+* could never match, so the schema refuses it instead of letting it sit dead.
+*/
+var StationarySubjectSchema = DetectionSubjectSchema.refine((s) => s.macro === "other" || s.label === void 0 || s.label.kind === "sub-class", { message: "a parked object carries no face or plate — only a class can narrow it" });
+/**
+* Where an editor lists the labels of a macro class. Sub-classes come from the
+* taxonomy (`subClassesOf`); identities and plates come from the galleries'
+* own methods, so a picker reads the cap and never a copy of it.
+*/
+var DETECTION_LABEL_SOURCES = {
+	animal: [{ kind: "sub-class" }],
+	person: [{
+		kind: "cap",
+		cap: "face-gallery",
+		method: "listIdentities",
+		label: "identity"
+	}],
+	vehicle: [{
+		kind: "cap",
+		cap: "plate-gallery",
+		method: "listPlates",
+		label: "plate"
+	}, { kind: "sub-class" }],
+	package: [{ kind: "sub-class" }]
+};
+/** The raw classes the taxonomy files under a macro class. */
+function subClassesOf(macro) {
+	return Object.entries(COCO_TO_MACRO.mapping).filter(([, m]) => m === macro).map(([raw]) => raw);
+}
+/**
+* A stored class string as a subject: a macro name stays a macro; a raw class
+* the taxonomy files under a macro becomes that macro plus the sub-class label
+* (`dog` → animal / dog); anything else is `other`, kept verbatim.
+*/
+function subjectFromClassName(className) {
+	const name = className.trim().toLowerCase();
+	const macro = COCO_TO_MACRO.mapping[name];
+	if (new Set(Object.values(COCO_TO_MACRO.mapping)).has(name)) return macroOnly(name);
+	if (macro === void 0) return {
+		macro: "other",
+		className
+	};
+	const label = {
+		kind: "sub-class",
+		className: name
+	};
+	switch (macro) {
+		case "animal": return {
+			macro: "animal",
+			label
+		};
+		case "vehicle": return {
+			macro: "vehicle",
+			label
+		};
+		case "package": return {
+			macro: "package",
+			label
+		};
+		default: return {
+			macro: "other",
+			className
+		};
+	}
+}
+function macroOnly(macro) {
+	switch (macro) {
+		case "animal": return { macro: "animal" };
+		case "person": return { macro: "person" };
+		case "vehicle": return { macro: "vehicle" };
+		case "package": return { macro: "package" };
+		default: return {
+			macro: "other",
+			className: macro
+		};
+	}
+}
+function normalisePlate(text) {
+	return text.toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+/** A human name for a subject, for a reason line. */
+function describeSubject(subject) {
+	if (subject.macro === "other") return subject.className;
+	const label = subject.label;
+	if (label === void 0) return subject.macro;
+	switch (label.kind) {
+		case "sub-class": return `${subject.macro} ${label.className}`;
+		case "identity": return `${subject.macro} ${label.name}`;
+		case "plate": return `${subject.macro} plate ${label.text}`;
+	}
+}
+/** Does one observation satisfy one subject, and which label did it match? */
+function subjectMatches(subject, observed) {
+	const className = observed.className.toLowerCase();
+	if (subject.macro === "other") return className === subject.className.toLowerCase() ? {
+		matches: true,
+		label: ""
+	} : {
+		matches: false,
+		reason: `class ${observed.className || "unknown"} is not ${subject.className}`
+	};
+	if (macroOf$1(className) !== subject.macro) return {
+		matches: false,
+		reason: `class ${observed.className || "unknown"} is not a ${subject.macro}`
+	};
+	const label = subject.label;
+	if (label === void 0) return {
+		matches: true,
+		label: ""
+	};
+	switch (label.kind) {
+		case "sub-class": {
+			const wanted = label.className.toLowerCase();
+			return [
+				className,
+				...observed.classes ?? [],
+				observed.label ?? ""
+			].map((c) => c.toLowerCase()).includes(wanted) ? {
+				matches: true,
+				label: label.className
+			} : {
+				matches: false,
+				reason: `${subject.macro} ${label.className} not seen yet`
+			};
+		}
+		case "identity": {
+			const byId = observed.identityId !== void 0 && observed.identityId === label.identityId;
+			const byName = observed.label !== void 0 && observed.label.toLowerCase() === label.name.toLowerCase();
+			return byId || byName ? {
+				matches: true,
+				label: label.name
+			} : {
+				matches: false,
+				reason: `face ${label.name} not recognised yet${observed.label === void 0 || observed.label === "" ? "" : ` (seen as ${observed.label})`}`
+			};
+		}
+		case "plate": {
+			const text = observed.plateText ?? observed.label ?? "";
+			return text !== "" && normalisePlate(text) === normalisePlate(label.text) ? {
+				matches: true,
+				label: label.text
+			} : {
+				matches: false,
+				reason: `plate ${label.text} not read yet${text === "" ? "" : ` (read ${text})`}`
+			};
+		}
+	}
+}
+/** The first subject an observation satisfies, else why the last one did not. */
+function anySubjectMatches(subjects, observed) {
+	let lastReason = "no subject listed";
+	for (const subject of subjects) {
+		const verdict = subjectMatches(subject, observed);
+		if (verdict.matches) return verdict;
+		lastReason = verdict.reason;
+	}
+	return {
+		matches: false,
+		reason: subjects.length === 1 ? lastReason : `none of [${subjects.map(describeSubject).join(", ")}] matches (${observed.className || "unknown"})`
+	};
+}
+//#endregion
+//#region src/automation/when.ts
+/**
+* The `when` tree — the ONE place an automation says when it runs.
+*
+* Containers are `all` / `any` / `not`. Leaves come in two kinds, told apart by
+* what they ARE, not by which section of a form they sit in:
+*
+*  - **event leaves (instants)** — something HAPPENS: a device field *becomes*
+*    a value, a device event, a schedule tick, an interval, a manual run, a
+*    detection, a parked object appearing or leaving;
+*  - **state leaves (durations)** — something IS true: a device field *is*
+*    compared to a value, a parked object is present, an expression holds.
 *
-* Bounds are a guard, not a paragraph (§3.2.1): depth ≤ 3, ≤ 32 leaves. They are
-* enforced by {@link validateRecipeBounds} AND by the schema, so a recipe that
-* arrives over the wire cannot skip the check that the editor applies.
+* Firing rule (ADR, "one tree"):
+*  1. A tree with event leaves fires when ONE of them occurs AND the whole tree
+*     is true at that instant. The event that occurred is true; every other
+*     event leaf is false.
+*  2. A tree of state leaves only fires when it goes false → true. The first
+*     evaluation seeds the state, so it never fires because it was already true.
+*  3. Two event leaves that can only be satisfied together are refused at
+*     author time ({@link validateWhenTree}).
 */
 /**
-* Depth of a condition tree, counting the root container as level 1.
+* Depth of the `when` tree, counting the root container as level 1. The old
+* condition tree was bounded at 3 under a flat list of triggers; the trigger
+* list is now the tree's top `any`, one level, so the bound is 3 + 1 and a
+* converted recipe never exceeds it.
 *
-* Three is enough and is not arbitrary: `NOT` over a group is always rewritable
-* by De Morgan (`not(any(a,b))` ≡ `all(not a, not b)`), so the shapes that would
-* need a fourth level have an equivalent at three. An editor that refuses depth
-* 4 should offer that rewrite rather than refusing blankly.
+* `NOT` over a group is always rewritable by De Morgan, so the shapes that
+* would need a fifth level have an equivalent at four.
 */
-var MAX_CONDITION_DEPTH = 3;
+var MAX_WHEN_DEPTH = 4;
 /** Leaves per automation. A UI that grows without a bound becomes a language. */
-var MAX_CONDITION_LEAVES = 32;
-/** How a leaf compares a device field to a value. Derived from the field's
-*  `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
+var MAX_WHEN_LEAVES = 32;
+/** How a state leaf compares a device field to a value. Derived from the
+*  field's `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
 var AutomationConditionOperatorSchema = zod.z.enum([
 	"eq",
 	"ne",
@@ -8896,12 +9513,76 @@ var AutomationConditionOperatorSchema = zod.z.enum([
 	"contains",
 	"in"
 ]);
-var AutomationConditionLeafSchema = zod.z.object({
-	kind: zod.z.literal("condition"),
+/**
+* D8 compliance, and it is the reason a "becomes" leaf is not merely an event
+* subscription: it evaluates against the **state mirror**, which is reconciled,
+* and an event only WAKES the evaluation. A dropped event therefore DELAYS a
+* fire; it does not lose it.
+*/
+var DeviceBecomesLeafSchema = zod.z.object({
+	kind: zod.z.literal("device-becomes"),
+	deviceId: zod.z.number().int().nonnegative(),
+	cap: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1),
+	/** Fire when the field takes this value. Omit to fire on any change. */
+	becomes: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean()
+	]).optional(),
+	/** Only on a CHANGE of value, not on every re-report. */
+	edge: zod.z.boolean().optional(),
+	/** The new value must hold this long before it counts. */
+	forMs: zod.z.number().int().min(0).max(864e5).optional(),
+	/** Collapse a burst into one occurrence. */
+	debounceMs: zod.z.number().int().min(0).max(6e5).optional()
+});
+var DeviceEventLeafSchema = zod.z.object({
+	kind: zod.z.literal("device-event"),
+	/** An `EventCategory` value. */
+	category: zod.z.string().min(1),
+	deviceId: zod.z.number().int().nonnegative().optional()
+});
+var ScheduleLeafSchema = zod.z.object({
+	kind: zod.z.literal("schedule"),
+	cron: zod.z.string().min(1).max(120)
+});
+var ManualLeafSchema = zod.z.object({ kind: zod.z.literal("manual") });
+var IntervalLeafSchema = zod.z.object({
+	kind: zod.z.literal("interval"),
+	minutes: zod.z.number().int().min(1).max(1440)
+});
+var DetectionLeafSchema = zod.z.object({
+	kind: zod.z.literal("detection"),
+	/** One macro class each, optionally narrowed by a label; a track of any listed subject fires. */
+	subjects: zod.z.array(DetectionSubjectSchema).min(1),
+	deviceIds: zod.z.array(zod.z.number().int().nonnegative()).min(1),
+	/** The track must have visited at least one of these zones. */
+	zones: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+	/** Best-so-far confidence the track must reach. */
+	minScore: zod.z.number().min(0).max(1).optional()
+});
+var StationaryLeafSchema = zod.z.object({
+	kind: zod.z.literal("stationary"),
+	deviceIds: zod.z.array(zod.z.number().int().nonnegative()).min(1),
+	subjects: zod.z.array(StationarySubjectSchema).min(1).optional(),
+	zones: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+	/** `appeared`: it became parked. `departed`: the registry retired it. */
+	phase: zod.z.enum(["appeared", "departed"])
+});
+/** "is": one device field compared to one value, NOW. */
+var DeviceIsLeafSchema = zod.z.object({
+	kind: zod.z.literal("device-is"),
 	deviceId: zod.z.number().int().nonnegative(),
 	cap: zod.z.string().min(1),
 	fieldPath: zod.z.string().min(1),
 	operator: AutomationConditionOperatorSchema,
+	/**
+	* The value. A number on a quantity field is stored in the field's base unit
+	* (D944); a quantity value is the WRITE form, which the save boundary
+	* replaces with the converted number and `unit`. A leaf that still carries
+	* one is never evaluated (it fails).
+	*/
 	value: zod.z.union([
 		zod.z.string(),
 		zod.z.number(),
@@ -8909,24 +9590,26 @@ var AutomationConditionLeafSchema = zod.z.object({
 		zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
 		QuantityValueSchema
 	]),
+	/** The unit the person picked for `value` (display only; `value` is in the base unit). */
 	unit: zod.z.string().min(1).optional()
 });
-var AutomationConditionStationaryPresentSchema = zod.z.object({
+/**
+* True when the camera currently has a PARKED object matching `subjects` in at
+* least one of `zones`. Reads the zone-analytics snapshot through the same
+* mirror as every other state leaf, so a dropped event never decides it (D49).
+*/
+var StationaryPresentLeafSchema = 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. */
+	subjects: zod.z.array(StationarySubjectSchema).min(1).optional(),
 	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
-* read `kind` off each option, and an intersection hides it. The author-time
-* validation is the SAME function `ExpressionSourceSchema` runs, so the two
-* cannot drift — an expression that one accepts, the other accepts.
+* The escape hatch: the bounded expression engine over named device bindings.
+* Declared as a plain object so a discriminated union can read `kind`; the
+* author-time validation is the SAME function `ExpressionSourceSchema` runs.
 */
-var AutomationConditionExpressionSchema = zod.z.object({
+var ExpressionLeafSchema = zod.z.object({
 	kind: zod.z.literal("expression"),
 	expr: zod.z.string().min(1).max(require_composition.MAX_EXPRESSION_SOURCE_LENGTH),
 	bindings: zod.z.record(zod.z.string().regex(require_composition.EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
@@ -8938,55 +9621,180 @@ var AutomationConditionExpressionSchema = zod.z.object({
 		path: ["expr"]
 	});
 });
-var AutomationConditionSchema = zod.z.lazy(() => zod.z.discriminatedUnion("kind", [
+var AutomationWhenSchema = zod.z.lazy(() => zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("all"),
-		children: zod.z.array(AutomationConditionSchema)
+		children: zod.z.array(AutomationWhenSchema)
 	}),
 	zod.z.object({
 		kind: zod.z.literal("any"),
-		children: zod.z.array(AutomationConditionSchema)
+		children: zod.z.array(AutomationWhenSchema)
 	}),
 	zod.z.object({
 		kind: zod.z.literal("not"),
-		child: AutomationConditionSchema
+		child: AutomationWhenSchema
 	}),
-	AutomationConditionLeafSchema,
-	AutomationConditionExpressionSchema,
-	AutomationConditionStationaryPresentSchema
+	DeviceBecomesLeafSchema,
+	DeviceEventLeafSchema,
+	ScheduleLeafSchema,
+	ManualLeafSchema,
+	IntervalLeafSchema,
+	DetectionLeafSchema,
+	StationaryLeafSchema,
+	DeviceIsLeafSchema,
+	StationaryPresentLeafSchema,
+	ExpressionLeafSchema
 ]));
+var EVENT_KINDS = new Set([
+	"device-becomes",
+	"device-event",
+	"schedule",
+	"manual",
+	"interval",
+	"detection",
+	"stationary"
+]);
+function isEventLeaf(node) {
+	return EVENT_KINDS.has(node.kind);
+}
+function isLeaf(node) {
+	return node.kind !== "all" && node.kind !== "any" && node.kind !== "not";
+}
+/** Depth of a tree, root container = 1. A bare leaf is depth 1. */
+function whenDepth(node) {
+	if (isLeaf(node)) return 1;
+	if (node.kind === "not") return 1 + whenDepth(node.child);
+	let deepest = 0;
+	for (const child of node.children) deepest = Math.max(deepest, whenDepth(child));
+	return 1 + deepest;
+}
+/** Leaves only — containers do not count toward the leaf budget. */
+function countWhenLeaves(node) {
+	if (isLeaf(node)) return 1;
+	if (node.kind === "not") return countWhenLeaves(node.child);
+	let total = 0;
+	for (const child of node.children) total += countWhenLeaves(child);
+	return total;
+}
+/** Every leaf with its path (`when`, `when.0`, `when.0.1`, `when.0` under a `not`). */
+function forEachLeaf(node, visit, path = "when") {
+	if (isLeaf(node)) {
+		visit(node, path);
+		return;
+	}
+	if (node.kind === "not") {
+		forEachLeaf(node.child, visit, `${path}.0`);
+		return;
+	}
+	node.children.forEach((child, i) => {
+		forEachLeaf(child, visit, `${path}.${i}`);
+	});
+}
+function hasEventLeaves(node) {
+	let found = false;
+	forEachLeaf(node, (leaf) => {
+		if (isEventLeaf(leaf)) found = true;
+	});
+	return found;
+}
+function hasEmptyContainer(node) {
+	if (isLeaf(node)) return false;
+	if (node.kind === "not") return hasEmptyContainer(node.child);
+	if (node.children.length === 0) return true;
+	return node.children.some(hasEmptyContainer);
+}
+var LEAF_WORDS = {
+	"device-becomes": "a device value that becomes",
+	"device-event": "a device event",
+	schedule: "a schedule",
+	manual: "a manual run",
+	interval: "an interval",
+	detection: "a detection",
+	stationary: "a parked object appearing or leaving"
+};
+function say(kind) {
+	return LEAF_WORDS[kind] ?? kind;
+}
 /**
-* What starts a run.
-*
-* D8 compliance, and it is the reason `device-state` is not merely an event
-* subscription: the trigger evaluates against the **state mirror**, which is
-* reconciled, and an event only WAKES the evaluation. A dropped event therefore
-* DELAYS a trigger; it does not lose it. `schedule` uses `croner` — the one
-* already in the repo — because `setInterval(24h)` drifts and "at 23:30" does
-* not.
+* The cheapest set of event leaves that makes `node` true, with negation pushed
+* down to the leaves first (De Morgan), so `not(any(A, B))` and `all(not A,
+* not B)` are the same shape to the check. A negated event is its own error: an
+* event is an instant, "the event did not occur" is true at every other moment.
 */
-var AutomationTriggerSchema = zod.z.discriminatedUnion("kind", [
+function eventNeed(node, path, negated) {
+	if (isLeaf(node)) {
+		if (!isEventLeaf(node)) return { paths: [] };
+		if (negated) return { error: `"not" is applied to ${say(node.kind)} (${path}) — an event is an instant, so "it did not happen" is true at every other moment and can never start a run. Negate a state ("is") instead, or remove the "not"` };
+		return { paths: [{
+			path,
+			kind: node.kind
+		}] };
+	}
+	if (node.kind === "not") return eventNeed(node.child, `${path}.0`, !negated);
+	const conjunctive = node.kind === "all" !== negated;
+	const parts = [];
+	for (let i = 0; i < node.children.length; i += 1) {
+		const child = node.children[i];
+		if (child === void 0) continue;
+		const need = eventNeed(child, `${path}.${i}`, negated);
+		if ("error" in need) return need;
+		parts.push(need);
+	}
+	if (conjunctive) return { paths: parts.flatMap((p) => p.paths) };
+	let best;
+	for (const part of parts) if (best === void 0 || part.paths.length < best.paths.length) best = part;
+	return best ?? { paths: [] };
+}
+/**
+* Author-time bounds and sense check of a `when` tree. Returns `null` when it
+* is legal, else a message the editor shows verbatim.
+*/
+function validateWhenTree(when) {
+	if (hasEmptyContainer(when)) return "a group is empty — group existing rows instead of leaving a container to fill";
+	const depth = whenDepth(when);
+	if (depth > 4) return `the rules nest ${depth} levels deep — the limit is 4. "not (any of …)" is the same as "all of (not …)", which is one level shallower`;
+	const leaves = countWhenLeaves(when);
+	if (leaves > 32) return `the rules use ${leaves} rows — the limit is 32`;
+	const need = eventNeed(when, "when", false);
+	if ("error" in need) return need.error;
+	const [first, second] = need.paths;
+	if (first !== void 0 && second !== void 0) return `${say(first.kind)} (${first.path}) and ${say(second.kind)} (${second.path}) would both have to happen at the same instant, and an event happens at one moment — this can never run. Use "any of" to start on either, or turn one of them into a state ("is") that must already hold`;
+	return null;
+}
+//#endregion
+//#region src/automation/legacy-recipe.ts
+/**
+* The recipe shape before the single `when` tree: a flat list of triggers
+* (OR'd, each an instant) and an optional condition tree. Stored recipes —
+* the `AUTOMATION_RECIPE` literal of every block saved so far, and whatever an
+* older client still posts — are in this shape, so it stays READABLE here, and
+* {@link convertLegacyRecipe} turns it into the new one, losslessly and one
+* way. Nothing writes this shape any more.
+*
+*   `{ triggers: [t1…tn], conditions?: C }`
+*      → `when = all(any(t1…tn), C)`, or `any(t1…tn)` without `C`;
+*        a single trigger is not wrapped in `any`.
+*   a `condition` leaf → a `device-is` leaf (the "is" verb);
+*   a `device-state` trigger → a `device-becomes` leaf (the "becomes" verb);
+*   `classes: ['dog']` → the macro `animal` with the label `dog`.
+*/
+var LegacyTriggerSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
 		kind: zod.z.literal("device-state"),
 		deviceId: zod.z.number().int().nonnegative(),
 		cap: zod.z.string().min(1),
 		fieldPath: zod.z.string().min(1),
-		/** Fire when the field takes this value. Omit to fire on any change. */
 		becomes: zod.z.union([
 			zod.z.string(),
 			zod.z.number(),
 			zod.z.boolean()
 		]).optional(),
-		/** Only on a CHANGE of value, not on every re-report. */
 		edge: zod.z.boolean().optional(),
-		/** The condition must hold this long before the run starts. */
 		forMs: zod.z.number().int().min(0).max(864e5).optional(),
-		/** Collapse a burst into one run. */
 		debounceMs: zod.z.number().int().min(0).max(6e5).optional()
 	}),
 	zod.z.object({
 		kind: zod.z.literal("device-event"),
-		/** An `EventCategory` value. */
 		category: zod.z.string().min(1),
 		deviceId: zod.z.number().int().nonnegative().optional()
 	}),
@@ -8997,25 +9805,16 @@ var AutomationTriggerSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({ kind: zod.z.literal("manual") }),
 	zod.z.object({
 		kind: zod.z.literal("detection"),
-		/** Class names. A macro class (`animal`, `vehicle`, `person`, `package`)
-		*  matches every raw class that maps to it; any other name matches
-		*  exactly. */
 		classes: zod.z.array(zod.z.string().min(1)).min(1),
 		deviceIds: zod.z.array(zod.z.number().int().nonnegative()).min(1),
-		/** The track must have visited at least one of these zones. */
 		zones: zod.z.array(zod.z.string().min(1)).min(1).optional(),
-		/** 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({
@@ -9023,6 +9822,145 @@ var AutomationTriggerSchema = zod.z.discriminatedUnion("kind", [
 		minutes: zod.z.number().int().min(1).max(1440)
 	})
 ]);
+var LegacyConditionLeafSchema = zod.z.object({
+	kind: zod.z.literal("condition"),
+	deviceId: zod.z.number().int().nonnegative(),
+	cap: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1),
+	operator: AutomationConditionOperatorSchema,
+	value: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean(),
+		zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
+		QuantityValueSchema
+	]),
+	unit: zod.z.string().min(1).optional()
+});
+var LegacyStationaryPresentSchema = zod.z.object({
+	kind: zod.z.literal("stationary-present"),
+	deviceId: zod.z.number().int().nonnegative(),
+	classes: zod.z.array(zod.z.string().min(1)).min(1).optional(),
+	zones: zod.z.array(zod.z.string().min(1)).min(1).optional()
+});
+var LegacyExpressionSchema = zod.z.object({
+	kind: zod.z.literal("expression"),
+	expr: zod.z.string().min(1).max(require_composition.MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: zod.z.record(zod.z.string().regex(require_composition.EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+}).superRefine((src, ctx) => {
+	const err = require_composition.validateExpressionSource(src);
+	if (err !== null) ctx.addIssue({
+		code: "custom",
+		message: err,
+		path: ["expr"]
+	});
+});
+var LegacyConditionSchema = zod.z.lazy(() => zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("all"),
+		children: zod.z.array(LegacyConditionSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("any"),
+		children: zod.z.array(LegacyConditionSchema)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("not"),
+		child: LegacyConditionSchema
+	}),
+	LegacyConditionLeafSchema,
+	LegacyExpressionSchema,
+	LegacyStationaryPresentSchema
+]));
+function convertTrigger(trigger) {
+	switch (trigger.kind) {
+		case "device-state": return {
+			...trigger,
+			kind: "device-becomes"
+		};
+		case "detection": {
+			const { classes, ...rest } = trigger;
+			return {
+				...rest,
+				subjects: classes.map(subjectFromClassName)
+			};
+		}
+		case "stationary": {
+			const { classes, ...rest } = trigger;
+			return {
+				...rest,
+				...classes === void 0 ? {} : { subjects: classes.map(subjectFromClassName) }
+			};
+		}
+		default: return trigger;
+	}
+}
+/** An old condition tree as a `when` subtree: `condition` → "is", classes → subjects. */
+function convertLegacyCondition(condition) {
+	switch (condition.kind) {
+		case "condition": return {
+			...condition,
+			kind: "device-is"
+		};
+		case "stationary-present": {
+			const { classes, ...rest } = condition;
+			return {
+				...rest,
+				...classes === void 0 ? {} : { subjects: classes.map(subjectFromClassName) }
+			};
+		}
+		case "expression": return condition;
+		case "not": return {
+			kind: "not",
+			child: convertLegacyCondition(condition.child)
+		};
+		case "all":
+		case "any": return {
+			kind: condition.kind,
+			children: condition.children.map(convertLegacyCondition)
+		};
+	}
+}
+/** `all(any(t1…tn), C)`, or `any(t1…tn)`; a single trigger is not wrapped in `any`. */
+function convertLegacyWhen(half) {
+	const leaves = half.triggers.map(convertTrigger);
+	const first = leaves[0];
+	const triggers = leaves.length === 1 && first !== void 0 ? first : {
+		kind: "any",
+		children: leaves
+	};
+	if (half.conditions === void 0) return triggers;
+	return {
+		kind: "all",
+		children: [triggers, convertLegacyCondition(half.conditions)]
+	};
+}
+//#endregion
+//#region src/automation/recipe.ts
+/**
+* The automation RECIPE — what a visually-authored automation is, before it
+* becomes code.
+*
+* This is the data half of `docs/design/2026-08-08-automation-scripts-custom-devices.md`
+* Phase 6. A recipe is not an engine and never evaluates anything: it is a
+* declarative description that {@link generateAutomationBlock} compiles to the
+* TypeScript of an ordinary core block. There is therefore no second rule
+* engine, no second store and no second runtime — the block runner is the
+* runtime, `core_blocks` is the store (§2.1).
+*
+* Two parts:
+*
+*  - **`when`** — ONE tree (`./when.ts`) of all/any/not over event leaves
+*    (instants) and state leaves (durations). It replaces the flat trigger list
+*    plus the separate condition tree; the firing rule is in that file and in
+*    ADR "one tree".
+*  - **Actions** — `NcRuleActionSchema`'s two steps, plus the `{kind:'code'}`
+*    fragment of §3.2.2. See {@link AutomationActionSchema} for the ONE place
+*    this had to diverge from "verbatim", and why.
+*
+* A recipe stored in the old shape (`triggers` + `conditions`) still LOADS:
+* {@link AutomationRecipeSchema} (the parse-anywhere schema) converts it on parse. Nothing writes it.
+*/
 /**
 * One action step.
 *
@@ -9128,61 +10066,49 @@ var AutomationRunModeSchema = zod.z.discriminatedUnion("mode", [
 /** Run traces kept per automation when the recipe does not say. */
 var DEFAULT_TRACE_KEEP = 20;
 var MAX_TRACE_KEEP = 100;
-var AutomationRecipeSchema = zod.z.object({
-	triggers: zod.z.array(AutomationTriggerSchema),
-	conditions: AutomationConditionSchema.optional(),
+var CurrentAutomationRecipeSchema = zod.z.object({
+	when: AutomationWhenSchema,
 	actions: zod.z.array(AutomationActionSchema),
 	runMode: AutomationRunModeSchema.optional(),
 	/** 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 (isLeaf(cond)) return 1;
-	if (cond.kind === "not") return 1 + conditionDepth(cond.child);
-	const children = cond.children;
-	if (children.length === 0) return 1;
-	let deepest = 0;
-	for (const child of children) {
-		const d = conditionDepth(child);
-		if (d > deepest) deepest = d;
-	}
-	return 1 + deepest;
-}
-/** Leaves only — containers do not count toward the leaf budget. */
-function countConditionLeaves(cond) {
-	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 (isLeaf(cond)) return false;
-	if (cond.kind === "not") return findEmptyContainer(cond.child);
-	if (cond.children.length === 0) return true;
-	return cond.children.some(findEmptyContainer);
+/** A recipe as it was stored before the single tree. Read-only: nothing writes this. */
+var LegacyAutomationRecipeSchema = zod.z.object({
+	triggers: zod.z.array(LegacyTriggerSchema),
+	conditions: LegacyConditionSchema.optional(),
+	actions: zod.z.array(AutomationActionSchema),
+	runMode: AutomationRunModeSchema.optional(),
+	keepTraces: zod.z.number().int().min(1).max(100).optional()
+});
+/** The old shape as the new one, lossless. */
+function convertLegacyRecipe(legacy) {
+	const { triggers, conditions, ...rest } = legacy;
+	return {
+		when: convertLegacyWhen({
+			triggers,
+			conditions
+		}),
+		...rest
+	};
 }
 /**
-* Author-time bounds check. Returns `null` when the recipe is legal, else a
-* message naming the bound it broke — the editor shows it verbatim, so it has
-* to read like something an operator can act on.
+* Where recipes are PARSED (the core-blocks cap, the MCP tool, the literal a
+* saved block carries): the new shape as it is, or the old shape converted to
+* it. The output type is always the new one.
+*/
+var AutomationRecipeSchema = zod.z.union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
+/** Bounds, shared by `when` and the old names the guards still know. */
+var MAX_CONDITION_DEPTH = 4;
+var MAX_CONDITION_LEAVES = 32;
+/**
+* Author-time check. Returns `null` when the recipe is legal, else a message
+* naming what is wrong — the editor shows it verbatim, so it has to read like
+* something an operator can act on.
 */
 function validateRecipeBounds(recipe) {
-	if (recipe.triggers.length === 0) return "an automation needs at least one trigger — without one nothing can start a run";
 	if (recipe.actions.length === 0) return "an automation needs at least one action — a rule that does nothing is not a rule";
-	const cond = recipe.conditions;
-	if (cond !== void 0) {
-		if (findEmptyContainer(cond)) return "a condition group is empty — group existing rows instead of leaving a container to fill";
-		const depth = conditionDepth(cond);
-		if (depth > 3) return `conditions nest ${depth} levels deep — the limit is 3. "not (any of …)" is the same as "all of (not …)", which is one level shallower`;
-		const leaves = countConditionLeaves(cond);
-		if (leaves > 32) return `conditions use ${leaves} leaves — the limit is 32`;
-	}
-	return null;
+	return validateWhenTree(recipe.when);
 }
 //#endregion
 //#region src/automation/codegen.ts
@@ -9206,9 +10132,10 @@ function stepMetaOf(action) {
 function j(value) {
 	return JSON.stringify(value);
 }
-function emitTrigger(trigger, index) {
+function emitLeaf(trigger, path) {
+	const at = j(path);
 	switch (trigger.kind) {
-		case "schedule": return `  // trigger ${index}: schedule — armed to the next minute boundary and
+		case "schedule": return `  // event leaf ${path}: schedule — armed to the next minute boundary and
   // RE-ARMED from the wall clock every tick, so it cannot drift the way a
   // setInterval(24h) does. No cron library: a block cannot resolve one.
   {
@@ -9216,7 +10143,7 @@ function emitTrigger(trigger, index) {
     const arm = (): void => {
       timer = setTimeout(() => {
         if (cronMatches(${j(trigger.cron)}, new Date())) {
-          void run({ kind: 'schedule', at: Date.now() })
+          void run({ kind: 'schedule', leaf: ${at}, at: Date.now() })
         }
         arm()
       }, nextMinuteBoundary())
@@ -9224,13 +10151,14 @@ function emitTrigger(trigger, index) {
     arm()
     disposers.push(() => { if (timer !== undefined) clearTimeout(timer) })
   }`;
-		case "device-event": return `  // trigger ${index}: device event
+		case "device-event": return `  // event leaf ${path}: device event
   disposers.push(
     ctx.eventBus.subscribe(
       { category: ${j(trigger.category)}${trigger.deviceId === void 0 ? "" : `, deviceId: ${j(trigger.deviceId)}`} },
       (event) => {
         void run({
           kind: 'device-event',
+          leaf: ${at},
           at: Date.now(),
           deviceId: event.deviceId,
           category: ${j(trigger.category)},
@@ -9238,9 +10166,9 @@ function emitTrigger(trigger, index) {
       },
     ),
   )`;
-		case "device-state": {
+		case "device-becomes": {
 			const becomes = trigger.becomes === void 0 ? "undefined" : j(trigger.becomes);
-			return `  // trigger ${index}: device state — the mirror is the authority, the
+			return `  // event leaf ${path}: device state — the mirror is the authority, the
   // event only WAKES the evaluation, so a dropped event delays and never loses.
   {
     let previous: unknown = undefined
@@ -9261,7 +10189,8 @@ function emitTrigger(trigger, index) {
       }
       heldSince = undefined
       void run({
-        kind: 'device-state',
+        kind: 'device-becomes',
+        leaf: ${at},
         at: Date.now(),
         deviceId: ${j(trigger.deviceId)},
         cap: ${j(trigger.cap)},
@@ -9280,23 +10209,23 @@ function emitTrigger(trigger, index) {
     disposers.push(() => clearInterval(reconcile))
   }`;
 		}
-		case "manual": return `  // trigger ${index}: manual — fired by automation-control.trigger
+		case "manual": return `  // event leaf ${path}: manual — fired by automation-control.trigger
   // ("Run actions"), which runs the THEN half with an EMPTY vars bag. A manual
   // run bypasses only the cooldown wait, never the single/queued limits.`;
-		case "interval": return `  // trigger ${index}: interval — every ${trigger.minutes} min, first run jittered so
+		case "interval": return `  // event leaf ${path}: interval — every ${trigger.minutes} min, first run jittered so
   // blocks restarted together do not all fire on the same second.
   {
     let interval: ReturnType<typeof setInterval> | undefined
     const first = setTimeout(() => {
-      void run({ kind: 'interval', at: Date.now() })
-      interval = setInterval(() => { void run({ kind: 'interval', at: Date.now() }) }, ${j(trigger.minutes * 6e4)})
+      void run({ kind: 'interval', leaf: ${at}, at: Date.now() })
+      interval = setInterval(() => { void run({ kind: 'interval', leaf: ${at}, at: Date.now() }) }, ${j(trigger.minutes * 6e4)})
     }, Math.floor(Math.random() * Math.min(${j(trigger.minutes * 6e4)}, 30_000)) + 1)
     disposers.push(() => {
       clearTimeout(first)
       if (interval !== undefined) clearInterval(interval)
     })
   }`;
-		case "detection": return `  // trigger ${index}: detection — ONE fire per (device, track); a rejected event is
+		case "detection": return `  // event leaf ${path}: detection — ONE fire per (device, track); a rejected event is
   // traced with its reason and never fires.
   {
     const filter = new DetectionTriggerFilter(${j(trigger)})
@@ -9313,7 +10242,7 @@ function emitTrigger(trigger, index) {
             })
           }
           void run(
-            { kind: 'detection', at: Date.now(), ...decision.vars },
+            { kind: 'detection', leaf: ${at}, at: Date.now(), ...decision.vars },
             decision.reason,
             decision.kind === 'fire',
           )
@@ -9321,9 +10250,9 @@ function emitTrigger(trigger, index) {
       ),
     )
   }`;
-		case "stationary": return `  // trigger ${index}: stationary — a parked object appeared / departed. Stateless:
+		case "stationary": return `  // event leaf ${path}: 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.
+  // the stationary-present STATE leaf reads the registry, not this event.
   {
     const trigger = ${j(trigger)} as const
     disposers.push(
@@ -9339,7 +10268,7 @@ function emitTrigger(trigger, index) {
             })
           }
           void run(
-            { kind: 'stationary', at: Date.now(), ...decision.vars },
+            { kind: 'stationary', leaf: ${at}, at: Date.now(), ...decision.vars },
             decision.reason,
             decision.kind === 'fire',
           )
@@ -9361,11 +10290,11 @@ ${body}
 		case "cap":
 			if (Array.isArray(action.deviceId)) return step(`        for (const deviceId of ${j(action.deviceId)}) {
           scope.setDeviceId(deviceId)
-          await actuate(deviceId, ${j(action.cap)}, ${j(action.method)}, ${j(action.args ?? {})}, vars)
+          await actuate(scope, deviceId, ${j(action.cap)}, ${j(action.method)}, ${j(action.args ?? {})}, vars)
         }`);
 			return step(`        const deviceId = ${typeof action.deviceId === "number" ? j(action.deviceId) : `resolveTarget(vars, ${j(action.deviceId.$var)})`}
         scope.setDeviceId(deviceId)
-        await actuate(deviceId, ${j(action.cap)}, ${j(action.method)}, ${j(action.args ?? {})}, vars)`);
+        await actuate(scope, deviceId, ${j(action.cap)}, ${j(action.method)}, ${j(action.args ?? {})}, vars)`);
 		case "action": return step(`        // an Action run, awaited: the step takes THAT run's outcome
         const result = await ctx.api.actions.run.mutate({
           actionId: ${j(action.actionId)},
@@ -9395,6 +10324,13 @@ function generateAutomationBlock(input) {
 	const { name, recipe } = input;
 	const runMode = recipe.runMode ?? { mode: "single" };
 	const stepMeta = recipe.actions.map(stepMetaOf);
+	const eventLeaves = [];
+	forEachLeaf(recipe.when, (leaf, path) => {
+		if (isEventLeaf(leaf)) eventLeaves.push({
+			leaf,
+			path
+		});
+	});
 	return `import type {
   AddonContext,
   AutomationConditionTraceNode,
@@ -9402,6 +10338,7 @@ function generateAutomationBlock(input) {
   AutomationRunVerdict,
   AutomationStepTrace,
   RunnableStep,
+  StepScope,
 } from '@camstack/types'
 import {
   ConditionMirror,
@@ -9409,9 +10346,9 @@ import {
   EventCategory,
   RunGate,
   buildTriggerTrace,
-  collectMirrorSources,
+  collectWhenMirrorSources,
   coreBlockIdFromAddonId,
-  evaluateConditionTree,
+  evaluateWhenTree,
   evaluateStationaryTrigger,
   isSkippedTrace,
   mergeSkipTraces,
@@ -9439,7 +10376,11 @@ const RUN_MODE = ${j(runMode)} as const
 /** Run traces kept (a ring, held in the hub's runs ledger). */
 const KEEP_TRACES = ${recipe.keepTraces ?? 20}
 
-const CONDITIONS = ${recipe.conditions === void 0 ? "undefined" : "AUTOMATION_RECIPE.conditions"}
+/** The ONE tree: event leaves (instants) and state leaves (durations). */
+const WHEN = AUTOMATION_RECIPE.when
+
+/** No event leaf: the automation fires when the tree goes false → true, never because it was already true. */
+const STATE_ONLY = ${!hasEventLeaves(recipe.when)}
 
 /** Skips that repeat are folded into one trace; it goes to the hub after this. */
 const SKIP_FLUSH_MS = 5_000
@@ -9498,7 +10439,8 @@ function matchField(field: string, value: number): boolean {
 export default function block(ctx: AddonContext) {
   const disposers: Array<() => void> = []
   const gate = new RunGate(RUN_MODE)
-  const mirror = new ConditionMirror(collectMirrorSources(CONDITIONS))
+  const MIRROR_SOURCES = collectWhenMirrorSources(WHEN)
+  const mirror = new ConditionMirror(MIRROR_SOURCES)
   const BLOCK_ID = coreBlockIdFromAddonId(ctx.id)
   /** The cooldown stamp: memory is the authority at fire time (D49); the hub ledger is read once at start. */
   let lastRunStartedAt: number | null = null
@@ -9664,6 +10606,7 @@ export default function block(ctx: AddonContext) {
   }
 
   async function actuate(
+    scope: StepScope,
     deviceId: number,
     cap: string,
     method: string,
@@ -9673,6 +10616,7 @@ export default function block(ctx: AddonContext) {
     const substituted = substitute(args, vars)
     const resolved: Record<string, unknown> =
       substituted !== null && typeof substituted === 'object' ? { ...substituted } : {}
+    scope.setArgs(resolved)
     // Forked-addon ctx.api namespaces are tRPC Proxies over a noop function
     // (typeof === 'function'), not plain objects — reject only null/undefined.
     const client: unknown = Reflect.get(ctx.api, capToRouterKey(cap))
@@ -9761,10 +10705,13 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
     let nodes: AutomationConditionTraceNode[] = []
     let steps: AutomationStepTrace[] = []
     try {
-      const evaluation = evaluateConditionTree(CONDITIONS, mirror, Date.now())
+      const firedLeaf = trigger['leaf']
+      const evaluation = evaluateWhenTree(WHEN, mirror, Date.now(), {
+        ...(typeof firedLeaf === 'string' ? { firedPath: firedLeaf } : {}),
+      })
       nodes = [...evaluation.nodes]
       for (const node of nodes) {
-        if (node.kind === 'condition' && node.observed === null && node.deviceId !== undefined) {
+        if (node.kind === 'device-is' && node.observed === null && node.deviceId !== undefined) {
           ctx.logger.warn('condition leaf value unknown — treated as false', {
             tags: { deviceId: node.deviceId },
             path: node.path,
@@ -9775,7 +10722,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
       }
       if (!evaluation.pass) {
         outcome = 'skipped-conditions'
-        ctx.logger.debug('automation did not run — conditions were false', { trigger, ...deviceTags(trigger) })
+        ctx.logger.debug('automation did not run — the rule tree was false at that instant', { trigger, ...deviceTags(trigger) })
         return
       }
       const letThrough = stampUnknown && RUN_MODE.mode === 'cooldown'
@@ -9874,9 +10821,30 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
   const ready: Promise<void> = (async () => {
     await loadState()
     await refreshMirror()
+    stateWatching = true
+    evaluateStateTree()
   })()
 
-  if (CONDITIONS !== undefined) {
+  /**
+   * Rule 2 — a tree of states only. It fires when the tree goes false → true.
+   * The FIRST evaluation only seeds \`treeWasTrue\` (a tree that is already true
+   * when the hub or runner starts must not fire), and an evaluation that read an
+   * unknown value neither seeds nor moves it: unknown is not false.
+   */
+  let treeWasTrue: boolean | undefined
+  let stateWatching = false
+  function evaluateStateTree(): void {
+    if (!STATE_ONLY || !stateWatching || stopped) return
+    const evaluation = evaluateWhenTree(WHEN, mirror, Date.now())
+    if (evaluation.unknown) return
+    const was = treeWasTrue
+    treeWasTrue = evaluation.pass
+    if (was === false && evaluation.pass) {
+      void run({ kind: 'state', leaf: 'when', at: Date.now() }, 'the rules became true', true)
+    }
+  }
+
+  if (MIRROR_SOURCES.length > 0) {
     disposers.push(
       ctx.eventBus.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
         const data = event.data
@@ -9884,14 +10852,17 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
         const capName = data['capName']
         if (typeof deviceId === 'number' && typeof capName === 'string') {
           mirror.apply(deviceId, capName, data['slice'])
+          evaluateStateTree()
         }
       }),
     )
-    const mirrorReconcile = setInterval(() => { void refreshMirror() }, RECONCILE_MS)
+    const mirrorReconcile = setInterval(() => {
+      void refreshMirror().then(evaluateStateTree)
+    }, RECONCILE_MS)
     disposers.push(() => clearInterval(mirrorReconcile))
   }
 
-${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
+${eventLeaves.map(({ leaf, path }) => emitLeaf(leaf, path)).join("\n\n")}
 
   return () => {
     stopped = true
@@ -9907,494 +10878,6 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
 `;
 }
 //#endregion
-//#region src/catalogs/coco-classmap.ts
-var COCO_80_LABELS = [
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "bicycle",
-		name: "Bicycle"
-	},
-	{
-		id: "car",
-		name: "Car"
-	},
-	{
-		id: "motorcycle",
-		name: "Motorcycle"
-	},
-	{
-		id: "airplane",
-		name: "Airplane"
-	},
-	{
-		id: "bus",
-		name: "Bus"
-	},
-	{
-		id: "train",
-		name: "Train"
-	},
-	{
-		id: "truck",
-		name: "Truck"
-	},
-	{
-		id: "boat",
-		name: "Boat"
-	},
-	{
-		id: "traffic light",
-		name: "Traffic Light"
-	},
-	{
-		id: "fire hydrant",
-		name: "Fire Hydrant"
-	},
-	{
-		id: "stop sign",
-		name: "Stop Sign"
-	},
-	{
-		id: "parking meter",
-		name: "Parking Meter"
-	},
-	{
-		id: "bench",
-		name: "Bench"
-	},
-	{
-		id: "bird",
-		name: "Bird"
-	},
-	{
-		id: "cat",
-		name: "Cat"
-	},
-	{
-		id: "dog",
-		name: "Dog"
-	},
-	{
-		id: "horse",
-		name: "Horse"
-	},
-	{
-		id: "sheep",
-		name: "Sheep"
-	},
-	{
-		id: "cow",
-		name: "Cow"
-	},
-	{
-		id: "elephant",
-		name: "Elephant"
-	},
-	{
-		id: "bear",
-		name: "Bear"
-	},
-	{
-		id: "zebra",
-		name: "Zebra"
-	},
-	{
-		id: "giraffe",
-		name: "Giraffe"
-	},
-	{
-		id: "backpack",
-		name: "Backpack"
-	},
-	{
-		id: "umbrella",
-		name: "Umbrella"
-	},
-	{
-		id: "handbag",
-		name: "Handbag"
-	},
-	{
-		id: "tie",
-		name: "Tie"
-	},
-	{
-		id: "suitcase",
-		name: "Suitcase"
-	},
-	{
-		id: "frisbee",
-		name: "Frisbee"
-	},
-	{
-		id: "skis",
-		name: "Skis"
-	},
-	{
-		id: "snowboard",
-		name: "Snowboard"
-	},
-	{
-		id: "sports ball",
-		name: "Sports Ball"
-	},
-	{
-		id: "kite",
-		name: "Kite"
-	},
-	{
-		id: "baseball bat",
-		name: "Baseball Bat"
-	},
-	{
-		id: "baseball glove",
-		name: "Baseball Glove"
-	},
-	{
-		id: "skateboard",
-		name: "Skateboard"
-	},
-	{
-		id: "surfboard",
-		name: "Surfboard"
-	},
-	{
-		id: "tennis racket",
-		name: "Tennis Racket"
-	},
-	{
-		id: "bottle",
-		name: "Bottle"
-	},
-	{
-		id: "wine glass",
-		name: "Wine Glass"
-	},
-	{
-		id: "cup",
-		name: "Cup"
-	},
-	{
-		id: "fork",
-		name: "Fork"
-	},
-	{
-		id: "knife",
-		name: "Knife"
-	},
-	{
-		id: "spoon",
-		name: "Spoon"
-	},
-	{
-		id: "bowl",
-		name: "Bowl"
-	},
-	{
-		id: "banana",
-		name: "Banana"
-	},
-	{
-		id: "apple",
-		name: "Apple"
-	},
-	{
-		id: "sandwich",
-		name: "Sandwich"
-	},
-	{
-		id: "orange",
-		name: "Orange"
-	},
-	{
-		id: "broccoli",
-		name: "Broccoli"
-	},
-	{
-		id: "carrot",
-		name: "Carrot"
-	},
-	{
-		id: "hot dog",
-		name: "Hot Dog"
-	},
-	{
-		id: "pizza",
-		name: "Pizza"
-	},
-	{
-		id: "donut",
-		name: "Donut"
-	},
-	{
-		id: "cake",
-		name: "Cake"
-	},
-	{
-		id: "chair",
-		name: "Chair"
-	},
-	{
-		id: "couch",
-		name: "Couch"
-	},
-	{
-		id: "potted plant",
-		name: "Potted Plant"
-	},
-	{
-		id: "bed",
-		name: "Bed"
-	},
-	{
-		id: "dining table",
-		name: "Dining Table"
-	},
-	{
-		id: "toilet",
-		name: "Toilet"
-	},
-	{
-		id: "tv",
-		name: "TV"
-	},
-	{
-		id: "laptop",
-		name: "Laptop"
-	},
-	{
-		id: "mouse",
-		name: "Mouse"
-	},
-	{
-		id: "remote",
-		name: "Remote"
-	},
-	{
-		id: "keyboard",
-		name: "Keyboard"
-	},
-	{
-		id: "cell phone",
-		name: "Cell Phone"
-	},
-	{
-		id: "microwave",
-		name: "Microwave"
-	},
-	{
-		id: "oven",
-		name: "Oven"
-	},
-	{
-		id: "toaster",
-		name: "Toaster"
-	},
-	{
-		id: "sink",
-		name: "Sink"
-	},
-	{
-		id: "refrigerator",
-		name: "Refrigerator"
-	},
-	{
-		id: "book",
-		name: "Book"
-	},
-	{
-		id: "clock",
-		name: "Clock"
-	},
-	{
-		id: "vase",
-		name: "Vase"
-	},
-	{
-		id: "scissors",
-		name: "Scissors"
-	},
-	{
-		id: "teddy bear",
-		name: "Teddy Bear"
-	},
-	{
-		id: "hair drier",
-		name: "Hair Drier"
-	},
-	{
-		id: "toothbrush",
-		name: "Toothbrush"
-	}
-];
-var MACRO_LABELS = [
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-];
-/**
-* The class names a per-class COUNT can ever be keyed on — the macro ids, and
-* only those.
-*
-* `preserveOriginal: false` below is the whole reason this set exists: the
-* executor maps each raw COCO label onto its macro and DROPS everything else,
-* so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
-* Any surface that indexes counts by class name — the ZoneAnalytics occupancy
-* snapshot's `byClass`, and therefore every occupancy rule — can match nothing
-* else. Derived from the catalog, never hand-listed, so a new macro joins it by
-* being declared once.
-*
-* Cost of not having it, 2026-08-12: the notification rule editor offered the
-* full taxonomy for an occupancy class (occupancy is the one condition that
-* does not go through the engine's macro-expanding `expandClassSelector`), two
-* live rules were authored on `car`, and both counters read 0 forever.
-*/
-var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
-/** True when `className` is a macro the detector can actually emit (and hence a
-*  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
-function isDetectionMacroClass(className) {
-	return DETECTION_MACRO_CLASSES.has(className.trim().toLowerCase());
-}
-var COCO_TO_MACRO = {
-	mapping: {
-		person: "person",
-		bicycle: "vehicle",
-		car: "vehicle",
-		motorcycle: "vehicle",
-		airplane: "vehicle",
-		bus: "vehicle",
-		train: "vehicle",
-		truck: "vehicle",
-		boat: "vehicle",
-		bird: "animal",
-		cat: "animal",
-		dog: "animal",
-		horse: "animal",
-		sheep: "animal",
-		cow: "animal",
-		elephant: "animal",
-		bear: "animal",
-		zebra: "animal",
-		giraffe: "animal",
-		suitcase: "package",
-		backpack: "package",
-		handbag: "package"
-	},
-	preserveOriginal: false
-};
-var MACRO_NAMES = new Set(Object.values(COCO_TO_MACRO.mapping));
-function macroOf(className) {
-	return COCO_TO_MACRO.mapping[className] ?? className;
-}
-/** `animal` matches a dog; `dog` matches only a dog (a cat is also an animal). */
-function detectionClassMatches(wanted, actual) {
-	const w = wanted.toLowerCase();
-	const a = actual.toLowerCase();
-	if (w === a) return true;
-	return MACRO_NAMES.has(w) && macroOf(a) === w;
-}
-function isPhase$1(value) {
-	return value === "start" || value === "update" || value === "end";
-}
-var DetectionTriggerFilter = class {
-	trigger;
-	/** `${deviceId}|${trackId}` → fired at. Insertion-ordered, so the oldest is first. */
-	fired = /* @__PURE__ */ new Map();
-	constructor(trigger) {
-		this.trigger = trigger;
-	}
-	get firedCount() {
-		return this.fired.size;
-	}
-	evaluate(event, now) {
-		const { deviceId, trackId, phase } = event;
-		if (typeof deviceId !== "number" || typeof trackId !== "string" || !isPhase$1(phase)) return {
-			kind: "ignore",
-			why: "malformed track-lifecycle event"
-		};
-		if (!this.trigger.deviceIds.includes(deviceId)) return {
-			kind: "ignore",
-			why: `device ${deviceId} is not one of the trigger's devices`
-		};
-		const key = `${deviceId}|${trackId}`;
-		if (phase === "end") {
-			this.fired.delete(key);
-			return {
-				kind: "ignore",
-				why: "track ended"
-			};
-		}
-		this.expire(now);
-		const className = typeof event.bestClassName === "string" ? event.bestClassName : "";
-		const score = typeof event.bestConfidence === "number" ? event.bestConfidence : 0;
-		const vars = {
-			deviceId,
-			className,
-			trackId,
-			score
-		};
-		if (this.fired.has(key)) return {
-			kind: "reject",
-			reason: `already fired for track ${trackId}`,
-			vars
-		};
-		if (!this.trigger.classes.some((c) => detectionClassMatches(c, className))) return {
-			kind: "reject",
-			reason: `class ${className || "unknown"} not in [${this.trigger.classes.join(", ")}]`,
-			vars
-		};
-		if (this.trigger.minScore !== void 0 && score < this.trigger.minScore) return {
-			kind: "reject",
-			reason: `score ${score} < ${this.trigger.minScore}`,
-			vars
-		};
-		if (this.trigger.zones !== void 0) {
-			const visited = Array.isArray(event.zonesVisited) ? event.zonesVisited.filter((z) => typeof z === "string") : [];
-			if (!this.trigger.zones.some((z) => visited.includes(z))) return {
-				kind: "reject",
-				reason: `zone mismatch: visited [${visited.join(", ")}], wanted [${this.trigger.zones.join(", ")}]`,
-				vars
-			};
-		}
-		this.remember(key, now);
-		return {
-			kind: "fire",
-			reason: `${className} ${score} on device ${deviceId}`,
-			vars
-		};
-	}
-	remember(key, now) {
-		this.fired.set(key, now);
-		while (this.fired.size > 512) {
-			const oldest = this.fired.keys().next();
-			if (oldest.done === true) break;
-			this.fired.delete(oldest.value);
-		}
-	}
-	expire(now) {
-		for (const [key, at] of this.fired) {
-			if (now - at < 9e5) break;
-			this.fired.delete(key);
-		}
-	}
-};
-//#endregion
 //#region src/automation/condition-eval.ts
 /**
 * Evaluating an automation's condition tree against the ConditionMirror.
@@ -10421,7 +10904,7 @@ function collectInto(cond, out) {
 		case "not":
 			collectInto(cond.child, out);
 			return;
-		case "condition":
+		case "device-is":
 			out.push({
 				kind: "device",
 				deviceId: cond.deviceId,
@@ -10442,10 +10925,11 @@ function collectInto(cond, out) {
 				cap: binding.cap
 			});
 			return;
+		default: return;
 	}
 }
-/** Every (device, cap) a tree reads, deduplicated. */
-function collectMirrorSources(cond) {
+/** Every (device, cap) a `when` tree's STATE leaves read, deduplicated. */
+function collectWhenMirrorSources(cond) {
 	if (cond === void 0) return [];
 	const all = [];
 	collectInto(cond, all);
@@ -10457,6 +10941,10 @@ function collectMirrorSources(cond) {
 		return true;
 	});
 }
+/** Legacy name, for blocks generated before the single tree: an old condition tree. */
+function collectMirrorSources(cond) {
+	return collectWhenMirrorSources(cond === void 0 ? void 0 : convertLegacyCondition(cond));
+}
 function sliceKey(deviceId, cap) {
 	return `${deviceId}|${cap}`;
 }
@@ -10610,7 +11098,8 @@ function zonesOfParked(zones, parkedId) {
 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`
+		why: `device ${cond.deviceId} occupancy snapshot unknown`,
+		unknown: true
 	};
 	const parked = parkedObjectsOf(reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "stationaryObjects"));
 	if (parked.length === 0) return {
@@ -10619,7 +11108,7 @@ function judgeStationaryPresent(cond, reader) {
 	};
 	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.subjects !== void 0 && !anySubjectMatches(cond.subjects, { className: obj.className }).matches) continue;
 		if (cond.zones !== void 0) {
 			const inZones = zonesOfParked(zones, obj.id);
 			if (!cond.zones.some((z) => inZones.includes(z))) continue;
@@ -10634,9 +11123,20 @@ function judgeStationaryPresent(cond, reader) {
 		why: `${parked.length} parked on device ${cond.deviceId}, none matching the class/zone filter`
 	};
 }
-function evalNode(cond, path, reader, now, out) {
+function evalEventLeaf(cond, path, state, out) {
+	const occurred = state.firedPath === path;
+	out.push({
+		path,
+		kind: cond.kind,
+		outcome: occurred ? "pass" : "fail",
+		reason: occurred ? `${cond.kind} occurred → pass` : `${cond.kind} is an instant and did not occur now → fail`
+	});
+	return occurred;
+}
+function evalNode(cond, path, reader, now, out, state) {
+	if (isEventLeaf(cond)) return evalEventLeaf(cond, path, state, out);
 	switch (cond.kind) {
-		case "condition": {
+		case "device-is": {
 			const observed = reader.read(cond.deviceId, cond.cap, cond.fieldPath);
 			const base = {
 				path,
@@ -10657,6 +11157,7 @@ function evalNode(cond, path, reader, now, out) {
 				return false;
 			}
 			if (observed === void 0) {
+				state.unknown = true;
 				out.push({
 					...base,
 					outcome: "fail",
@@ -10674,6 +11175,7 @@ function evalNode(cond, path, reader, now, out) {
 		}
 		case "stationary-present": {
 			const verdict = judgeStationaryPresent(cond, reader);
+			if (verdict.unknown === true) state.unknown = true;
 			out.push({
 				path,
 				kind: cond.kind,
@@ -10699,6 +11201,7 @@ function evalNode(cond, path, reader, now, out) {
 						outcome: "fail",
 						reason: `${alias} value unknown → fail`
 					});
+					state.unknown = true;
 					return false;
 				}
 				values[alias] = require_composition.toExpressionValue(raw) ?? null;
@@ -10730,7 +11233,7 @@ function evalNode(cond, path, reader, now, out) {
 				outcome: "not-evaluated",
 				reason: ""
 			});
-			const inner = evalNode(cond.child, `${path}.0`, reader, now, out);
+			const inner = evalNode(cond.child, `${path}.0`, reader, now, out, state);
 			const ok = !inner;
 			out.splice(at, 1, {
 				path,
@@ -10758,7 +11261,7 @@ function evalNode(cond, path, reader, now, out) {
 					markSkipped(child, `${path}.${i}`, `short-circuited by ${path}.${decided}`, out);
 					continue;
 				}
-				const ok = evalNode(child, `${path}.${i}`, reader, now, out);
+				const ok = evalNode(child, `${path}.${i}`, reader, now, out, state);
 				if (isAll ? !ok : ok) decided = i;
 			}
 			const ok = isAll ? decided === null : decided !== null;
@@ -10773,20 +11276,167 @@ function evalNode(cond, path, reader, now, out) {
 		}
 	}
 }
-/** No condition tree is a pass with no nodes. */
+/** Evaluate a `when` tree: the fired event leaf is true, every other event leaf false. */
+function evaluateWhenTree(when, reader, now, options = {}) {
+	const nodes = [];
+	const state = {
+		firedPath: options.firedPath,
+		unknown: false
+	};
+	return {
+		pass: evalNode(when, options.rootPath ?? "when", reader, now, nodes, state),
+		unknown: state.unknown,
+		nodes
+	};
+}
+/** Legacy name, for blocks generated before the single tree. No tree is a pass with no nodes. */
 function evaluateConditionTree(cond, reader, now) {
 	if (cond === void 0) return {
 		pass: true,
+		unknown: false,
 		nodes: []
 	};
-	const nodes = [];
-	return {
-		pass: evalNode(cond, "conditions", reader, now, nodes),
-		nodes
-	};
+	return evaluateWhenTree(convertLegacyCondition(cond), reader, now, { rootPath: "conditions" });
 }
 //#endregion
+//#region src/automation/detection-trigger.ts
+/**
+* The `detection` trigger's per-event decision: does this track-lifecycle
+* event start a run, and if not, WHY not.
+*
+* Source: `EventCategory.PipelineAnalyticsTrackLifecycle` — payload
+* {@link PipelineAnalyticsTrackLifecyclePayload} (`deviceId`, `trackId`,
+* `phase` start|update|end, `bestClassName`, `bestConfidence`,
+* `zonesVisited`). The event carries the device in its DATA, not on its
+* `source`, so the filter reads `data.deviceId`.
+*
+* ONE fire per `(deviceId, trackId)`: a track fires the first time it satisfies
+* the subject, score and zone conditions (which may be on an `update`, once its
+* best confidence has risen, or once its face or plate has been resolved — D683
+* decides identity late, so a leaf with a label fires on the update that
+* carries it, never on the first detection), and never again. The fired set is bounded and
+* forgets a track on its `end` or after {@link FIRED_TTL_MS}, so a track whose
+* `end` was dropped (events are telemetry, D8) cannot pin memory.
+*/
+/** The subjects a trigger asks for, whichever shape it has. */
+function subjectsOf(trigger) {
+	return "subjects" in trigger ? trigger.subjects : trigger.classes.map(subjectFromClassName);
+}
+var MACRO_NAMES = new Set(Object.values(COCO_TO_MACRO.mapping));
+function macroOf(className) {
+	return COCO_TO_MACRO.mapping[className] ?? className;
+}
+/** `animal` matches a dog; `dog` matches only a dog (a cat is also an animal). */
+function detectionClassMatches(wanted, actual) {
+	const w = wanted.toLowerCase();
+	const a = actual.toLowerCase();
+	if (w === a) return true;
+	return MACRO_NAMES.has(w) && macroOf(a) === w;
+}
+function isPhase$1(value) {
+	return value === "start" || value === "update" || value === "end";
+}
+var DetectionTriggerFilter = class {
+	trigger;
+	/** `${deviceId}|${trackId}` → fired at. Insertion-ordered, so the oldest is first. */
+	fired = /* @__PURE__ */ new Map();
+	subjects;
+	constructor(trigger) {
+		this.trigger = trigger;
+		this.subjects = subjectsOf(trigger);
+	}
+	get firedCount() {
+		return this.fired.size;
+	}
+	evaluate(event, now) {
+		const { deviceId, trackId, phase } = event;
+		if (typeof deviceId !== "number" || typeof trackId !== "string" || !isPhase$1(phase)) return {
+			kind: "ignore",
+			why: "malformed track-lifecycle event"
+		};
+		if (!this.trigger.deviceIds.includes(deviceId)) return {
+			kind: "ignore",
+			why: `device ${deviceId} is not one of the trigger's devices`
+		};
+		const key = `${deviceId}|${trackId}`;
+		if (phase === "end") {
+			this.fired.delete(key);
+			return {
+				kind: "ignore",
+				why: "track ended"
+			};
+		}
+		this.expire(now);
+		const className = typeof event.bestClassName === "string" ? event.bestClassName : "";
+		const score = typeof event.bestConfidence === "number" ? event.bestConfidence : 0;
+		const vars = {
+			deviceId,
+			className,
+			trackId,
+			score,
+			label: ""
+		};
+		if (this.fired.has(key)) return {
+			kind: "reject",
+			reason: `already fired for track ${trackId}`,
+			vars
+		};
+		const verdict = anySubjectMatches(this.subjects, {
+			className,
+			...Array.isArray(event.classes) ? { classes: event.classes.filter((c) => typeof c === "string") } : {},
+			...typeof event.label === "string" ? { label: event.label } : {},
+			...typeof event.identityId === "string" ? { identityId: event.identityId } : {},
+			...typeof event.plateText === "string" ? { plateText: event.plateText } : {}
+		});
+		if (!verdict.matches) return {
+			kind: "reject",
+			reason: verdict.reason,
+			vars
+		};
+		const matched = {
+			...vars,
+			label: verdict.label
+		};
+		if (this.trigger.minScore !== void 0 && score < this.trigger.minScore) return {
+			kind: "reject",
+			reason: `score ${score} < ${this.trigger.minScore}`,
+			vars: matched
+		};
+		if (this.trigger.zones !== void 0) {
+			const visited = Array.isArray(event.zonesVisited) ? event.zonesVisited.filter((z) => typeof z === "string") : [];
+			if (!this.trigger.zones.some((z) => visited.includes(z))) return {
+				kind: "reject",
+				reason: `zone mismatch: visited [${visited.join(", ")}], wanted [${this.trigger.zones.join(", ")}]`,
+				vars: matched
+			};
+		}
+		this.remember(key, now);
+		return {
+			kind: "fire",
+			reason: `${verdict.label === "" ? className : verdict.label} ${score} on device ${deviceId}`,
+			vars: matched
+		};
+	}
+	remember(key, now) {
+		this.fired.set(key, now);
+		while (this.fired.size > 512) {
+			const oldest = this.fired.keys().next();
+			if (oldest.done === true) break;
+			this.fired.delete(oldest.value);
+		}
+	}
+	expire(now) {
+		for (const [key, at] of this.fired) {
+			if (now - at < 9e5) break;
+			this.fired.delete(key);
+		}
+	}
+};
+//#endregion
 //#region src/automation/stationary-trigger.ts
+function isLegacyStationary(trigger) {
+	return "classes" in trigger;
+}
 function isPhase(value) {
 	return value === "appeared" || value === "departed";
 }
@@ -10813,11 +11463,15 @@ function evaluateStationaryTrigger(trigger, event) {
 		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
-	};
+	const subjects = isLegacyStationary(trigger) ? trigger.classes?.map(subjectFromClassName) : trigger.subjects;
+	if (subjects !== void 0) {
+		const verdict = anySubjectMatches(subjects, { className });
+		if (!verdict.matches) return {
+			kind: "reject",
+			reason: verdict.reason,
+			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(", ")}]`,
@@ -10956,11 +11610,12 @@ var RunGate = class {
 * Run traces — what an automation (or, later, an Action run) DID, node by node,
 * so the editor can paint every block green or red with its reason.
 *
-* A trace is data, not a log: it covers the WHOLE tree — the trigger stage,
-* every condition node (containers and leaves, including the ones a
-* short-circuit never reached), the run-mode verdict and every action step —
-* each addressed by a stable path (`conditions.0.1`, `actions.2`, or `steps.N`
-* for an Action run). Skipped
+* A trace is data, not a log: it covers the WHOLE tree — the event leaf that
+* fired, every node of the `when` tree (containers and leaves, including the
+* ones a short-circuit never reached), the run-mode verdict and every action
+* step — each addressed by a stable path (`when.0.1`, `actions.2`, or `steps.N`
+* for an Action run). Traces written before the single tree carry
+* `conditions.*` paths and still parse. Skipped
 * evaluations are traced too, and identical consecutive skips collapse into a
 * repeat count so a trigger that fails every 5 minutes cannot flush real runs.
 *
@@ -10992,6 +11647,8 @@ var TraceNodeOutcomeSchema = zod.z.enum([
 ]);
 var AutomationTriggerTraceSchema = zod.z.object({
 	kind: zod.z.string().min(1),
+	/** The event leaf that fired (`when`, `when.0.1`); absent on traces written before the single tree. */
+	path: zod.z.string().min(1).optional(),
 	outcome: zod.z.enum(["pass", "fail"]),
 	/** Why an event was rejected ("class person not in [dog]") or what fired. */
 	reason: zod.z.string(),
@@ -10999,15 +11656,23 @@ var AutomationTriggerTraceSchema = zod.z.object({
 	vars: zod.z.record(zod.z.string(), TraceValueSchema)
 });
 var AutomationConditionTraceNodeSchema = zod.z.object({
-	/** `conditions` for the root, `conditions.<i>` for its i-th child, … */
+	/** `when` for the root, `when.<i>` for its i-th child, … (`conditions…` on an old trace). */
 	path: zod.z.string().min(1),
 	kind: zod.z.enum([
 		"all",
 		"any",
 		"not",
 		"condition",
+		"device-is",
 		"expression",
-		"stationary-present"
+		"stationary-present",
+		"device-becomes",
+		"device-event",
+		"schedule",
+		"interval",
+		"manual",
+		"detection",
+		"stationary"
 	]),
 	outcome: TraceNodeOutcomeSchema,
 	reason: zod.z.string(),
@@ -11041,6 +11706,12 @@ var AutomationStepTraceSchema = zod.z.object({
 	deviceId: zod.z.number().int().optional(),
 	startedAt: zod.z.number().optional(),
 	endedAt: zod.z.number().optional(),
+	/**
+	* The parameters the step SENT, after `{{vars.x}}` substitution — what the
+	* device was actually asked. Bounded like trigger `vars`; a secret parameter
+	* is shown as {@link REDACTED_ARG}. Absent on traces written before it existed.
+	*/
+	args: zod.z.record(zod.z.string(), TraceValueSchema).optional(),
 	outcome: zod.z.enum([
 		"ok",
 		"error",
@@ -11132,20 +11803,53 @@ function appendTrace(ring, trace, keep) {
 	}
 	return next;
 }
+/** What a secret parameter is shown as in a trace. */
+var REDACTED_ARG = "[redacted]";
+/** Parameters kept per step trace; the rest are counted in `…`. */
+var MAX_TRACE_ARGS = 32;
+/** A string value is cut here. */
+var MAX_TRACE_ARG_LENGTH = 200;
+/** A parameter whose NAME says it is a credential. */
+var SECRET_ARG_NAME = /pass(word|phrase|code)?|secret|token|api[-_]?key|credential|\bpin\b|auth/i;
+function isSecretArg(name, value) {
+	return SECRET_ARG_NAME.test(name) || require_sleep.isSecretMarkerLike(value);
+}
+/**
+* The parameters a step sent, as a trace may show them: primitives and short
+* lists of them (anything deeper is its JSON text, cut), at most
+* {@link MAX_TRACE_ARGS} of them. No cap method declares a parameter secret, so
+* a parameter is redacted by what it is called or by being a keychain marker,
+* and `secretKeys` names the ones a caller knows about.
+*/
+function buildStepArgsTrace(args, secretKeys = []) {
+	const out = {};
+	for (const [key, value] of Object.entries(args).slice(0, 32)) if (secretKeys.includes(key) || isSecretArg(key, value)) out[key] = REDACTED_ARG;
+	else if (typeof value === "string") out[key] = value.length > 200 ? `${value.slice(0, 200)}…` : value;
+	else if (typeof value === "number" || typeof value === "boolean" || value === null) out[key] = value;
+	else if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) out[key] = value;
+	else if (value !== void 0) {
+		const text = JSON.stringify(value) ?? "";
+		out[key] = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+	}
+	return out;
+}
 /**
 * The trigger stage of a trace from the bag a trigger handed to `run()`:
 * primitives and short lists of them (a device-state `to` that is an object is left out), minus the
-* bookkeeping keys `kind` and `at`.
+* bookkeeping keys `kind`, `at` and `leaf` (the fired leaf's path, which moves to `path`).
 */
 function buildTriggerTrace(trigger, outcome, reason) {
 	const vars = {};
 	for (const [key, value] of Object.entries(trigger)) {
-		if (key === "kind" || key === "at") continue;
+		if (key === "kind" || key === "at" || key === "leaf") 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;
 	}
+	const kind = typeof trigger["kind"] === "string" ? trigger["kind"] : "unknown";
+	const path = typeof trigger["leaf"] === "string" ? trigger["leaf"] : void 0;
 	return {
-		kind: typeof trigger["kind"] === "string" ? trigger["kind"] : "unknown",
+		kind,
+		...path === void 0 ? {} : { path },
 		outcome,
 		reason,
 		vars
@@ -11383,14 +12087,22 @@ async function runSteps(steps, options) {
 		}
 		const startedAt = options.now();
 		let deviceId = step.meta.deviceId;
-		const scope = { setDeviceId: (id) => {
-			deviceId = id;
-		} };
+		let sent;
+		const scope = {
+			setDeviceId: (id) => {
+				deviceId = id;
+			},
+			setArgs: (args) => {
+				sent = args;
+			}
+		};
+		const argsTrace = () => sent === void 0 ? {} : { args: buildStepArgsTrace(sent) };
 		try {
 			await step.run(scope);
 			traces.push({
 				...step.meta,
 				...deviceId === void 0 ? {} : { deviceId },
+				...argsTrace(),
 				path,
 				startedAt,
 				endedAt: options.now(),
@@ -11408,6 +12120,7 @@ async function runSteps(steps, options) {
 			traces.push({
 				...step.meta,
 				...deviceId === void 0 ? {} : { deviceId },
+				...argsTrace(),
 				path,
 				startedAt,
 				endedAt: options.now(),
@@ -11494,6 +12207,7 @@ function buildActionSteps(steps, vars, deps) {
 				const targets = typeof step.deviceId === "number" ? [step.deviceId] : Array.isArray(step.deviceId) ? step.deviceId : [resolveDeviceTarget(vars, step.deviceId.$var)];
 				for (const deviceId of targets) {
 					scope.setDeviceId(deviceId);
+					scope.setArgs(args);
 					await deps.invokeCap({
 						deviceId,
 						cap: step.cap,
@@ -11633,9 +12347,9 @@ function normalizeLeaf(leaf, resolver, path) {
 	};
 }
 /** Normalise every leaf of a condition tree. Throws {@link QuantityUnitError}. */
-function normalizeConditionUnits(condition, resolver, path = "conditions") {
+function normalizeConditionUnits(condition, resolver, path = "when") {
 	switch (condition.kind) {
-		case "condition": {
+		case "device-is": {
 			const { leaf, warnings } = normalizeLeaf(condition, resolver, path);
 			return {
 				value: leaf,
@@ -11728,17 +12442,17 @@ function normalizeActionUnits(actions, resolver, path = "steps") {
 		warnings
 	};
 }
-/** Normalise a whole recipe: its condition tree and its actions. */
+/** Normalise a whole recipe: its `when` tree and its actions. */
 function normalizeRecipeUnits(recipe, resolver) {
-	const conditions = recipe.conditions === void 0 ? void 0 : normalizeConditionUnits(recipe.conditions, resolver, "conditions");
+	const when = normalizeConditionUnits(recipe.when, resolver, "when");
 	const actions = normalizeActionUnits(recipe.actions, resolver, "actions");
 	return {
 		value: {
 			...recipe,
-			...conditions === void 0 ? {} : { conditions: conditions.value },
+			when: when.value,
 			actions: actions.value
 		},
-		warnings: [...conditions?.warnings ?? [], ...actions.warnings]
+		warnings: [...when.warnings, ...actions.warnings]
 	};
 }
 //#endregion
@@ -11761,7 +12475,7 @@ function normalizeRecipeUnits(recipe, resolver) {
 */
 function stampCondition(condition, resolver) {
 	switch (condition.kind) {
-		case "condition": {
+		case "device-is": {
 			if (typeof condition.value !== "number" || condition.unit !== void 0) return condition;
 			const quantity = resolver.fieldQuantity(condition.cap, condition.fieldPath);
 			if (quantity === void 0 || unitsForQuantity(quantity).length < 2) return condition;
@@ -11804,7 +12518,7 @@ function stampAction(action, resolver) {
 function prepareRecipeUnits(recipe, resolver) {
 	const stamped = {
 		...recipe,
-		...recipe.conditions === void 0 ? {} : { conditions: stampCondition(recipe.conditions, resolver) },
+		when: stampCondition(recipe.when, resolver),
 		actions: recipe.actions.map((action) => stampAction(action, resolver))
 	};
 	try {
@@ -12609,6 +13323,25 @@ var addonSettingsCapability = {
 			addonId: zod.z.string(),
 			nodeId: zod.z.string().optional()
 		}), SettingsSchemaWithValuesSchema.nullable()),
+		getDeclaredSettingsKeys: require_sleep.method(zod.z.object({
+			addonId: zod.z.string(),
+			nodeId: zod.z.string().optional()
+		}), zod.z.object({ keys: zod.z.array(zod.z.string()) }).nullable(), { auth: "admin" }),
+		unsetStoredSettingsKeys: require_sleep.method(zod.z.object({
+			addonId: zod.z.string(),
+			nodeId: zod.z.string().optional(),
+			keys: zod.z.array(zod.z.string())
+		}), zod.z.object({
+			removed: zod.z.array(zod.z.string()),
+			refused: zod.z.array(zod.z.object({
+				key: zod.z.string(),
+				reason: zod.z.string()
+			})),
+			secretsCleared: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		getDeviceSettings: require_sleep.method(zod.z.object({
 			addonId: zod.z.string(),
 			deviceId: zod.z.number(),
@@ -20747,6 +21480,8 @@ var StorageKindSchema = zod.z.object({
 		"orphaned",
 		"dropped"
 	]),
+	/** An owner declared this kind since the engine started. */
+	declaredThisBoot: zod.z.boolean(),
 	/** `null` when the caller asked for no counts (`counts: false`). */
 	rows: zod.z.number().int().nonnegative().nullable(),
 	/** Rows x the average size of a sample; null for an empty kind. */
@@ -20758,6 +21493,51 @@ var StorageKindSchema = zod.z.object({
 	/** The whole declaration, secret paths and entry descriptor included (the entries service builds its handle from it). */
 	declaration: require_sleep.RecordKindDeclarationSchema
 });
+zod.z.enum([
+	"orphaned",
+	"stale",
+	"unknown"
+]);
+/** A record kind nobody declared since its owner started, or whose owner is gone. */
+var StaleKindFindingSchema = zod.z.object({
+	owner: zod.z.string(),
+	kind: zod.z.string(),
+	/** `unknown`: the owner could not be judged (not running, or its state unreadable) - never dropped. */
+	verdict: zod.z.enum(["orphaned", "unknown"]),
+	reason: zod.z.string(),
+	rows: zod.z.number().int().nonnegative().nullable(),
+	/** local-auth's tables are never dropped by this audit. */
+	protected: zod.z.boolean()
+});
+/** A stored global-settings key the running addon no longer declares. */
+var StaleSettingsKeyFindingSchema = zod.z.object({
+	addonId: zod.z.string(),
+	/** The stored key as written, a per-node `<key>@<nodeId>` suffix included. */
+	key: zod.z.string(),
+	/**
+	* Keychain refs whose ONLY marker sits under this key: in use by stale data,
+	* not orphans yet. Removing the key releases them.
+	*/
+	secretRefs: zod.z.array(zod.z.string())
+});
+/** An addon the audit could not judge, with the reason. Never reported as stale. */
+var StaleUnknownSchema = zod.z.object({
+	subject: zod.z.string(),
+	reason: zod.z.string()
+});
+var StaleDataReportSchema = zod.z.object({
+	/** Epoch ms of the last finished scan; `null` before the first. */
+	scannedAt: zod.z.number().nullable(),
+	scanning: zod.z.boolean(),
+	trigger: zod.z.enum([
+		"boot",
+		"interval",
+		"manual"
+	]).nullable(),
+	kinds: zod.z.array(StaleKindFindingSchema),
+	settingsKeys: zod.z.array(StaleSettingsKeyFindingSchema),
+	unknown: zod.z.array(StaleUnknownSchema)
+});
 /**
 * storage-admin - the operator's maintenance reach into the databases: list
 * their tables and record kinds, read a kind for diagnosis. Read-only: a table
@@ -20794,7 +21574,49 @@ var storageAdminCapability = {
 		readRecords: require_sleep.method(RecordQueryInputSchema.extend({
 			owner: zod.z.string().min(1),
 			kind: require_sleep.RecordKindNameSchema
-		}), RecordQueryResultSchema, { auth: "admin" })
+		}), RecordQueryResultSchema, { auth: "admin" }),
+		/**
+		* The last stale-data scan (read-only detection): record kinds left behind
+		* and settings keys no running addon declares. Held in memory; a scan runs
+		* at hub boot, every 24 h and on `scanStaleData`.
+		*/
+		staleDataReport: require_sleep.method(zod.z.object({}), StaleDataReportSchema, { auth: "admin" }),
+		/** Scan now. Detection only: it logs findings (owner and key, never values) and changes nothing. */
+		scanStaleData: require_sleep.method(zod.z.object({}), StaleDataReportSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Drop an ORPHANED kind: its rows, their keychain values, then mark it
+		* dropped. The verdict is re-checked at call time; anything not still
+		* orphaned (or a protected owner) is refused.
+		*/
+		dropOrphanedKind: require_sleep.method(zod.z.object({
+			owner: zod.z.string().min(1),
+			kind: require_sleep.RecordKindNameSchema
+		}), zod.z.object({
+			deleted: zod.z.number().int().nonnegative(),
+			secretsReleased: zod.z.number().int().nonnegative()
+		}), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		/**
+		* Unset one stale settings key on a running addon (an owner-side write that
+		* also clears the keychain values the key held). Re-checked at call time.
+		*/
+		unsetStaleSettingsKey: require_sleep.method(zod.z.object({
+			addonId: zod.z.string().min(1),
+			key: zod.z.string().min(1)
+		}), zod.z.object({
+			removed: zod.z.boolean(),
+			secretsCleared: zod.z.number().int().nonnegative()
+		}), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		})
 	}
 };
 //#endregion
@@ -20974,6 +21796,19 @@ var keychainCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Release the values rows of a DROPPED record kind held, whatever the kind's
+		* owner (stale-data audit). Reserved to `sqlite-settings`, the engine that
+		* just deleted the rows: only refs scoped `row/records:<kind>/...` are
+		* accepted, and the audit names the operator it acted for. Answers a count.
+		*/
+		releaseRecordRefs: require_sleep.method(zod.z.object({
+			refs: RefListSchema,
+			onBehalfOf: zod.z.string().min(1)
+		}), zod.z.object({ released: zod.z.number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** The caller's own refs, metadata only. */
 		listMeta: require_sleep.method(zod.z.object({}), zod.z.array(KeychainSecretMetaSchema).readonly(), { auth: "admin" }),
 		/** Whether values can be served — the save path refuses a write while locked. */
@@ -22294,7 +23129,9 @@ var DiscoveredChildDeviceSchema = zod.z.lazy(() => zod.z.object({
 	/** Upstream-system identity + rendering hints for the candidate. */
 	sourceInfo: SourceInfoSchema.optional(),
 	/** Nested entity-children for accordion preview — integrations populate, Hubs omit. */
-	children: zod.z.array(DiscoveredChildDeviceSchema).readonly().optional()
+	children: zod.z.array(DiscoveredChildDeviceSchema).readonly().optional(),
+	/** `childNativeId` of the gateway candidate in the same list this device sits behind. */
+	parentStableId: zod.z.string().optional()
 }));
 /**
 * Status block — populated by the integration after each
@@ -42900,6 +43737,79 @@ var DiscoveredDeviceSchema = zod.z.object({
 	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
 /**
+* HOW a provider can be found on the network. The provider only DECLARES the
+* mode; the `local-network` scan engine runs it once for every provider that
+* asked (one multicast browse, one host sweep) and hands the raw hits back to
+* `classifyDiscoveryHits`. A provider never opens a discovery socket itself,
+* except through a `custom` mode.
+*/
+var DiscoveryModeSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({
+		kind: zod.z.literal("mdns"),
+		/** DNS-SD service type, e.g. `_esphomelib._tcp`. */
+		serviceType: zod.z.string().min(1),
+		/** Regular expression an instance name must match (case-insensitive). */
+		instancePattern: zod.z.string().optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("ws-discovery"),
+		/** Probe types (e.g. `dn:NetworkVideoTransmitter`); omitted = any device. */
+		types: zod.z.array(zod.z.string()).optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("ssdp"),
+		searchTarget: zod.z.string().min(1)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("udp-broadcast"),
+		port: zod.z.number().int().min(1).max(65535),
+		payloadHex: zod.z.string().regex(/^([0-9a-fA-F]{2})*$/),
+		/** Port replies arrive on, when the device answers somewhere other than the source port. */
+		listenPort: zod.z.number().int().min(1).max(65535).optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("http-probe"),
+		port: zod.z.number().int().min(1).max(65535),
+		path: zod.z.string().startsWith("/"),
+		method: zod.z.enum(["GET", "POST"]).default("GET"),
+		bodyText: zod.z.string().optional(),
+		contentType: zod.z.string().optional(),
+		tls: zod.z.boolean().default(false),
+		/** Status codes that count as a hit. Omitted = any HTTP answer. */
+		acceptStatus: zod.z.array(zod.z.number().int()).optional()
+	}),
+	zod.z.object({
+		kind: zod.z.literal("custom"),
+		/** Why the engine cannot do it (an allowlisted exception, e.g. a vendor UDP protocol). */
+		reason: zod.z.string().min(1)
+	})
+]);
+/** What the engine saw on the wire for ONE declared mode; the provider classifies it. */
+var DiscoveryHitSchema = zod.z.object({
+	/** Index into the provider's own `getDiscoveryModes()` array. */
+	modeIndex: zod.z.number().int().min(0),
+	host: zod.z.string(),
+	port: zod.z.number().int(),
+	http: zod.z.object({
+		status: zod.z.number().int(),
+		headers: zod.z.record(zod.z.string(), zod.z.string()),
+		/** At most 16 KiB. */
+		bodyText: zod.z.string()
+	}).optional(),
+	mdns: zod.z.object({
+		instance: zod.z.string(),
+		host: zod.z.string(),
+		port: zod.z.number().int(),
+		txt: zod.z.record(zod.z.string(), zod.z.string())
+	}).optional(),
+	udp: zod.z.object({ payloadHex: zod.z.string() }).optional(),
+	wsd: zod.z.object({
+		xaddrs: zod.z.array(zod.z.string()),
+		types: zod.z.array(zod.z.string()),
+		scopes: zod.z.array(zod.z.string())
+	}).optional()
+});
+/**
 * Candidate handed back from discovery and accepted by
 * `adoptDiscoveredDevice`. Shape mirrors the in-process
 * `DiscoveredDevice` interface used by `DeviceDiscovery`.
@@ -42934,7 +43844,17 @@ var DiscoveryCandidateSchema = zod.z.object({
 	/** Numeric id of the device this candidate was matched to. Set with `alreadyOnboarded`. */
 	onboardedDeviceId: zod.z.number().optional(),
 	/** Operator-facing name of the matched device, so the UI can say WHICH one it is. */
-	onboardedName: zod.z.string().optional()
+	onboardedName: zod.z.string().optional(),
+	/**
+	* This candidate is an INTEGRATION to set up (a gateway, a hub, a controller),
+	* not a device to adopt. Replaces the `prefilledConfig.setupIntegration` marker,
+	* which is still read for one release.
+	*/
+	setupIntegration: zod.z.boolean().optional(),
+	/** `stableId` of the gateway candidate this device was found BEHIND. */
+	parentStableId: zod.z.string().optional(),
+	/** `false` = shown for context but not pickable. Default true. */
+	selectable: zod.z.boolean().optional()
 });
 /**
 * Flat device summary returned by `createDevice` / `adoptDiscoveredDevice`.
@@ -43031,6 +43951,24 @@ var deviceProviderCapability = {
 			auth: "admin"
 		}),
 		/**
+		* How this provider is found on the network. `[]` = the provider has no
+		* declarative mode and keeps answering `discoverDevices` itself.
+		*/
+		getDiscoveryModes: require_sleep.method(zod.z.object({}), zod.z.array(DiscoveryModeSchema)),
+		/**
+		* Turn the engine's raw hits into candidates. The provider may make
+		* follow-up UNICAST requests to a hit host (an authenticated call, an
+		* identity check) and never sweeps a subnet. `params` is the per-scan form
+		* from `getDiscoveryParamsSchema`.
+		*/
+		classifyDiscoveryHits: require_sleep.method(zod.z.object({
+			hits: zod.z.array(DiscoveryHitSchema),
+			params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+		}), zod.z.array(DiscoveryCandidateSchema), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Optional form schema (`ConfigUISchema`) for the EXTRA per-scan inputs a
 		* provider accepts (e.g. Gree's broadcast address for a different subnet).
 		* `null` when the provider takes no extra scan params — the generic
@@ -44388,20 +45326,26 @@ var deviceManagerCapability = {
 			label: zod.z.string()
 		})).readonly() }), { auth: "admin" }),
 		/** Scan EVERY discovery-capable provider; returns candidates grouped by addon. */
-		discoverAllProviders: require_sleep.method(zod.z.object({}), zod.z.object({ groups: zod.z.array(zod.z.object({
-			addonId: zod.z.string(),
-			label: zod.z.string(),
-			candidates: zod.z.array(DiscoveryCandidateSchema).readonly(),
-			error: zod.z.string().nullable()
-		})).readonly() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
+		discoverAllProviders: require_sleep.method(
+			/** `subnets`: extra CIDRs for THIS scan, on top of the hub's own and the saved list. */
+			zod.z.object({ subnets: zod.z.array(zod.z.string()).optional() }),
+			zod.z.object({ groups: zod.z.array(zod.z.object({
+				addonId: zod.z.string(),
+				label: zod.z.string(),
+				candidates: zod.z.array(DiscoveryCandidateSchema).readonly(),
+				error: zod.z.string().nullable()
+			})).readonly() }),
+			{
+				kind: "mutation",
+				auth: "admin"
+			}
+		),
 		/** Scan ONE provider with optional provider-specific params (subnet /
 		*  broadcast addr) — the per-integration "Scan network" surface. */
 		discoverProvider: require_sleep.method(zod.z.object({
 			addonId: zod.z.string(),
-			params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+			params: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+			subnets: zod.z.array(zod.z.string()).optional()
 		}), zod.z.object({ candidates: zod.z.array(DiscoveryCandidateSchema).readonly() }), {
 			kind: "mutation",
 			auth: "admin"
@@ -70961,7 +71905,9 @@ var integrationsCapability = {
 			id: zod.z.string(),
 			settings: zod.z.record(zod.z.string(), zod.z.unknown()),
 			/** Keys the form's schema declares secret (by type) — keychain-stored (D787). */
-			secretKeys: zod.z.array(zod.z.string()).optional()
+			secretKeys: zod.z.array(zod.z.string()).optional(),
+			/** The integration's own addon applies the change in-process and asks the hub not to respawn it. */
+			skipRestart: zod.z.boolean().optional()
 		}), zod.z.object({ success: zod.z.boolean() }), {
 			kind: "mutation",
 			auth: "admin"
@@ -71607,6 +72553,39 @@ var TlsStatusSchema = zod.z.object({
 		hasCa: zod.z.boolean()
 	}).nullable()
 });
+/** One provider's ask of the scan engine: the modes it declared. */
+var ScanRequestSchema = zod.z.object({
+	providerId: zod.z.string().min(1),
+	modes: zod.z.array(DiscoveryModeSchema)
+});
+var ScanErrorSchema = zod.z.object({
+	/** Absent for a failure that is the scan's own (a bad subnet, a socket that would not open). */
+	providerId: zod.z.string().optional(),
+	/** The mode family that failed (`mdns`, `http-probe`, …). */
+	mode: zod.z.string().optional(),
+	message: zod.z.string()
+});
+/** What one scan did, per mode family; the engine logs the same numbers once. */
+var ScanStatsSchema = zod.z.object({
+	hostsProbed: zod.z.number().int(),
+	hits: zod.z.number().int(),
+	timeouts: zod.z.number().int(),
+	byMode: zod.z.record(zod.z.string(), zod.z.object({
+		probed: zod.z.number().int(),
+		hits: zod.z.number().int(),
+		timeouts: zod.z.number().int()
+	}))
+});
+var ScanNetworkResultSchema = zod.z.object({
+	hits: zod.z.array(zod.z.object({
+		providerId: zod.z.string(),
+		hit: DiscoveryHitSchema
+	})),
+	/** CIDRs actually covered: the hub's own /24s, the saved list and the per-call list. */
+	subnetsScanned: zod.z.array(zod.z.string()),
+	errors: zod.z.array(ScanErrorSchema),
+	stats: ScanStatsSchema
+});
 var localNetworkCapability = {
 	name: "local-network",
 	scope: "system",
@@ -71820,6 +72799,34 @@ var localNetworkCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* The LAN discovery engine. Every provider that declared discovery modes
+		* (`device-provider.getDiscoveryModes`) is scanned in ONE pass: a single
+		* mDNS browse for the union of service types, one WS-Discovery probe, one
+		* SSDP search per target and one sweep that visits each host once and runs
+		* every http-probe of every provider. Subnets scanned = the hub's own
+		* non-internal IPv4 /24s ∪ the saved list (`getScanSubnets`) ∪ `subnets`.
+		* A bad CIDR, or more than 4096 hosts in total, refuses the scan.
+		*/
+		scanNetwork: require_sleep.method(zod.z.object({
+			requests: zod.z.array(ScanRequestSchema),
+			subnets: zod.z.array(zod.z.string()).optional()
+		}), ScanNetworkResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: 9e4
+		}),
+		/** Extra subnets every scan covers besides the hub's own, as CIDR strings. */
+		getScanSubnets: require_sleep.method(zod.z.void(), zod.z.object({ subnets: zod.z.array(zod.z.string()) }), { auth: "admin" }),
+		/**
+		* Replace the saved extra subnets (a cluster setting). Each entry is IPv4
+		* CIDR, at most a /22; the list is refused when it is invalid or its hosts
+		* would exceed the scan cap.
+		*/
+		setScanSubnets: require_sleep.method(zod.z.object({ subnets: zod.z.array(zod.z.string()) }), zod.z.object({ subnets: zod.z.array(zod.z.string()) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Return to the generated local CA. The uploaded certificate stays stored (D873). */
 		revertToGeneratedCertificate: require_sleep.method(zod.z.void(), TlsStatusSchema, {
 			kind: "mutation",
@@ -88643,6 +89650,17 @@ var BaseDeviceProvider = class extends require_sleep.BaseAddon {
 	async discoverDevices(_input) {
 		return [];
 	}
+	/**
+	* How the scan engine finds this provider. Default `[]`: the provider is
+	* not migrated and keeps answering `discoverDevices` itself.
+	*/
+	async getDiscoveryModes() {
+		return [];
+	}
+	/** Turn the scan engine's raw hits into candidates. Default: none. */
+	async classifyDiscoveryHits(_input) {
+		return [];
+	}
 	/** Extra per-scan input form (e.g. a broadcast address for another subnet).
 	*  Null = no extra params. Override in providers that support scoped scans. */
 	async getDiscoveryParamsSchema() {
@@ -90333,6 +91351,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"addonSettings.getDeclaredSettingsKeys": {
+		capName: "addon-settings",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"addonSettings.getDeviceSettings": {
 		capName: "addon-settings",
 		capScope: "system",
@@ -90354,6 +91379,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"addonSettings.unsetStoredSettingsKeys": {
+		capName: "addon-settings",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"addonSettings.updateDeviceSettings": {
 		capName: "addon-settings",
 		capScope: "system",
@@ -92769,6 +93801,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceProvider.classifyDiscoveryHits": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceProvider.createDevice": {
 		capName: "device-provider",
 		capScope: "system",
@@ -92797,6 +93836,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"deviceProvider.getDiscoveryModes": {
+		capName: "device-provider",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"deviceProvider.getDiscoveryParamsSchema": {
 		capName: "device-provider",
 		capScope: "system",
@@ -93574,6 +94620,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"keychain.releaseRecordRefs": {
+		capName: "keychain",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"keychain.resolve": {
 		capName: "keychain",
 		capScope: "system",
@@ -93994,6 +95047,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"localNetwork.getScanSubnets": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"localNetwork.getTlsStatus": {
 		capName: "local-network",
 		capScope: "system",
@@ -94043,6 +95103,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"localNetwork.scanNetwork": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"localNetwork.setAddressRole": {
 		capName: "local-network",
 		capScope: "system",
@@ -94064,6 +95131,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"localNetwork.setScanSubnets": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"localNetwork.setViewerEndpoints": {
 		capName: "local-network",
 		capScope: "system",
@@ -98285,6 +99359,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"storageAdmin.dropOrphanedKind": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
 	"storageAdmin.listKinds": {
 		capName: "storage-admin",
 		capScope: "system",
@@ -98306,6 +99387,27 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"storageAdmin.scanStaleData": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"storageAdmin.staleDataReport": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"storageAdmin.unsetStaleSettingsKey": {
+		capName: "storage-admin",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"storageEvictable.evict": {
 		capName: "storage-evictable",
 		capScope: "system",
@@ -111511,7 +112613,9 @@ function createSystemProxy(api) {
 		addonSettings: {
 			getGlobalSettings: (input) => dispatch("addonSettings", "getGlobalSettings", "query", input),
 			updateGlobalSettings: (input) => dispatch("addonSettings", "updateGlobalSettings", "mutation", input),
-			getIntegrationSettings: (input) => dispatch("addonSettings", "getIntegrationSettings", "query", input)
+			getIntegrationSettings: (input) => dispatch("addonSettings", "getIntegrationSettings", "query", input),
+			getDeclaredSettingsKeys: (input) => dispatch("addonSettings", "getDeclaredSettingsKeys", "query", input),
+			unsetStoredSettingsKeys: (input) => dispatch("addonSettings", "unsetStoredSettingsKeys", "mutation", input)
 		},
 		addonWidgets: { listWidgets: (input) => dispatch("addonWidgets", "listWidgets", "query", input) },
 		alerts: {
@@ -111726,6 +112830,8 @@ function createSystemProxy(api) {
 			reloadDevice: (input) => dispatch("deviceProvider", "reloadDevice", "mutation", input),
 			supportsDiscovery: (input) => dispatch("deviceProvider", "supportsDiscovery", "query", input),
 			discoverDevices: (input) => dispatch("deviceProvider", "discoverDevices", "mutation", input),
+			getDiscoveryModes: (input) => dispatch("deviceProvider", "getDiscoveryModes", "query", input),
+			classifyDiscoveryHits: (input) => dispatch("deviceProvider", "classifyDiscoveryHits", "mutation", input),
 			getDiscoveryParamsSchema: (input) => dispatch("deviceProvider", "getDiscoveryParamsSchema", "query", input),
 			getManualCreationType: (input) => dispatch("deviceProvider", "getManualCreationType", "query", input),
 			adoptDiscoveredDevice: (input) => dispatch("deviceProvider", "adoptDiscoveredDevice", "mutation", input),
@@ -111831,6 +112937,9 @@ function createSystemProxy(api) {
 			uploadCertificate: (input) => dispatch("localNetwork", "uploadCertificate", "mutation", input),
 			downloadCa: (input) => dispatch("localNetwork", "downloadCa", "query", input),
 			useStoredUploadedCertificate: (input) => dispatch("localNetwork", "useStoredUploadedCertificate", "mutation", input),
+			scanNetwork: (input) => dispatch("localNetwork", "scanNetwork", "mutation", input),
+			getScanSubnets: (input) => dispatch("localNetwork", "getScanSubnets", "query", input),
+			setScanSubnets: (input) => dispatch("localNetwork", "setScanSubnets", "mutation", input),
 			revertToGeneratedCertificate: (input) => dispatch("localNetwork", "revertToGeneratedCertificate", "mutation", input)
 		},
 		meshNetwork: {
@@ -121367,12 +122476,22 @@ function rewriteBody(body, kind, currentUpstream, route) {
 /**
 * A vendor `Set-Cookie` for the browser: no `Domain` (the cookie belongs to the hub
 * origin), `Path` narrowed to this attempt's prefix, `Secure` kept (the hub is HTTPS).
-*/
-function rewriteSetCookie(cookie, route) {
-	const kept = cookie.split(";").map((part) => part.trim()).filter((part, index) => {
+* `browserSafe` (the server keeps its own jar, so this copy only serves the page's script):
+* also no `Secure` / `SameSite`, which a plain-http hub makes the browser refuse, and no
+* `__Host-` / `__Secure-` cookie, whose rules a narrowed Path breaks.
+*/
+function rewriteSetCookie(cookie, route, options = {}) {
+	const parts = cookie.split(";").map((part) => part.trim());
+	const dropped = options.browserSafe === true ? [
+		"domain",
+		"path",
+		"secure",
+		"samesite"
+	] : ["domain", "path"];
+	const kept = parts.filter((part, index) => {
 		if (index === 0) return true;
 		const name = part.split("=")[0]?.trim().toLowerCase() ?? "";
-		return name !== "domain" && name !== "path";
+		return !dropped.includes(name);
 	});
 	kept.push(`Path=${route.basePath}/`);
 	return kept.join("; ");
@@ -121383,10 +122502,10 @@ function rewriteSetCookie(cookie, route) {
 * one, so a past-dated set that only deleted the other domain's copy would delete the
 * live one the same response just set: that deletion is dropped.
 */
-function rewriteSetCookies(cookies, route) {
+function rewriteSetCookies(cookies, route, options = {}) {
 	const now = Date.now();
 	const liveNames = new Set(cookies.filter((c) => !isExpiredCookie(c, now)).map(cookieName));
-	return cookies.filter((c) => !(isExpiredCookie(c, now) && liveNames.has(cookieName(c)))).map((c) => rewriteSetCookie(c, route));
+	return cookies.filter((c) => !(isExpiredCookie(c, now) && liveNames.has(cookieName(c)))).filter((c) => options.browserSafe !== true || !/^__(?:host|secure)-/i.test(cookieName(c))).map((c) => rewriteSetCookie(c, route, options));
 }
 function cookieName(cookie) {
 	return cookie.split(";")[0]?.split("=")[0]?.trim() ?? "";
@@ -121447,6 +122566,101 @@ function filterForwardedCookies(cookieHeader) {
 	return cookieHeader.split(";").map((part) => part.trim()).filter((part) => part.length > 0 && !part.toLowerCase().startsWith("camstack_")).join("; ");
 }
 //#endregion
+//#region src/vendor-login-proxy/cookie-jar.ts
+/**
+* Server-side cookie jar of ONE vendor sign-in attempt (D955).
+*
+* A vendor login (an identity provider's cookie/JS check page) refuses a flow that arrives
+* without the cookies it set a step earlier. Relying on the browser to store them under the
+* hub origin loses them whenever the browser refuses the rewritten cookie (a `Secure` cookie
+* on a plain-http hub, a `__Host-` name with a narrowed Path, a `SameSite=None` without
+* `Secure`). The proxy therefore keeps every vendor cookie itself and sends them upstream,
+* whatever the browser did. Values never leave this object except as the upstream `Cookie`
+* header; nothing here logs.
+*/
+function attributeValue(attrs, name) {
+	const found = attrs.find((a) => a.split("=")[0]?.trim().toLowerCase() === name);
+	if (found === void 0) return void 0;
+	const eq = found.indexOf("=");
+	return eq === -1 ? "" : found.slice(eq + 1).trim();
+}
+function hasFlag(attrs, name) {
+	return attrs.some((a) => a.toLowerCase() === name);
+}
+function expiryOf(attrs, nowMs) {
+	const maxAge = attributeValue(attrs, "max-age");
+	if (maxAge !== void 0 && maxAge.length > 0 && Number.isFinite(Number(maxAge))) return nowMs + Number(maxAge) * 1e3;
+	const expires = attributeValue(attrs, "expires");
+	if (expires === void 0) return null;
+	const at = Date.parse(expires);
+	return Number.isFinite(at) ? at : null;
+}
+function defaultPath(requestPath) {
+	const last = requestPath.lastIndexOf("/");
+	return last <= 0 ? "/" : requestPath.slice(0, last);
+}
+function pathMatches(cookiePath, requestPath) {
+	if (requestPath === cookiePath) return true;
+	if (!requestPath.startsWith(cookiePath)) return false;
+	return cookiePath.endsWith("/") || requestPath.charAt(cookiePath.length) === "/";
+}
+function hostMatches(cookie, host) {
+	if (cookie.domain === null) return cookie.originHost === host;
+	const bare = hostWithoutPort(host);
+	return bare === cookie.domain || bare.endsWith(`.${cookie.domain}`);
+}
+var VendorCookieJar = class {
+	#cookies = /* @__PURE__ */ new Map();
+	/** Store (or delete, when expired) the cookies of one upstream response. */
+	store(setCookies, origin, nowMs) {
+		for (const raw of setCookies) {
+			const [first, ...rest] = raw.split(";").map((part) => part.trim());
+			const eq = first?.indexOf("=") ?? -1;
+			if (first === void 0 || eq <= 0) continue;
+			const name = first.slice(0, eq);
+			const attrs = rest;
+			const domainAttr = attributeValue(attrs, "domain");
+			const domain = domainAttr === void 0 || domainAttr.length === 0 ? null : domainAttr.replace(/^\./, "").toLowerCase();
+			const pathAttr = attributeValue(attrs, "path");
+			const path = pathAttr !== void 0 && pathAttr.startsWith("/") ? pathAttr : defaultPath(origin.pathname);
+			const originBare = hostWithoutPort(origin.host);
+			if (domain !== null && originBare !== domain && !originBare.endsWith(`.${domain}`)) continue;
+			const expiresAtMs = expiryOf(attrs, nowMs);
+			const key = `${name}|${domain ?? origin.host}|${path}`;
+			if (expiresAtMs !== null && expiresAtMs <= nowMs) {
+				this.#cookies.delete(key);
+				continue;
+			}
+			this.#cookies.set(key, {
+				name,
+				value: first.slice(eq + 1),
+				originHost: origin.host,
+				domain,
+				path,
+				secure: hasFlag(attrs, "secure"),
+				expiresAtMs
+			});
+		}
+	}
+	/** The `Cookie` header value for a request to `host` + `pathname`, or null when none applies. */
+	headerFor(target, nowMs) {
+		const secureOk = target.scheme === "https" || isLoopbackHost(target.host);
+		const matching = [...this.#cookies.values()].filter((c) => (c.expiresAtMs === null || c.expiresAtMs > nowMs) && (!c.secure || secureOk) && hostMatches(c, target.host) && pathMatches(c.path, target.pathname)).sort((a, b) => b.path.length - a.path.length);
+		if (matching.length === 0) return null;
+		return matching.map((c) => `${c.name}=${c.value}`).join("; ");
+	}
+};
+/** Cookie names carried by a `Cookie` header value. */
+function cookieHeaderNames(header) {
+	return new Set(header.split(";").map((part) => part.split("=")[0]?.trim() ?? "").filter((name) => name.length > 0));
+}
+/** `browser` cookies not shadowed by the jar's, then the jar's: the jar is the truth. */
+function mergeCookieHeaders(browser, jar) {
+	if (jar === null) return browser;
+	const shadowed = cookieHeaderNames(jar);
+	return [...browser.split(";").map((part) => part.trim()).filter((part) => part.length > 0 && !shadowed.has(part.split("=")[0]?.trim() ?? "")), jar].join("; ");
+}
+//#endregion
 //#region src/vendor-login-proxy/flow-trace.ts
 /** A short stable label for the attempt: enough to group lines, useless as a capability. */
 function attemptLabel(attemptId) {
@@ -121645,6 +122859,7 @@ var VendorLoginProxy = class {
 		this.#attempts.set(spec.attemptId, {
 			expiresAtMs: spec.expiresAtMs,
 			upstreams: spec.upstreams,
+			jar: spec.serverCookieJar === true ? new VendorCookieJar() : null,
 			evaluate: async (view) => {
 				const verdict = await spec.terminal(view);
 				if (verdict.kind === "continue") return verdict;
@@ -121741,7 +122956,7 @@ var VendorLoginProxy = class {
 				body = Buffer.from(rewriteFormBody(formBodyRaw, route), "utf8");
 			} else body = read;
 		}
-		const headers = this.#requestHeaders(req, route, upstream);
+		const headers = this.#requestHeaders(req, route, upstream, attempt.jar, target);
 		const upstreamRes = await this.#fetch(target, {
 			method,
 			headers,
@@ -121750,6 +122965,10 @@ var VendorLoginProxy = class {
 		});
 		const location = upstreamRes.headers.get("location");
 		const setCookies = upstreamRes.headers.getSetCookie();
+		attempt.jar?.store(setCookies, {
+			host: upstream.host,
+			pathname: target.pathname
+		}, this.#now());
 		const kind = bodyKindOf(upstreamRes.headers.get("content-type") ?? "");
 		const declaredLength = Number(upstreamRes.headers.get("content-length") ?? "0");
 		const text = kind !== null && !(declaredLength > MAX_TEXT_BODY_BYTES) && method !== "HEAD" ? await upstreamRes.text() : null;
@@ -121797,7 +123016,7 @@ var VendorLoginProxy = class {
 		upstreamRes.headers.forEach((value, name) => {
 			if (!DROP_RESPONSE_HEADERS.has(name.toLowerCase())) out[name] = value;
 		});
-		if (setCookies.length > 0) out["set-cookie"] = rewriteSetCookies(setCookies, route);
+		if (setCookies.length > 0) out["set-cookie"] = rewriteSetCookies(setCookies, route, { browserSafe: attempt.jar !== null });
 		if (location !== null) out["location"] = rewriteLocation(location, upstream, route);
 		out["cache-control"] = "no-store";
 		if (text !== null && kind !== null) {
@@ -121819,15 +123038,19 @@ var VendorLoginProxy = class {
 			...flowTraceMeta(input)
 		} });
 	}
-	#requestHeaders(req, route, upstream) {
+	#requestHeaders(req, route, upstream, jar, target) {
 		const headers = {};
 		for (const [name, value] of Object.entries(req.headers)) {
 			const lower = name.toLowerCase();
 			if (DROP_REQUEST_HEADERS.has(lower) || value === void 0) continue;
 			headers[lower] = Array.isArray(value) ? value.join(", ") : value;
 		}
-		const cookie = filterForwardedCookies(firstHeader(req.headers["cookie"]) ?? "");
-		if (cookie.length > 0) headers["cookie"] = cookie;
+		const merged = mergeCookieHeaders(filterForwardedCookies(firstHeader(req.headers["cookie"]) ?? ""), jar?.headerFor({
+			host: upstream.host,
+			pathname: target.pathname,
+			scheme: upstream.scheme
+		}, this.#now()) ?? null);
+		if (merged.length > 0) headers["cookie"] = merged;
 		if (req.headers["origin"] !== void 0) headers["origin"] = `${upstream.scheme}://${upstream.host}`;
 		const referer = firstHeader(req.headers["referer"]);
 		if (referer !== void 0) {
@@ -123159,7 +124382,6 @@ exports.AutoUpdateSettingsSchema = AutoUpdateSettingsSchema;
 exports.AutomationActionSchema = AutomationActionSchema;
 exports.AutomationCapStepSchema = AutomationCapStepSchema;
 exports.AutomationConditionOperatorSchema = AutomationConditionOperatorSchema;
-exports.AutomationConditionSchema = AutomationConditionSchema;
 exports.AutomationConditionTraceNodeSchema = AutomationConditionTraceNodeSchema;
 exports.AutomationControlStatusSchema = AutomationControlStatusSchema;
 exports.AutomationRecipeSchema = AutomationRecipeSchema;
@@ -123169,9 +124391,9 @@ exports.AutomationRunTraceSchema = AutomationRunTraceSchema;
 exports.AutomationRunVerdictSchema = AutomationRunVerdictSchema;
 exports.AutomationStateDocSchema = AutomationStateDocSchema;
 exports.AutomationStepTraceSchema = AutomationStepTraceSchema;
-exports.AutomationTriggerSchema = AutomationTriggerSchema;
 exports.AutomationTriggerTraceSchema = AutomationTriggerTraceSchema;
 exports.AutomationWaitStepSchema = AutomationWaitStepSchema;
+exports.AutomationWhenSchema = AutomationWhenSchema;
 exports.AvailableIntegrationTypeSchema = AvailableIntegrationTypeSchema;
 exports.BASE_DEVICE_CAPS = BASE_DEVICE_CAPS;
 exports.BASE_LIVE_EGRESS_PROFILE = BASE_LIVE_EGRESS_PROFILE;
@@ -123472,6 +124694,7 @@ exports.CreateIntegrationInputSchema = CreateIntegrationInputSchema;
 exports.CreateUserInputSchema = CreateUserInputSchema;
 exports.CredentialScopeSchema = CredentialScopeSchema;
 exports.CredentialTokenClaimsSchema = CredentialTokenClaimsSchema;
+exports.CurrentAutomationRecipeSchema = CurrentAutomationRecipeSchema;
 exports.CustomActionInputSchema = CustomActionInputSchema;
 exports.CustomModelDescriptorSchema = CustomModelDescriptorSchema;
 exports.CustomizeAssignmentStatusSchema = CustomizeAssignmentStatusSchema;
@@ -123524,6 +124747,7 @@ exports.DETAIL_CROP_PADDING_FIELD = DETAIL_CROP_PADDING_FIELD;
 exports.DETAIL_CROP_PADDING_KEY = DETAIL_CROP_PADDING_KEY;
 exports.DETAIL_CROP_SECTION_ID = DETAIL_CROP_SECTION_ID;
 exports.DETAIL_CROP_SQUARE_KEY = DETAIL_CROP_SQUARE_KEY;
+exports.DETECTION_LABEL_SOURCES = DETECTION_LABEL_SOURCES;
 exports.DETECTION_MACRO_CLASSES = DETECTION_MACRO_CLASSES;
 exports.DETECTION_PIPELINE_CAP_NAME = DETECTION_PIPELINE_CAP_NAME;
 exports.DETECTOR_ACCURACY = DETECTOR_ACCURACY;
@@ -123587,6 +124811,7 @@ exports.DetailCropConventionSchema = DetailCropConventionSchema;
 exports.DetectionCatalogClassMapSchema = DetectionCatalogClassMapSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
 exports.DetectionSourcesSchema = DetectionSourcesSchema;
+exports.DetectionSubjectSchema = DetectionSubjectSchema;
 exports.DetectionTriggerFilter = DetectionTriggerFilter;
 exports.DeviceAdminLinkSchema = DeviceAdminLinkSchema;
 exports.DeviceCaStatusSchema = DeviceCaStatusSchema;
@@ -123638,6 +124863,8 @@ exports.DiscoveredChildDeviceSchema = DiscoveredChildDeviceSchema;
 exports.DiscoveredChildStatusSchema = DiscoveredChildStatusSchema;
 exports.DiscoveredDeviceSchema = DiscoveredDeviceSchema;
 exports.DiscoveredTargetSchema = DiscoveredTargetSchema;
+exports.DiscoveryHitSchema = DiscoveryHitSchema;
+exports.DiscoveryModeSchema = DiscoveryModeSchema;
 exports.DishwasherAccessSchema = DishwasherAccessSchema;
 exports.DishwasherAvailabilitySchema = DishwasherAvailabilitySchema;
 exports.DishwasherOperationStateSchema = DishwasherOperationStateSchema;
@@ -123935,7 +125162,10 @@ exports.LedgerWalkRefusalSchema = LedgerWalkRefusalSchema;
 exports.LedgerWalkReportSchema = LedgerWalkReportSchema;
 exports.LedgerWalkSkipCountsSchema = LedgerWalkSkipCountsSchema;
 exports.LedgerWalkSkipReasonSchema = LedgerWalkSkipReasonSchema;
+exports.LegacyAutomationRecipeSchema = LegacyAutomationRecipeSchema;
+exports.LegacyConditionSchema = LegacyConditionSchema;
 exports.LegacyStorageLocationDefaultSchema = LegacyStorageLocationDefaultSchema;
+exports.LegacyTriggerSchema = LegacyTriggerSchema;
 exports.LinkedDeviceSchema = LinkedDeviceSchema;
 exports.LinkedDevicesModeSchema = LinkedDevicesModeSchema;
 exports.LinkedDevicesSlotValueSchema = LinkedDevicesSlotValueSchema;
@@ -124038,10 +125268,14 @@ exports.MAX_REMOTE_BINDINGS = MAX_REMOTE_BINDINGS;
 exports.MAX_REMOTE_CUSTOM_BUTTONS = MAX_REMOTE_CUSTOM_BUTTONS;
 exports.MAX_REQUEUED_BUCKETS_PER_SERIES = MAX_REQUEUED_BUCKETS_PER_SERIES;
 exports.MAX_SENSOR_TRIGGER_DEVICES = MAX_SENSOR_TRIGGER_DEVICES;
+exports.MAX_TRACE_ARGS = MAX_TRACE_ARGS;
+exports.MAX_TRACE_ARG_LENGTH = MAX_TRACE_ARG_LENGTH;
 exports.MAX_TRACE_KEEP = MAX_TRACE_KEEP;
 exports.MAX_TRACK_DEBUG_NOTE_LEN = MAX_TRACK_DEBUG_NOTE_LEN;
 exports.MAX_TRACK_PURITIES = MAX_TRACK_PURITIES;
 exports.MAX_TRACK_RELATIONS = MAX_TRACK_RELATIONS;
+exports.MAX_WHEN_DEPTH = MAX_WHEN_DEPTH;
+exports.MAX_WHEN_LEAVES = MAX_WHEN_LEAVES;
 exports.MEDIA_OWNER_TYPES = MEDIA_OWNER_TYPES;
 exports.MEDIA_PRESENCE_OWNER_KINDS = MEDIA_PRESENCE_OWNER_KINDS;
 exports.METHOD_ACCESS_MAP = METHOD_ACCESS_MAP;
@@ -124597,6 +125831,7 @@ exports.RECOVERY_MIN_INTERVAL_MS = RECOVERY_MIN_INTERVAL_MS;
 exports.RECOVERY_MIN_UNCOVERED_FRACTION = RECOVERY_MIN_UNCOVERED_FRACTION;
 exports.RECOVERY_MOTION_MAX_AGE_MS = RECOVERY_MOTION_MAX_AGE_MS;
 exports.RECOVERY_VIEW_PX = RECOVERY_VIEW_PX;
+exports.REDACTED_ARG = REDACTED_ARG;
 exports.REDACTED_SECRET = require_sleep.REDACTED_SECRET;
 exports.REFERENCE_COMPUTE = REFERENCE_COMPUTE;
 exports.REFERENCE_MATCH_FRACTION = REFERENCE_MATCH_FRACTION;
@@ -124921,10 +126156,14 @@ exports.SnapshotImageSchema = SnapshotImageSchema;
 exports.SourceInfoSchema = SourceInfoSchema;
 exports.SpatialDetectionSchema = SpatialDetectionSchema;
 exports.SsoBridgeClaimsSchema = SsoBridgeClaimsSchema;
+exports.StaleDataReportSchema = StaleDataReportSchema;
 exports.StaleDevicePinSchema = StaleDevicePinSchema;
+exports.StaleKindFindingSchema = StaleKindFindingSchema;
+exports.StaleSettingsKeyFindingSchema = StaleSettingsKeyFindingSchema;
 exports.StartEmbeddedInputSchema = StartEmbeddedInputSchema;
 exports.StartEnrollmentOutputSchema = StartEnrollmentOutputSchema;
 exports.StationaryObjectSchema = StationaryObjectSchema;
+exports.StationarySubjectSchema = StationarySubjectSchema;
 exports.StatisticHelperSpecSchema = require_composition.StatisticHelperSpecSchema;
 exports.StatisticWindowSchema = require_composition.StatisticWindowSchema;
 exports.StorageAbortUploadInputSchema = AbortUploadInputSchema;
@@ -125233,6 +126472,7 @@ exports.allDoActions = allDoActions;
 exports.allowedSuppliedEffect = allowedSuppliedEffect;
 exports.ambientLightSensorCapability = ambientLightSensorCapability;
 exports.annotateClipsWithEventLabels = annotateClipsWithEventLabels;
+exports.anySubjectMatches = anySubjectMatches;
 exports.appFlowLocation = appFlowLocation;
 exports.appendTrace = appendTrace;
 exports.applianceDeviceType = require_composition.applianceDeviceType;
@@ -125300,6 +126540,7 @@ exports.buildPlusCatalogClassMap = buildPlusCatalogClassMap;
 exports.buildRoleScopes = buildRoleScopes;
 exports.buildSecretRef = require_sleep.buildSecretRef;
 exports.buildSessionLostAlert = buildSessionLostAlert;
+exports.buildStepArgsTrace = buildStepArgsTrace;
 exports.buildStreamParamsConfigSchema = buildStreamParamsConfigSchema;
 exports.buildSubjectPath = buildSubjectPath;
 exports.buildTriggerTrace = buildTriggerTrace;
@@ -125365,6 +126606,7 @@ exports.collectModelBoundKeys = collectModelBoundKeys;
 exports.collectSecretConfigKeys = require_sleep.collectSecretConfigKeys;
 exports.collectSecretLeaves = require_sleep.collectSecretLeaves;
 exports.collectSecretMarkerRefs = require_sleep.collectSecretMarkerRefs;
+exports.collectWhenMirrorSources = collectWhenMirrorSources;
 exports.collectZodSecretPaths = require_sleep.collectZodSecretPaths;
 exports.colorCapability = colorCapability;
 exports.colorForKind = colorForKind;
@@ -125394,7 +126636,6 @@ exports.compositionSourceKey = require_composition.compositionSourceKey;
 exports.compositionSourceRefs = compositionSourceRefs;
 exports.computeCapacityShares = computeCapacityShares;
 exports.computeScores = computeScores;
-exports.conditionDepth = conditionDepth;
 exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
 exports.connectionTestCapability = connectionTestCapability;
@@ -125406,6 +126647,9 @@ exports.consumablesCapability = consumablesCapability;
 exports.contactCapability = contactCapability;
 exports.containingParentIndex = containingParentIndex;
 exports.controlCapability = controlCapability;
+exports.convertLegacyCondition = convertLegacyCondition;
+exports.convertLegacyRecipe = convertLegacyRecipe;
+exports.convertLegacyWhen = convertLegacyWhen;
 exports.convertPresetFeature = convertPresetFeature;
 exports.convertQuantityInput = convertQuantityInput;
 exports.convertUnit = convertUnit;
@@ -125417,8 +126661,8 @@ exports.coreBlockIdFromAddonId = coreBlockIdFromAddonId;
 exports.coreBlockSourceKind = coreBlockSourceKind;
 exports.coreBlocksCapability = coreBlocksCapability;
 exports.cosineSimilarity = cosineSimilarity;
-exports.countConditionLeaves = countConditionLeaves;
 exports.countRecoverySkips = countRecoverySkips;
+exports.countWhenLeaves = countWhenLeaves;
 exports.coverCapability = coverCapability;
 exports.createAlarmProfile = createAlarmProfile;
 exports.createDeviceExtensionProvider = createDeviceExtensionProvider;
@@ -125484,6 +126728,7 @@ exports.describeOnboardRefusal = describeOnboardRefusal;
 exports.describeRootSupplies = describeRootSupplies;
 exports.describeRootSupply = describeRootSupply;
 exports.describeStateField = describeStateField;
+exports.describeSubject = describeSubject;
 exports.describeSystemEventDeliveryProblem = describeSystemEventDeliveryProblem;
 exports.describeSystemEventFamilyProblem = describeSystemEventFamilyProblem;
 exports.describeTopLevelStateFields = describeTopLevelStateFields;
@@ -125560,6 +126805,7 @@ exports.evaluateSensorLevelEdge = require_composition.evaluateSensorLevelEdge;
 exports.evaluateStatefulExpressionCall = require_composition.evaluateStatefulExpressionCall;
 exports.evaluateStationaryTrigger = evaluateStationaryTrigger;
 exports.evaluateStatistic = require_composition.evaluateStatistic;
+exports.evaluateWhenTree = evaluateWhenTree;
 exports.evaluateZoneRules = evaluateZoneRules;
 exports.event = require_sleep.event;
 exports.eventEmitterCapability = eventEmitterCapability;
@@ -125602,6 +126848,7 @@ exports.findCompositionCycles = findCompositionCycles;
 exports.findTimezone = findTimezone;
 exports.floodCapability = floodCapability;
 exports.foldSnapshotByFunction = foldSnapshotByFunction;
+exports.forEachLeaf = forEachLeaf;
 exports.foreignCapacityCells = foreignCapacityCells;
 exports.forgetKnownSecret = require_sleep.forgetKnownSecret;
 exports.formatDeviceRevoker = formatDeviceRevoker;
@@ -125635,6 +126882,7 @@ exports.groupActiveCapability = groupActiveCapability;
 exports.groupCommandsCapability = groupCommandsCapability;
 exports.groupStatusCapability = groupStatusCapability;
 exports.groupTemplate = groupTemplate;
+exports.hasEventLeaves = hasEventLeaves;
 exports.hasModelBoundOverrides = hasModelBoundOverrides;
 exports.hasMotionTrigger = hasMotionTrigger;
 exports.hasUrlScheme = hasUrlScheme;
@@ -125705,6 +126953,7 @@ exports.isDrawableSubjectPath = isDrawableSubjectPath;
 exports.isEmbeddingModelFailed = isEmbeddingModelFailed;
 exports.isEvent = require_sleep.isEvent;
 exports.isEventKindLabelKey = isEventKindLabelKey;
+exports.isEventLeaf = isEventLeaf;
 exports.isEventOwnerType = isEventOwnerType;
 exports.isFirstLevelMacroClass = isFirstLevelMacroClass;
 exports.isForwardInputRef = require_composition.isForwardInputRef;
@@ -125716,6 +126965,7 @@ exports.isIsolatedBuiltin = isIsolatedBuiltin;
 exports.isKeychainStoredField = require_sleep.isKeychainStoredField;
 exports.isKnownTemplateVar = isKnownTemplateVar;
 exports.isLabelSupplyStepId = isLabelSupplyStepId;
+exports.isLeaf = isLeaf;
 exports.isLocationEnabled = isLocationEnabled;
 exports.isMediaOwnerType = isMediaOwnerType;
 exports.isModelScopedStepSettingKey = isModelScopedStepSettingKey;
@@ -126220,8 +127470,11 @@ exports.streamQualityLabel = streamQualityLabel;
 exports.streamSignalsCapability = streamSignalsCapability;
 exports.stripRetiredBandPreBufferSec = stripRetiredBandPreBufferSec;
 exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
+exports.subClassesOf = subClassesOf;
 exports.subKindsOf = subKindsOf;
+exports.subjectFromClassName = subjectFromClassName;
 exports.subjectHasPath = subjectHasPath;
+exports.subjectMatches = subjectMatches;
 exports.subjectPathSampleFromBox = subjectPathSampleFromBox;
 exports.subjectPathSvgPoints = subjectPathSvgPoints;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
@@ -126303,6 +127556,7 @@ exports.validateCustomAddress = validateCustomAddress;
 exports.validateExpressionSource = require_composition.validateExpressionSource;
 exports.validatePalette = validatePalette;
 exports.validateRecipeBounds = validateRecipeBounds;
+exports.validateWhenTree = validateWhenTree;
 exports.valveCapability = valveCapability;
 exports.vectorDimFromBase64 = vectorDimFromBase64;
 exports.vectorIndexDimConflictError = vectorIndexDimConflictError;
@@ -126324,6 +127578,7 @@ exports.webrtcSessionCapability = webrtcSessionCapability;
 exports.weeklyMaskIndex = weeklyMaskIndex;
 exports.weeklyMaskIsUniform = weeklyMaskIsUniform;
 exports.weeklyMaskToWindows = weeklyMaskToWindows;
+exports.whenDepth = whenDepth;
 exports.widenDeviceConstructor = widenDeviceConstructor;
 exports.windowsToWeeklyMask = windowsToWeeklyMask;
 exports.wiringAddonHealthSchema = wiringAddonHealthSchema;