camstack 1.2.212 → 1.2.213

package/dist/{chunk-MLWXP2SI.js → chunk-MJJWVAEM.js}

@@ -1404,7 +1404,7 @@ var EventCategory = /* @__PURE__ */ (function(EventCategory2) {
   return EventCategory2;
 })({});
 
-// ../types/dist/sleep-63gM_1JR.mjs
+// ../types/dist/sleep-CeyhrcOk.mjs
 import { z as z2 } from "zod";
 var AUDIO_CHUNK_FORMATS = [
   "f32le",
@@ -7308,6 +7308,149 @@ function metaOf(schema) {
 function paramMetaOf(field) {
   return metaOf(field) ?? metaOf(unwrapSchema(field));
 }
+var MACRO_LABELS = [
+  {
+    id: "person",
+    name: "Person"
+  },
+  {
+    id: "vehicle",
+    name: "Vehicle"
+  },
+  {
+    id: "animal",
+    name: "Animal"
+  },
+  {
+    id: "package",
+    name: "Package"
+  }
+];
+var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
+var COCO_TO_MACRO = {
+  mapping: {
+    person: "person",
+    bicycle: "vehicle",
+    car: "vehicle",
+    motorcycle: "vehicle",
+    airplane: "vehicle",
+    bus: "vehicle",
+    train: "vehicle",
+    truck: "vehicle",
+    boat: "vehicle",
+    bird: "animal",
+    cat: "animal",
+    dog: "animal",
+    horse: "animal",
+    sheep: "animal",
+    cow: "animal",
+    elephant: "animal",
+    bear: "animal",
+    zebra: "animal",
+    giraffe: "animal",
+    suitcase: "package",
+    backpack: "package",
+    handbag: "package"
+  },
+  preserveOriginal: false
+};
+var SubClassLabelSchema = z4.object({
+  kind: z4.literal("sub-class"),
+  className: z4.string().min(1)
+});
+var IdentityLabelSchema = z4.object({
+  kind: z4.literal("identity"),
+  /** The `face-gallery` identity id (stable across a rename). */
+  identityId: z4.string().min(1),
+  /** The identity's name — what a track-lifecycle event carries as `label`. */
+  name: z4.string().min(1)
+});
+var PlateLabelSchema = z4.object({
+  kind: z4.literal("plate"),
+  text: z4.string().min(1)
+});
+function macroOf$1(className) {
+  return COCO_TO_MACRO.mapping[className.toLowerCase()] ?? className.toLowerCase();
+}
+function subClassBelongs(macro2, label) {
+  return label === void 0 || macroOf$1(label.className) === macro2;
+}
+var subClassOf = (macro2) => SubClassLabelSchema.refine((l) => subClassBelongs(macro2, l), { message: `that class is not a kind of ${macro2} in the detection taxonomy` });
+var DetectionSubjectSchema = z4.discriminatedUnion("macro", [
+  z4.object({
+    macro: z4.literal("animal"),
+    label: subClassOf("animal").optional()
+  }),
+  z4.object({
+    macro: z4.literal("person"),
+    label: IdentityLabelSchema.optional()
+  }),
+  z4.object({
+    macro: z4.literal("vehicle"),
+    label: z4.discriminatedUnion("kind", [SubClassLabelSchema.refine((l) => subClassBelongs("vehicle", l), { message: "that class is not a kind of vehicle in the detection taxonomy" }), PlateLabelSchema]).optional()
+  }),
+  z4.object({
+    macro: z4.literal("package"),
+    label: subClassOf("package").optional()
+  }),
+  z4.object({
+    macro: z4.literal("other"),
+    className: z4.string().min(1)
+  })
+]);
+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 \u2014 only a class can narrow it" });
+function subjectFromClassName(className) {
+  const name = className.trim().toLowerCase();
+  const macro2 = COCO_TO_MACRO.mapping[name];
+  if (new Set(Object.values(COCO_TO_MACRO.mapping)).has(name)) return macroOnly(name);
+  if (macro2 === void 0) return {
+    macro: "other",
+    className
+  };
+  const label = {
+    kind: "sub-class",
+    className: name
+  };
+  switch (macro2) {
+    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(macro2) {
+  switch (macro2) {
+    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: macro2
+      };
+  }
+}
 var AutomationConditionOperatorSchema = z4.enum([
   "eq",
   "ne",
@@ -7318,12 +7461,69 @@ var AutomationConditionOperatorSchema = z4.enum([
   "contains",
   "in"
 ]);
-var AutomationConditionLeafSchema = z4.object({
-  kind: z4.literal("condition"),
+var DeviceBecomesLeafSchema = z4.object({
+  kind: z4.literal("device-becomes"),
+  deviceId: z4.number().int().nonnegative(),
+  cap: z4.string().min(1),
+  fieldPath: z4.string().min(1),
+  /** Fire when the field takes this value. Omit to fire on any change. */
+  becomes: z4.union([
+    z4.string(),
+    z4.number(),
+    z4.boolean()
+  ]).optional(),
+  /** Only on a CHANGE of value, not on every re-report. */
+  edge: z4.boolean().optional(),
+  /** The new value must hold this long before it counts. */
+  forMs: z4.number().int().min(0).max(864e5).optional(),
+  /** Collapse a burst into one occurrence. */
+  debounceMs: z4.number().int().min(0).max(6e5).optional()
+});
+var DeviceEventLeafSchema = z4.object({
+  kind: z4.literal("device-event"),
+  /** An `EventCategory` value. */
+  category: z4.string().min(1),
+  deviceId: z4.number().int().nonnegative().optional()
+});
+var ScheduleLeafSchema = z4.object({
+  kind: z4.literal("schedule"),
+  cron: z4.string().min(1).max(120)
+});
+var ManualLeafSchema = z4.object({ kind: z4.literal("manual") });
+var IntervalLeafSchema = z4.object({
+  kind: z4.literal("interval"),
+  minutes: z4.number().int().min(1).max(1440)
+});
+var DetectionLeafSchema = z4.object({
+  kind: z4.literal("detection"),
+  /** One macro class each, optionally narrowed by a label; a track of any listed subject fires. */
+  subjects: z4.array(DetectionSubjectSchema).min(1),
+  deviceIds: z4.array(z4.number().int().nonnegative()).min(1),
+  /** The track must have visited at least one of these zones. */
+  zones: z4.array(z4.string().min(1)).min(1).optional(),
+  /** Best-so-far confidence the track must reach. */
+  minScore: z4.number().min(0).max(1).optional()
+});
+var StationaryLeafSchema = z4.object({
+  kind: z4.literal("stationary"),
+  deviceIds: z4.array(z4.number().int().nonnegative()).min(1),
+  subjects: z4.array(StationarySubjectSchema).min(1).optional(),
+  zones: z4.array(z4.string().min(1)).min(1).optional(),
+  /** `appeared`: it became parked. `departed`: the registry retired it. */
+  phase: z4.enum(["appeared", "departed"])
+});
+var DeviceIsLeafSchema = z4.object({
+  kind: z4.literal("device-is"),
   deviceId: z4.number().int().nonnegative(),
   cap: z4.string().min(1),
   fieldPath: z4.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: z4.union([
     z4.string(),
     z4.number(),
@@ -7331,17 +7531,16 @@ var AutomationConditionLeafSchema = z4.object({
     z4.array(z4.union([z4.string(), z4.number()])),
     QuantityValueSchema
   ]),
+  /** The unit the person picked for `value` (display only; `value` is in the base unit). */
   unit: z4.string().min(1).optional()
 });
-var AutomationConditionStationaryPresentSchema = z4.object({
+var StationaryPresentLeafSchema = z4.object({
   kind: z4.literal("stationary-present"),
   deviceId: z4.number().int().nonnegative(),
-  /** Class names; a macro class matches every raw class that maps to it. */
-  classes: z4.array(z4.string().min(1)).min(1).optional(),
-  /** The parked object must be in at least one of these zones. */
+  subjects: z4.array(StationarySubjectSchema).min(1).optional(),
   zones: z4.array(z4.string().min(1)).min(1).optional()
 });
-var AutomationConditionExpressionSchema = z4.object({
+var ExpressionLeafSchema = z4.object({
   kind: z4.literal("expression"),
   expr: z4.string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
   bindings: z4.record(z4.string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
@@ -7353,45 +7552,150 @@ var AutomationConditionExpressionSchema = z4.object({
     path: ["expr"]
   });
 });
-var AutomationConditionSchema = z4.lazy(() => z4.discriminatedUnion("kind", [
+var AutomationWhenSchema = z4.lazy(() => z4.discriminatedUnion("kind", [
   z4.object({
     kind: z4.literal("all"),
-    children: z4.array(AutomationConditionSchema)
+    children: z4.array(AutomationWhenSchema)
   }),
   z4.object({
     kind: z4.literal("any"),
-    children: z4.array(AutomationConditionSchema)
+    children: z4.array(AutomationWhenSchema)
   }),
   z4.object({
     kind: z4.literal("not"),
-    child: AutomationConditionSchema
+    child: AutomationWhenSchema
   }),
-  AutomationConditionLeafSchema,
-  AutomationConditionExpressionSchema,
-  AutomationConditionStationaryPresentSchema
+  DeviceBecomesLeafSchema,
+  DeviceEventLeafSchema,
+  ScheduleLeafSchema,
+  ManualLeafSchema,
+  IntervalLeafSchema,
+  DetectionLeafSchema,
+  StationaryLeafSchema,
+  DeviceIsLeafSchema,
+  StationaryPresentLeafSchema,
+  ExpressionLeafSchema
 ]));
-var AutomationTriggerSchema = z4.discriminatedUnion("kind", [
+var EVENT_KINDS = /* @__PURE__ */ 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";
+}
+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;
+}
+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;
+}
+function forEachLeaf(node, visit, path2 = "when") {
+  if (isLeaf(node)) {
+    visit(node, path2);
+    return;
+  }
+  if (node.kind === "not") {
+    forEachLeaf(node.child, visit, `${path2}.0`);
+    return;
+  }
+  node.children.forEach((child, i) => {
+    forEachLeaf(child, visit, `${path2}.${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;
+}
+function eventNeed(node, path2, negated) {
+  if (isLeaf(node)) {
+    if (!isEventLeaf(node)) return { paths: [] };
+    if (negated) return { error: `"not" is applied to ${say(node.kind)} (${path2}) \u2014 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: path2,
+      kind: node.kind
+    }] };
+  }
+  if (node.kind === "not") return eventNeed(node.child, `${path2}.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, `${path2}.${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: [] };
+}
+function validateWhenTree(when) {
+  if (hasEmptyContainer(when)) return "a group is empty \u2014 group existing rows instead of leaving a container to fill";
+  const depth = whenDepth(when);
+  if (depth > 4) return `the rules nest ${depth} levels deep \u2014 the limit is 4. "not (any of \u2026)" is the same as "all of (not \u2026)", which is one level shallower`;
+  const leaves = countWhenLeaves(when);
+  if (leaves > 32) return `the rules use ${leaves} rows \u2014 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 \u2014 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;
+}
+var LegacyTriggerSchema = z4.discriminatedUnion("kind", [
   z4.object({
     kind: z4.literal("device-state"),
     deviceId: z4.number().int().nonnegative(),
     cap: z4.string().min(1),
     fieldPath: z4.string().min(1),
-    /** Fire when the field takes this value. Omit to fire on any change. */
     becomes: z4.union([
       z4.string(),
       z4.number(),
       z4.boolean()
     ]).optional(),
-    /** Only on a CHANGE of value, not on every re-report. */
     edge: z4.boolean().optional(),
-    /** The condition must hold this long before the run starts. */
     forMs: z4.number().int().min(0).max(864e5).optional(),
-    /** Collapse a burst into one run. */
     debounceMs: z4.number().int().min(0).max(6e5).optional()
   }),
   z4.object({
     kind: z4.literal("device-event"),
-    /** An `EventCategory` value. */
     category: z4.string().min(1),
     deviceId: z4.number().int().nonnegative().optional()
   }),
@@ -7402,25 +7706,16 @@ var AutomationTriggerSchema = z4.discriminatedUnion("kind", [
   z4.object({ kind: z4.literal("manual") }),
   z4.object({
     kind: z4.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: z4.array(z4.string().min(1)).min(1),
     deviceIds: z4.array(z4.number().int().nonnegative()).min(1),
-    /** The track must have visited at least one of these zones. */
     zones: z4.array(z4.string().min(1)).min(1).optional(),
-    /** Best-so-far confidence the track must reach. */
     minScore: z4.number().min(0).max(1).optional()
   }),
   z4.object({
     kind: z4.literal("stationary"),
     deviceIds: z4.array(z4.number().int().nonnegative()).min(1),
-    /** Class names; a macro class matches like the detection trigger. */
     classes: z4.array(z4.string().min(1)).min(1).optional(),
-    /** The parked object must be in at least one of these zones. */
     zones: z4.array(z4.string().min(1)).min(1).optional(),
-    /** `appeared`: it became parked. `departed`: the registry retired it.
-    *  The vocabulary of `PipelineAnalyticsStationaryChanged`. */
     phase: z4.enum(["appeared", "departed"])
   }),
   z4.object({
@@ -7428,6 +7723,123 @@ var AutomationTriggerSchema = z4.discriminatedUnion("kind", [
     minutes: z4.number().int().min(1).max(1440)
   })
 ]);
+var LegacyConditionLeafSchema = z4.object({
+  kind: z4.literal("condition"),
+  deviceId: z4.number().int().nonnegative(),
+  cap: z4.string().min(1),
+  fieldPath: z4.string().min(1),
+  operator: AutomationConditionOperatorSchema,
+  value: z4.union([
+    z4.string(),
+    z4.number(),
+    z4.boolean(),
+    z4.array(z4.union([z4.string(), z4.number()])),
+    QuantityValueSchema
+  ]),
+  unit: z4.string().min(1).optional()
+});
+var LegacyStationaryPresentSchema = z4.object({
+  kind: z4.literal("stationary-present"),
+  deviceId: z4.number().int().nonnegative(),
+  classes: z4.array(z4.string().min(1)).min(1).optional(),
+  zones: z4.array(z4.string().min(1)).min(1).optional()
+});
+var LegacyExpressionSchema = z4.object({
+  kind: z4.literal("expression"),
+  expr: z4.string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+  bindings: z4.record(z4.string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+}).superRefine((src, ctx) => {
+  const err = validateExpressionSource(src);
+  if (err !== null) ctx.addIssue({
+    code: "custom",
+    message: err,
+    path: ["expr"]
+  });
+});
+var LegacyConditionSchema = z4.lazy(() => z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("all"),
+    children: z4.array(LegacyConditionSchema)
+  }),
+  z4.object({
+    kind: z4.literal("any"),
+    children: z4.array(LegacyConditionSchema)
+  }),
+  z4.object({
+    kind: z4.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;
+  }
+}
+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)
+      };
+  }
+}
+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)]
+  };
+}
 var AutomationWaitStepSchema = z4.object({
   kind: z4.literal("wait"),
   seconds: z4.number().min(0).max(300)
@@ -7495,54 +7907,34 @@ var AutomationRunModeSchema = z4.discriminatedUnion("mode", [
     minutes: z4.number().int().min(1).max(1440)
   })
 ]);
-var AutomationRecipeSchema = z4.object({
-  triggers: z4.array(AutomationTriggerSchema),
-  conditions: AutomationConditionSchema.optional(),
+var CurrentAutomationRecipeSchema = z4.object({
+  when: AutomationWhenSchema,
   actions: z4.array(AutomationActionSchema),
   runMode: AutomationRunModeSchema.optional(),
   /** How many run traces the automation keeps (default {@link DEFAULT_TRACE_KEEP}). */
   keepTraces: z4.number().int().min(1).max(100).optional()
 });
-function isLeaf(cond) {
-  return cond.kind === "condition" || cond.kind === "expression" || cond.kind === "stationary-present";
-}
-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;
-}
-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);
+var LegacyAutomationRecipeSchema = z4.object({
+  triggers: z4.array(LegacyTriggerSchema),
+  conditions: LegacyConditionSchema.optional(),
+  actions: z4.array(AutomationActionSchema),
+  runMode: AutomationRunModeSchema.optional(),
+  keepTraces: z4.number().int().min(1).max(100).optional()
+});
+function convertLegacyRecipe(legacy) {
+  const { triggers, conditions, ...rest } = legacy;
+  return {
+    when: convertLegacyWhen({
+      triggers,
+      conditions
+    }),
+    ...rest
+  };
 }
+var AutomationRecipeSchema = z4.union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
 function validateRecipeBounds(recipe) {
-  if (recipe.triggers.length === 0) return "an automation needs at least one trigger \u2014 without one nothing can start a run";
   if (recipe.actions.length === 0) return "an automation needs at least one action \u2014 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 \u2014 group existing rows instead of leaving a container to fill";
-    const depth = conditionDepth(cond);
-    if (depth > 3) return `conditions nest ${depth} levels deep \u2014 the limit is 3. "not (any of \u2026)" is the same as "all of (not \u2026)", which is one level shallower`;
-    const leaves = countConditionLeaves(cond);
-    if (leaves > 32) return `conditions use ${leaves} leaves \u2014 the limit is 32`;
-  }
-  return null;
+  return validateWhenTree(recipe.when);
 }
 var RECONCILE_MS = 15e3;
 function stepMetaOf(action) {
@@ -7565,10 +7957,11 @@ function stepMetaOf(action) {
 function j(value) {
   return JSON.stringify(value);
 }
-function emitTrigger(trigger, index) {
+function emitLeaf(trigger, path2) {
+  const at = j(path2);
   switch (trigger.kind) {
     case "schedule":
-      return `  // trigger ${index}: schedule \u2014 armed to the next minute boundary and
+      return `  // event leaf ${path2}: schedule \u2014 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.
   {
@@ -7576,7 +7969,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())
@@ -7585,13 +7978,14 @@ function emitTrigger(trigger, index) {
     disposers.push(() => { if (timer !== undefined) clearTimeout(timer) })
   }`;
     case "device-event":
-      return `  // trigger ${index}: device event
+      return `  // event leaf ${path2}: 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)},
@@ -7599,9 +7993,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 \u2014 the mirror is the authority, the
+      return `  // event leaf ${path2}: device state \u2014 the mirror is the authority, the
   // event only WAKES the evaluation, so a dropped event delays and never loses.
   {
     let previous: unknown = undefined
@@ -7622,7 +8016,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)},
@@ -7642,17 +8037,17 @@ function emitTrigger(trigger, index) {
   }`;
     }
     case "manual":
-      return `  // trigger ${index}: manual \u2014 fired by automation-control.trigger
+      return `  // event leaf ${path2}: manual \u2014 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 \u2014 every ${trigger.minutes} min, first run jittered so
+      return `  // event leaf ${path2}: interval \u2014 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)
@@ -7660,7 +8055,7 @@ function emitTrigger(trigger, index) {
     })
   }`;
     case "detection":
-      return `  // trigger ${index}: detection \u2014 ONE fire per (device, track); a rejected event is
+      return `  // event leaf ${path2}: detection \u2014 ONE fire per (device, track); a rejected event is
   // traced with its reason and never fires.
   {
     const filter = new DetectionTriggerFilter(${j(trigger)})
@@ -7677,7 +8072,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',
           )
@@ -7686,9 +8081,9 @@ function emitTrigger(trigger, index) {
     )
   }`;
     case "stationary":
-      return `  // trigger ${index}: stationary \u2014 a parked object appeared / departed. Stateless:
+      return `  // event leaf ${path2}: stationary \u2014 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(
@@ -7704,7 +8099,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',
           )
@@ -7727,11 +8122,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({
@@ -7756,6 +8151,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, path2) => {
+    if (isEventLeaf(leaf)) eventLeaves.push({
+      leaf,
+      path: path2
+    });
+  });
   return `import type {
   AddonContext,
   AutomationConditionTraceNode,
@@ -7763,6 +8165,7 @@ function generateAutomationBlock(input) {
   AutomationRunVerdict,
   AutomationStepTrace,
   RunnableStep,
+  StepScope,
 } from '@camstack/types'
 import {
   ConditionMirror,
@@ -7770,9 +8173,9 @@ import {
   EventCategory,
   RunGate,
   buildTriggerTrace,
-  collectMirrorSources,
+  collectWhenMirrorSources,
   coreBlockIdFromAddonId,
-  evaluateConditionTree,
+  evaluateWhenTree,
   evaluateStationaryTrigger,
   isSkippedTrace,
   mergeSkipTraces,
@@ -7800,7 +8203,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 \u2192 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
@@ -7859,7 +8266,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
@@ -8025,6 +8433,7 @@ export default function block(ctx: AddonContext) {
   }
 
   async function actuate(
+    scope: StepScope,
     deviceId: number,
     cap: string,
     method: string,
@@ -8034,6 +8443,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 \u2014 reject only null/undefined.
     const client: unknown = Reflect.get(ctx.api, capToRouterKey(cap))
@@ -8122,10 +8532,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 \u2014 treated as false', {
             tags: { deviceId: node.deviceId },
             path: node.path,
@@ -8136,7 +8549,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
       }
       if (!evaluation.pass) {
         outcome = 'skipped-conditions'
-        ctx.logger.debug('automation did not run \u2014 conditions were false', { trigger, ...deviceTags(trigger) })
+        ctx.logger.debug('automation did not run \u2014 the rule tree was false at that instant', { trigger, ...deviceTags(trigger) })
         return
       }
       const letThrough = stampUnknown && RUN_MODE.mode === 'cooldown'
@@ -8235,9 +8648,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 \u2014 a tree of states only. It fires when the tree goes false \u2192 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
@@ -8245,14 +8679,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((t2, i) => emitTrigger(t2, i)).join("\n\n")}
+${eventLeaves.map(({ leaf, path: path2 }) => emitLeaf(leaf, path2)).join("\n\n")}
 
   return () => {
     stopped = true
@@ -8267,52 +8704,6 @@ ${recipe.triggers.map((t2, i) => emitTrigger(t2, i)).join("\n\n")}
 }
 `;
 }
-var MACRO_LABELS = [
-  {
-    id: "person",
-    name: "Person"
-  },
-  {
-    id: "vehicle",
-    name: "Vehicle"
-  },
-  {
-    id: "animal",
-    name: "Animal"
-  },
-  {
-    id: "package",
-    name: "Package"
-  }
-];
-var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
-var COCO_TO_MACRO = {
-  mapping: {
-    person: "person",
-    bicycle: "vehicle",
-    car: "vehicle",
-    motorcycle: "vehicle",
-    airplane: "vehicle",
-    bus: "vehicle",
-    train: "vehicle",
-    truck: "vehicle",
-    boat: "vehicle",
-    bird: "animal",
-    cat: "animal",
-    dog: "animal",
-    horse: "animal",
-    sheep: "animal",
-    cow: "animal",
-    elephant: "animal",
-    bear: "animal",
-    zebra: "animal",
-    giraffe: "animal",
-    suitcase: "package",
-    backpack: "package",
-    handbag: "package"
-  },
-  preserveOriginal: false
-};
 var MACRO_NAMES = new Set(Object.values(COCO_TO_MACRO.mapping));
 var TraceValueSchema = z4.union([
   z4.string(),
@@ -8337,6 +8728,8 @@ var TraceNodeOutcomeSchema = z4.enum([
 ]);
 var AutomationTriggerTraceSchema = z4.object({
   kind: z4.string().min(1),
+  /** The event leaf that fired (`when`, `when.0.1`); absent on traces written before the single tree. */
+  path: z4.string().min(1).optional(),
   outcome: z4.enum(["pass", "fail"]),
   /** Why an event was rejected ("class person not in [dog]") or what fired. */
   reason: z4.string(),
@@ -8344,15 +8737,23 @@ var AutomationTriggerTraceSchema = z4.object({
   vars: z4.record(z4.string(), TraceValueSchema)
 });
 var AutomationConditionTraceNodeSchema = z4.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: z4.string().min(1),
   kind: z4.enum([
     "all",
     "any",
     "not",
     "condition",
+    "device-is",
     "expression",
-    "stationary-present"
+    "stationary-present",
+    "device-becomes",
+    "device-event",
+    "schedule",
+    "interval",
+    "manual",
+    "detection",
+    "stationary"
   ]),
   outcome: TraceNodeOutcomeSchema,
   reason: z4.string(),
@@ -8385,6 +8786,12 @@ var AutomationStepTraceSchema = z4.object({
   deviceId: z4.number().int().optional(),
   startedAt: z4.number().optional(),
   endedAt: z4.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: z4.record(z4.string(), TraceValueSchema).optional(),
   outcome: z4.enum([
     "ok",
     "error",
@@ -8652,9 +9059,9 @@ function normalizeLeaf(leaf, resolver, path2) {
     })]
   };
 }
-function normalizeConditionUnits(condition, resolver, path2 = "conditions") {
+function normalizeConditionUnits(condition, resolver, path2 = "when") {
   switch (condition.kind) {
-    case "condition": {
+    case "device-is": {
       const { leaf, warnings } = normalizeLeaf(condition, resolver, path2);
       return {
         value: leaf,
@@ -8745,20 +9152,20 @@ function normalizeActionUnits(actions, resolver, path2 = "steps") {
   };
 }
 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]
   };
 }
 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;
@@ -8799,7 +9206,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 {
@@ -9288,6 +9695,25 @@ var addonSettingsCapability = {
       addonId: z4.string(),
       nodeId: z4.string().optional()
     }), SettingsSchemaWithValuesSchema.nullable()),
+    getDeclaredSettingsKeys: method(z4.object({
+      addonId: z4.string(),
+      nodeId: z4.string().optional()
+    }), z4.object({ keys: z4.array(z4.string()) }).nullable(), { auth: "admin" }),
+    unsetStoredSettingsKeys: method(z4.object({
+      addonId: z4.string(),
+      nodeId: z4.string().optional(),
+      keys: z4.array(z4.string())
+    }), z4.object({
+      removed: z4.array(z4.string()),
+      refused: z4.array(z4.object({
+        key: z4.string(),
+        reason: z4.string()
+      })),
+      secretsCleared: z4.number()
+    }), {
+      kind: "mutation",
+      auth: "admin"
+    }),
     getDeviceSettings: method(z4.object({
       addonId: z4.string(),
       deviceId: z4.number(),
@@ -14154,6 +14580,8 @@ var StorageKindSchema = z4.object({
     "orphaned",
     "dropped"
   ]),
+  /** An owner declared this kind since the engine started. */
+  declaredThisBoot: z4.boolean(),
   /** `null` when the caller asked for no counts (`counts: false`). */
   rows: z4.number().int().nonnegative().nullable(),
   /** Rows x the average size of a sample; null for an empty kind. */
@@ -14165,6 +14593,48 @@ var StorageKindSchema = z4.object({
   /** The whole declaration, secret paths and entry descriptor included (the entries service builds its handle from it). */
   declaration: RecordKindDeclarationSchema
 });
+z4.enum([
+  "orphaned",
+  "stale",
+  "unknown"
+]);
+var StaleKindFindingSchema = z4.object({
+  owner: z4.string(),
+  kind: z4.string(),
+  /** `unknown`: the owner could not be judged (not running, or its state unreadable) - never dropped. */
+  verdict: z4.enum(["orphaned", "unknown"]),
+  reason: z4.string(),
+  rows: z4.number().int().nonnegative().nullable(),
+  /** local-auth's tables are never dropped by this audit. */
+  protected: z4.boolean()
+});
+var StaleSettingsKeyFindingSchema = z4.object({
+  addonId: z4.string(),
+  /** The stored key as written, a per-node `<key>@<nodeId>` suffix included. */
+  key: z4.string(),
+  /**
+  * Keychain refs whose ONLY marker sits under this key: in use by stale data,
+  * not orphans yet. Removing the key releases them.
+  */
+  secretRefs: z4.array(z4.string())
+});
+var StaleUnknownSchema = z4.object({
+  subject: z4.string(),
+  reason: z4.string()
+});
+var StaleDataReportSchema = z4.object({
+  /** Epoch ms of the last finished scan; `null` before the first. */
+  scannedAt: z4.number().nullable(),
+  scanning: z4.boolean(),
+  trigger: z4.enum([
+    "boot",
+    "interval",
+    "manual"
+  ]).nullable(),
+  kinds: z4.array(StaleKindFindingSchema),
+  settingsKeys: z4.array(StaleSettingsKeyFindingSchema),
+  unknown: z4.array(StaleUnknownSchema)
+});
 var storageAdminCapability = {
   name: "storage-admin",
   scope: "system",
@@ -14189,7 +14659,49 @@ var storageAdminCapability = {
     readRecords: method(RecordQueryInputSchema.extend({
       owner: z4.string().min(1),
       kind: 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: method(z4.object({}), StaleDataReportSchema, { auth: "admin" }),
+    /** Scan now. Detection only: it logs findings (owner and key, never values) and changes nothing. */
+    scanStaleData: method(z4.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: method(z4.object({
+      owner: z4.string().min(1),
+      kind: RecordKindNameSchema
+    }), z4.object({
+      deleted: z4.number().int().nonnegative(),
+      secretsReleased: z4.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: method(z4.object({
+      addonId: z4.string().min(1),
+      key: z4.string().min(1)
+    }), z4.object({
+      removed: z4.boolean(),
+      secretsCleared: z4.number().int().nonnegative()
+    }), {
+      kind: "mutation",
+      auth: "admin",
+      caller: "required"
+    })
   }
 };
 var EntryKindInfoSchema = z4.object({
@@ -14321,6 +14833,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: method(z4.object({
+      refs: RefListSchema,
+      onBehalfOf: z4.string().min(1)
+    }), z4.object({ released: z4.number().int() }), {
+      kind: "mutation",
+      auth: "admin"
+    }),
     /** The caller's own refs, metadata only. */
     listMeta: method(z4.object({}), z4.array(KeychainSecretMetaSchema).readonly(), { auth: "admin" }),
     /** Whether values can be served — the save path refuses a write while locked. */
@@ -15215,7 +15740,9 @@ var DiscoveredChildDeviceSchema = z4.lazy(() => z4.object({
   /** Upstream-system identity + rendering hints for the candidate. */
   sourceInfo: SourceInfoSchema.optional(),
   /** Nested entity-children for accordion preview — integrations populate, Hubs omit. */
-  children: z4.array(DiscoveredChildDeviceSchema).readonly().optional()
+  children: z4.array(DiscoveredChildDeviceSchema).readonly().optional(),
+  /** `childNativeId` of the gateway candidate in the same list this device sits behind. */
+  parentStableId: z4.string().optional()
 }));
 var DeviceDiscoveryStatusSchema = z4.object({
   discovered: z4.array(DiscoveredChildDeviceSchema),
@@ -35433,6 +35960,71 @@ var DiscoveredDeviceSchema = z4.object({
   type: z4.string(),
   metadata: z4.record(z4.string(), z4.unknown()).optional()
 });
+var DiscoveryModeSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("mdns"),
+    /** DNS-SD service type, e.g. `_esphomelib._tcp`. */
+    serviceType: z4.string().min(1),
+    /** Regular expression an instance name must match (case-insensitive). */
+    instancePattern: z4.string().optional()
+  }),
+  z4.object({
+    kind: z4.literal("ws-discovery"),
+    /** Probe types (e.g. `dn:NetworkVideoTransmitter`); omitted = any device. */
+    types: z4.array(z4.string()).optional()
+  }),
+  z4.object({
+    kind: z4.literal("ssdp"),
+    searchTarget: z4.string().min(1)
+  }),
+  z4.object({
+    kind: z4.literal("udp-broadcast"),
+    port: z4.number().int().min(1).max(65535),
+    payloadHex: z4.string().regex(/^([0-9a-fA-F]{2})*$/),
+    /** Port replies arrive on, when the device answers somewhere other than the source port. */
+    listenPort: z4.number().int().min(1).max(65535).optional()
+  }),
+  z4.object({
+    kind: z4.literal("http-probe"),
+    port: z4.number().int().min(1).max(65535),
+    path: z4.string().startsWith("/"),
+    method: z4.enum(["GET", "POST"]).default("GET"),
+    bodyText: z4.string().optional(),
+    contentType: z4.string().optional(),
+    tls: z4.boolean().default(false),
+    /** Status codes that count as a hit. Omitted = any HTTP answer. */
+    acceptStatus: z4.array(z4.number().int()).optional()
+  }),
+  z4.object({
+    kind: z4.literal("custom"),
+    /** Why the engine cannot do it (an allowlisted exception, e.g. a vendor UDP protocol). */
+    reason: z4.string().min(1)
+  })
+]);
+var DiscoveryHitSchema = z4.object({
+  /** Index into the provider's own `getDiscoveryModes()` array. */
+  modeIndex: z4.number().int().min(0),
+  host: z4.string(),
+  port: z4.number().int(),
+  http: z4.object({
+    status: z4.number().int(),
+    headers: z4.record(z4.string(), z4.string()),
+    /** At most 16 KiB. */
+    bodyText: z4.string()
+  }).optional(),
+  mdns: z4.object({
+    instance: z4.string(),
+    host: z4.string(),
+    port: z4.number().int(),
+    txt: z4.record(z4.string(), z4.string())
+  }).optional(),
+  udp: z4.object({ payloadHex: z4.string() }).optional(),
+  wsd: z4.object({
+    xaddrs: z4.array(z4.string()),
+    types: z4.array(z4.string()),
+    scopes: z4.array(z4.string())
+  }).optional()
+});
 var DiscoveryCandidateSchema = z4.object({
   stableId: z4.string(),
   type: z4.enum(DeviceType),
@@ -35463,7 +36055,17 @@ var DiscoveryCandidateSchema = z4.object({
   /** Numeric id of the device this candidate was matched to. Set with `alreadyOnboarded`. */
   onboardedDeviceId: z4.number().optional(),
   /** Operator-facing name of the matched device, so the UI can say WHICH one it is. */
-  onboardedName: z4.string().optional()
+  onboardedName: z4.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: z4.boolean().optional(),
+  /** `stableId` of the gateway candidate this device was found BEHIND. */
+  parentStableId: z4.string().optional(),
+  /** `false` = shown for context but not pickable. Default true. */
+  selectable: z4.boolean().optional()
 });
 var DeviceSummarySchema = z4.object({
   id: z4.number(),
@@ -35541,6 +36143,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: method(z4.object({}), z4.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: method(z4.object({
+      hits: z4.array(DiscoveryHitSchema),
+      params: z4.record(z4.string(), z4.unknown()).optional()
+    }), z4.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
@@ -36796,20 +37416,26 @@ var deviceManagerCapability = {
       label: z4.string()
     })).readonly() }), { auth: "admin" }),
     /** Scan EVERY discovery-capable provider; returns candidates grouped by addon. */
-    discoverAllProviders: method(z4.object({}), z4.object({ groups: z4.array(z4.object({
-      addonId: z4.string(),
-      label: z4.string(),
-      candidates: z4.array(DiscoveryCandidateSchema).readonly(),
-      error: z4.string().nullable()
-    })).readonly() }), {
-      kind: "mutation",
-      auth: "admin"
-    }),
+    discoverAllProviders: method(
+      /** `subnets`: extra CIDRs for THIS scan, on top of the hub's own and the saved list. */
+      z4.object({ subnets: z4.array(z4.string()).optional() }),
+      z4.object({ groups: z4.array(z4.object({
+        addonId: z4.string(),
+        label: z4.string(),
+        candidates: z4.array(DiscoveryCandidateSchema).readonly(),
+        error: z4.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: method(z4.object({
       addonId: z4.string(),
-      params: z4.record(z4.string(), z4.unknown()).optional()
+      params: z4.record(z4.string(), z4.unknown()).optional(),
+      subnets: z4.array(z4.string()).optional()
     }), z4.object({ candidates: z4.array(DiscoveryCandidateSchema).readonly() }), {
       kind: "mutation",
       auth: "admin"
@@ -56177,7 +56803,9 @@ var integrationsCapability = {
       id: z4.string(),
       settings: z4.record(z4.string(), z4.unknown()),
       /** Keys the form's schema declares secret (by type) — keychain-stored (D787). */
-      secretKeys: z4.array(z4.string()).optional()
+      secretKeys: z4.array(z4.string()).optional(),
+      /** The integration's own addon applies the change in-process and asks the hub not to respawn it. */
+      skipRestart: z4.boolean().optional()
     }), z4.object({ success: z4.boolean() }), {
       kind: "mutation",
       auth: "admin"
@@ -56713,6 +57341,37 @@ var TlsStatusSchema = z4.object({
     hasCa: z4.boolean()
   }).nullable()
 });
+var ScanRequestSchema = z4.object({
+  providerId: z4.string().min(1),
+  modes: z4.array(DiscoveryModeSchema)
+});
+var ScanErrorSchema = z4.object({
+  /** Absent for a failure that is the scan's own (a bad subnet, a socket that would not open). */
+  providerId: z4.string().optional(),
+  /** The mode family that failed (`mdns`, `http-probe`, …). */
+  mode: z4.string().optional(),
+  message: z4.string()
+});
+var ScanStatsSchema = z4.object({
+  hostsProbed: z4.number().int(),
+  hits: z4.number().int(),
+  timeouts: z4.number().int(),
+  byMode: z4.record(z4.string(), z4.object({
+    probed: z4.number().int(),
+    hits: z4.number().int(),
+    timeouts: z4.number().int()
+  }))
+});
+var ScanNetworkResultSchema = z4.object({
+  hits: z4.array(z4.object({
+    providerId: z4.string(),
+    hit: DiscoveryHitSchema
+  })),
+  /** CIDRs actually covered: the hub's own /24s, the saved list and the per-call list. */
+  subnetsScanned: z4.array(z4.string()),
+  errors: z4.array(ScanErrorSchema),
+  stats: ScanStatsSchema
+});
 var localNetworkCapability = {
   name: "local-network",
   scope: "system",
@@ -56926,6 +57585,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: method(z4.object({
+      requests: z4.array(ScanRequestSchema),
+      subnets: z4.array(z4.string()).optional()
+    }), ScanNetworkResultSchema, {
+      kind: "mutation",
+      auth: "admin",
+      timeoutMs: 9e4
+    }),
+    /** Extra subnets every scan covers besides the hub's own, as CIDR strings. */
+    getScanSubnets: method(z4.void(), z4.object({ subnets: z4.array(z4.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: method(z4.object({ subnets: z4.array(z4.string()) }), z4.object({ subnets: z4.array(z4.string()) }), {
+      kind: "mutation",
+      auth: "admin"
+    }),
     /** Return to the generated local CA. The uploaded certificate stays stored (D873). */
     revertToGeneratedCertificate: method(z4.void(), TlsStatusSchema, {
       kind: "mutation",
@@ -66357,6 +67044,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",
@@ -66378,6 +67072,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",
@@ -68793,6 +69494,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",
@@ -68821,6 +69529,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",
@@ -69598,6 +70313,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",
@@ -70018,6 +70740,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",
@@ -70067,6 +70796,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",
@@ -70088,6 +70824,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",
@@ -74309,6 +75052,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",
@@ -74330,6 +75080,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",
@@ -85341,10 +86112,12 @@ function describeHub(hub) {
 export {
   isReadingQuantity,
   FFMPEG_PATH_ENV,
+  MACRO_LABELS,
+  countWhenLeaves,
+  convertLegacyWhen,
   AutomationRecipeSchema,
   validateRecipeBounds,
   generateAutomationBlock,
-  MACRO_LABELS,
   unitsForQuantity,
   capUnitResolver,
   prepareRecipeUnits,