camstack 1.2.210 → 1.2.211

package/dist/{chunk-EMTOU2RA.js → chunk-NAUJQNCX.js}

@@ -1724,6 +1724,9 @@ var READING_QUANTITIES = [
 ];
 var ReadingQuantitySchema = z2.enum(READING_QUANTITIES);
 var QUANTITY_SET = new Set(READING_QUANTITIES);
+function isReadingQuantity(value) {
+  return typeof value === "string" && QUANTITY_SET.has(value);
+}
 var QUANTITY_BASE = {
   temperature: "\xB0C",
   pressure: "hPa",
@@ -6747,6 +6750,63 @@ var ExpressionSourceSchema = z4.object({
     path: ["expr"]
   });
 });
+function unwrapSchema(schema) {
+  let s = schema;
+  while (s instanceof z4.ZodNullable || s instanceof z4.ZodOptional || s instanceof z4.ZodDefault) s = s.unwrap();
+  return s;
+}
+function isMetaBag(value) {
+  return typeof value === "object" && value !== null;
+}
+function metaQuantity(schema) {
+  const bag = z4.globalRegistry.get(schema);
+  if (isMetaBag(bag) && isReadingQuantity(bag.quantity)) return bag.quantity;
+}
+function quantityOfField(schema) {
+  return metaQuantity(schema) ?? metaQuantity(unwrapSchema(schema));
+}
+function leafKind(schema) {
+  const s = unwrapSchema(schema);
+  if (s instanceof z4.ZodEnum) return {
+    kind: "enum",
+    enumValues: s.options
+  };
+  if (s instanceof z4.ZodNumber) return { kind: "number" };
+  if (s instanceof z4.ZodString) return { kind: "string" };
+  if (s instanceof z4.ZodBoolean) return { kind: "boolean" };
+  return null;
+}
+function enumerateSchemaFields(schema, prefix = "") {
+  const root = unwrapSchema(schema);
+  if (!(root instanceof z4.ZodObject)) return [];
+  const out = [];
+  const shape = root.shape;
+  for (const [key, field] of Object.entries(shape)) {
+    const path2 = prefix ? `${prefix}.${key}` : key;
+    const inner = unwrapSchema(field);
+    if (inner instanceof z4.ZodObject) {
+      out.push(...enumerateSchemaFields(inner, path2));
+      continue;
+    }
+    const leaf = leafKind(field);
+    if (leaf) {
+      const quantity = quantityOfField(field);
+      out.push({
+        path: path2,
+        kind: leaf.kind,
+        ...leaf.enumValues ? { enumValues: leaf.enumValues } : {},
+        ...quantity !== void 0 ? { quantity } : {}
+      });
+    }
+  }
+  return out;
+}
+function enumerateItemArrayFields(itemArray) {
+  return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
+    ...f,
+    item: true
+  }));
+}
 var SourceInfoSchema = z4.object({
   /** Live dispatch key — mutable when the source system allows rename. */
   id: z4.string(),
@@ -6768,6 +6828,69 @@ var SourceInfoSchema = z4.object({
   *  attribute blobs (would explode the meta JSON column). */
   raw: z4.record(z4.string(), z4.unknown()).optional()
 });
+function normalizeUnit(raw) {
+  if (raw == null) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed === "") return void 0;
+  const lower = trimmed.toLowerCase();
+  if (lower === "\xB0c" || lower === "c" || lower === "celsius") return "\xB0C";
+  if (lower === "\xB0f" || lower === "f" || lower === "fahrenheit") return "\xB0F";
+  if (lower === "k" || lower === "kelvin") return "K";
+  if (lower === "%" || lower === "percent" || lower === "percentage") return "%";
+  if (lower === "lx" || lower === "lux") return "lx";
+  if (lower === "hpa" || lower === "hectopascal") return "hPa";
+  if (lower === "kpa") return "kPa";
+  if (lower === "pa") return "Pa";
+  if (lower === "mbar" || lower === "millibar") return "mbar";
+  if (lower === "w" || lower === "watt") return "W";
+  if (lower === "kw" || lower === "kilowatt") return "kW";
+  if (lower === "wh" || lower === "watt-hour") return "Wh";
+  if (lower === "kwh" || lower === "kilowatt-hour") return "kWh";
+  if (lower === "v" || lower === "volt") return "V";
+  if (lower === "a" || lower === "amp" || lower === "ampere") return "A";
+  if (lower === "ma" || lower === "milliampere") return "mA";
+  if (lower === "va") return "VA";
+  if (lower === "ppm") return "ppm";
+  if (lower === "ppb") return "ppb";
+  if (lower === "\xB5g/m\xB3" || lower === "ug/m3" || lower === "\xB5g/m3") return "\xB5g/m\xB3";
+  if (lower === "km/h" || lower === "kph") return "km/h";
+  if (lower === "mph") return "mph";
+  if (lower === "m/s") return "m/s";
+  if (lower === "m") return "m";
+  if (lower === "m\xB2" || lower === "m2") return "m\xB2";
+  if (lower === "mm") return "mm";
+  if (lower === "cm") return "cm";
+  if (lower === "km") return "km";
+  if (lower === "in" || lower === "inch" || lower === "inches") return "in";
+  if (lower === "ft" || lower === "foot" || lower === "feet") return "ft";
+  if (lower === "kg") return "kg";
+  if (lower === "g") return "g";
+  if (lower === "l" || lower === "liter" || lower === "litre" || lower === "liters" || lower === "litres") return "L";
+  if (lower === "ml") return "mL";
+  if (lower === "gal" || lower === "gallon" || lower === "gallons") return "gal";
+  if (lower === "s" || lower === "sec" || lower === "second" || lower === "seconds") return "s";
+  if (lower === "ms") return "ms";
+  if (lower === "min" || lower === "minute" || lower === "minutes") return "min";
+  if (lower === "h" || lower === "hr" || lower === "hour" || lower === "hours") return "h";
+  if (lower === "d" || lower === "day" || lower === "days") return "d";
+  if (lower === "b" || lower === "byte" || lower === "bytes") return "B";
+  if (lower === "kib") return "KiB";
+  if (lower === "mib") return "MiB";
+  if (lower === "gib") return "GiB";
+  if (lower === "tib") return "TiB";
+  if (lower === "kb") return "kB";
+  if (lower === "mb") return "MB";
+  if (lower === "gb") return "GB";
+  if (lower === "dbm") return "dBm";
+  if (lower === "dbfs") return "dBFS";
+  if (lower === "inhg") return "inHg";
+  if (lower === "mm/h") return "mm/h";
+  if (lower === "w/m\xB2" || lower === "w/m2") return "W/m\xB2";
+  if (lower === "\xB0" || lower === "deg" || lower === "degree" || lower === "degrees") return "\xB0";
+  if (lower === "kbps") return "kbps";
+  if (lower === "fps") return "fps";
+  return trimmed;
+}
 var UNIT_TABLE = {
   "\xB0C": {
     dimension: "temperature",
@@ -7118,6 +7241,9 @@ var UNIT_TABLE = {
 function specFor(unit) {
   return Object.hasOwn(UNIT_TABLE, unit) ? UNIT_TABLE[unit] : void 0;
 }
+function unitDimension(unit) {
+  return specFor(unit)?.dimension;
+}
 function toCanonical(value, spec) {
   return value * spec.factor + spec.offset;
 }
@@ -7133,6 +7259,11 @@ function tryConvertUnit(value, from, to) {
   if (fromSpec.dimension !== toSpec.dimension) return void 0;
   return fromCanonical(toCanonical(value, fromSpec), toSpec);
 }
+function unitsForDimension(dimension) {
+  const out = [];
+  for (const [unit, spec] of Object.entries(UNIT_TABLE)) if (spec.dimension === dimension) out.push(unit);
+  return out;
+}
 var QuantityUnitError = class extends Error {
   code;
   constructor(code, message) {
@@ -7145,6 +7276,17 @@ var QuantityValueSchema = z4.object({
   value: z4.number(),
   unit: z4.string().min(1)
 });
+function isQuantityValue(candidate) {
+  return QuantityValueSchema.safeParse(candidate).success;
+}
+function convertQuantityInput(input) {
+  if (!Number.isFinite(input.value)) throw new QuantityUnitError("non-finite", `${String(input.value)} is not a finite number`);
+  const unit = normalizeUnit(input.unit);
+  if (unit === void 0 || unitDimension(unit) === void 0) throw new QuantityUnitError("unknown-unit", `unknown unit "${input.unit}"`);
+  const converted = tryConvertUnit(input.value, unit, input.target);
+  if (converted === void 0) throw new QuantityUnitError("cross-dimension", `"${input.unit}" is not a unit of ${input.target}'s quantity`);
+  return Number(converted.toPrecision(12));
+}
 function paramMeta(declared) {
   const base = baseUnitOf(declared.quantity);
   if (base === void 0) throw new QuantityUnitError("unknown-unit", `quantity "${declared.quantity}" has no unit`);
@@ -7158,6 +7300,13 @@ var ParamMetaBagSchema = z4.object({
   quantity: ReadingQuantitySchema,
   unit: z4.string().min(1)
 });
+function metaOf(schema) {
+  const parsed = ParamMetaBagSchema.safeParse(z4.globalRegistry.get(schema));
+  return parsed.success ? parsed.data : void 0;
+}
+function paramMetaOf(field) {
+  return metaOf(field) ?? metaOf(unwrapSchema(field));
+}
 var AutomationConditionOperatorSchema = z4.enum([
   "eq",
   "ne",
@@ -7353,6 +7502,770 @@ var AutomationRecipeSchema = z4.object({
   /** 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);
+}
+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;
+}
+var RECONCILE_MS = 15e3;
+function stepMetaOf(action) {
+  switch (action.kind) {
+    case "wait":
+      return { kind: "wait" };
+    case "code":
+      return { kind: "code" };
+    case "action":
+      return { kind: "action" };
+    case "cap":
+      return {
+        kind: "cap",
+        cap: action.cap,
+        method: action.method,
+        ...typeof action.deviceId === "number" ? { deviceId: action.deviceId } : {}
+      };
+  }
+}
+function j(value) {
+  return JSON.stringify(value);
+}
+function emitTrigger(trigger, index) {
+  switch (trigger.kind) {
+    case "schedule":
+      return `  // trigger ${index}: 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.
+  {
+    let timer: ReturnType<typeof setTimeout> | undefined
+    const arm = (): void => {
+      timer = setTimeout(() => {
+        if (cronMatches(${j(trigger.cron)}, new Date())) {
+          void run({ kind: 'schedule', at: Date.now() })
+        }
+        arm()
+      }, nextMinuteBoundary())
+    }
+    arm()
+    disposers.push(() => { if (timer !== undefined) clearTimeout(timer) })
+  }`;
+    case "device-event":
+      return `  // trigger ${index}: 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',
+          at: Date.now(),
+          deviceId: event.deviceId,
+          category: ${j(trigger.category)},
+        })
+      },
+    ),
+  )`;
+    case "device-state": {
+      const becomes = trigger.becomes === void 0 ? "undefined" : j(trigger.becomes);
+      return `  // trigger ${index}: 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
+    let debounce: ReturnType<typeof setTimeout> | undefined
+    let heldSince: number | undefined
+    const check = async (): Promise<void> => {
+      const value = await readField(${j(trigger.deviceId)}, ${j(trigger.cap)}, ${j(trigger.fieldPath)})
+      const want = ${becomes}
+      const matches = want === undefined ? value !== previous : value === want
+      const changed = value !== previous
+      previous = value
+      if (!matches) { heldSince = undefined; return }
+      if (${trigger.edge === true ? "true" : "false"} && !changed) return
+      const forMs = ${j(trigger.forMs ?? 0)}
+      if (forMs > 0) {
+        if (heldSince === undefined) { heldSince = Date.now(); return }
+        if (Date.now() - heldSince < forMs) return
+      }
+      heldSince = undefined
+      void run({
+        kind: 'device-state',
+        at: Date.now(),
+        deviceId: ${j(trigger.deviceId)},
+        cap: ${j(trigger.cap)},
+        field: ${j(trigger.fieldPath)},
+        to: value,
+      })
+    }
+    const wake = (): void => {
+      if (debounce !== undefined) clearTimeout(debounce)
+      debounce = setTimeout(() => { void check() }, ${j(trigger.debounceMs ?? 0)})
+    }
+    disposers.push(
+      ctx.eventBus.subscribe({ category: 'device.state-changed', deviceId: ${j(trigger.deviceId)} }, wake),
+    )
+    const reconcile = setInterval(() => { void check() }, RECONCILE_MS)
+    disposers.push(() => clearInterval(reconcile))
+  }`;
+    }
+    case "manual":
+      return `  // trigger ${index}: 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
+  // 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)})
+    }, 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 \u2014 ONE fire per (device, track); a rejected event is
+  // traced with its reason and never fires.
+  {
+    const filter = new DetectionTriggerFilter(${j(trigger)})
+    disposers.push(
+      ctx.eventBus.subscribe(
+        { category: EventCategory.PipelineAnalyticsTrackLifecycle },
+        (event) => {
+          const decision = filter.evaluate(event.data, Date.now())
+          if (decision.kind === 'ignore') return
+          if (decision.kind === 'reject') {
+            ctx.logger.debug('detection trigger rejected an event', {
+              tags: { deviceId: decision.vars.deviceId },
+              reason: decision.reason,
+            })
+          }
+          void run(
+            { kind: 'detection', at: Date.now(), ...decision.vars },
+            decision.reason,
+            decision.kind === 'fire',
+          )
+        },
+      ),
+    )
+  }`;
+    case "stationary":
+      return `  // trigger ${index}: 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.
+  {
+    const trigger = ${j(trigger)} as const
+    disposers.push(
+      ctx.eventBus.subscribe(
+        { category: EventCategory.PipelineAnalyticsStationaryChanged },
+        (event) => {
+          const decision = evaluateStationaryTrigger(trigger, event.data)
+          if (decision.kind === 'ignore') return
+          if (decision.kind === 'reject') {
+            ctx.logger.debug('stationary trigger rejected an event', {
+              tags: { deviceId: decision.vars.deviceId },
+              reason: decision.reason,
+            })
+          }
+          void run(
+            { kind: 'stationary', at: Date.now(), ...decision.vars },
+            decision.reason,
+            decision.kind === 'fire',
+          )
+        },
+      ),
+    )
+  }`;
+  }
+}
+function emitAction(action, index) {
+  const step = (body) => `    {
+      meta: STEP_META[${index}]!,
+      run: async (scope) => {
+${body}
+      },
+    },`;
+  switch (action.kind) {
+    case "wait":
+      return step(`        await sleep(${j(action.seconds * 1e3)})`);
+    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)
+        }`);
+      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)`);
+    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)},
+          variables: substituteVariables(${j(action.variables ?? {})}, vars),
+          wait: true,
+          origin: { blockId: BLOCK_ID ?? undefined },
+        })
+        if (result.outcome !== 'ran') {
+          throw new Error('action ' + ${j(action.actionId)} + ' ' + result.outcome + (result.message === undefined ? '' : ': ' + result.message))
+        }`);
+    case "code":
+      return step(`        // inline code action \u2014 a fragment of THIS block, bundled by esbuild
+        await (async () => {
+${action.code.split("\n").map((line) => `          ${line}`).join("\n")}
+        })()`);
+  }
+}
+function generateAutomationBlock(input) {
+  const boundsError = validateRecipeBounds(input.recipe);
+  if (boundsError !== null) throw new Error(`cannot generate an automation from an invalid recipe: ${boundsError}`);
+  const { name, recipe } = input;
+  const runMode = recipe.runMode ?? { mode: "single" };
+  const stepMeta = recipe.actions.map(stepMetaOf);
+  return `import type {
+  AddonContext,
+  AutomationConditionTraceNode,
+  AutomationRunTrace,
+  AutomationRunVerdict,
+  AutomationStepTrace,
+  RunnableStep,
+} from '@camstack/types'
+import {
+  ConditionMirror,
+  DetectionTriggerFilter,
+  EventCategory,
+  RunGate,
+  buildTriggerTrace,
+  collectMirrorSources,
+  coreBlockIdFromAddonId,
+  evaluateConditionTree,
+  evaluateStationaryTrigger,
+  isSkippedTrace,
+  mergeSkipTraces,
+  resolveDeviceTarget,
+  resolveStepArgs,
+  runSteps,
+} from '@camstack/types'
+
+/**
+ * ${name}
+ *
+ * GENERATED FROM A RECIPE \u2014 do not edit by hand. Editing this file makes it a
+ * script: the visual editor reads AUTOMATION_RECIPE below, and hand edits are
+ * lost the next time the recipe is saved. Use "Eject to code" to take ownership
+ * of it permanently (one way).
+ */
+
+const AUTOMATION_RECIPE = ${JSON.stringify(recipe, null, 2)} as const
+
+const RECONCILE_MS = ${RECONCILE_MS}
+
+/** How triggers that arrive while busy (or cooling down) are handled. */
+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"}
+
+/** Skips that repeat are folded into one trace; it goes to the hub after this. */
+const SKIP_FLUSH_MS = 5_000
+
+/** Static facts about each action step, for its trace. */
+const STEP_META: ReadonlyArray<{ kind: string; cap?: string; method?: string; deviceId?: number }> = ${j(stepMeta)}
+
+/** A cap is named \`alarm-panel\`; \`ctx.api\` is keyed by the ROUTER name,
+ *  \`alarmPanel\`. Indexing ctx.api with the cap name yields undefined and every
+ *  action throws, so the conversion is not cosmetic. */
+function capToRouterKey(cap: string): string {
+  return cap.replace(/-([a-z0-9])/g, (_m, c: string) => c.toUpperCase())
+}
+
+/** Ms until the top of the next minute. Recomputed every tick so a long-lived
+ *  schedule cannot accumulate drift. */
+function nextMinuteBoundary(): number {
+  const now = Date.now()
+  return 60_000 - (now % 60_000)
+}
+
+/** Does \`when\` satisfy a 5-field cron expression (min hour dom mon dow)?
+ *  Supports wildcards, step syntax, ranges, comma lists and plain numbers \u2014
+ *  the subset an operator can author, and nothing that needs a library. */
+function cronMatches(expr: string, when: Date): boolean {
+  const fields = expr.trim().split(/\\s+/)
+  if (fields.length !== 5) return false
+  const actual = [
+    when.getMinutes(),
+    when.getHours(),
+    when.getDate(),
+    when.getMonth() + 1,
+    when.getDay(),
+  ]
+  return fields.every((field, i) => matchField(field, actual[i]!))
+}
+
+function matchField(field: string, value: number): boolean {
+  for (const part of field.split(',')) {
+    const [range, stepRaw] = part.split('/')
+    const step = stepRaw === undefined ? 1 : Number.parseInt(stepRaw, 10)
+    if (!Number.isFinite(step) || step < 1) continue
+    if (range === '*') {
+      if (value % step === 0) return true
+      continue
+    }
+    const bounds = range!.split('-')
+    const lo = Number.parseInt(bounds[0]!, 10)
+    const hi = bounds[1] === undefined ? lo : Number.parseInt(bounds[1], 10)
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) continue
+    if (value >= lo && value <= hi && (value - lo) % step === 0) return true
+  }
+  return false
+}
+
+export default function block(ctx: AddonContext) {
+  const disposers: Array<() => void> = []
+  const gate = new RunGate(RUN_MODE)
+  const mirror = new ConditionMirror(collectMirrorSources(CONDITIONS))
+  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
+  /** True when the stamp could not be read at start \u2014 the first run is let through and says so. */
+  let stampUnknown = false
+  let sendChain: Promise<void> = Promise.resolve()
+  let pendingSkip: AutomationRunTrace | undefined
+  let skipTimer: ReturnType<typeof setTimeout> | undefined
+  let stopped = false
+  let runCounter = 0
+  const runningTokens = new Set<RunToken>()
+  const queue: QueuedRun[] = []
+
+  interface RunToken {
+    aborted: boolean
+    wake?: () => void
+  }
+  interface QueuedRun {
+    readonly trigger: Record<string, unknown>
+    readonly reason: string
+    readonly queuedAt: number
+  }
+
+  /** Sleep that a restart can cut short. */
+  const abortableSleep = (ms: number, token: RunToken): Promise<void> =>
+    new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms)
+      token.wake = () => {
+        clearTimeout(timer)
+        resolve()
+      }
+    })
+
+  // \u2500\u2500 the hub's runs ledger: the stamp is read ONCE here, the ring is written through RPC \u2500\u2500
+  async function loadState(): Promise<void> {
+    if (BLOCK_ID === null) {
+      ctx.logger.warn('this is not a core-block addon id \u2014 no run ledger, cooldown and traces will not survive a restart', { addonId: ctx.id })
+      return
+    }
+    try {
+      const doc = await ctx.api.coreBlocks.getAutomationRunState.query({ blockId: BLOCK_ID })
+      lastRunStartedAt = doc.lastRunStartedAt
+    } catch (err: unknown) {
+      stampUnknown = true
+      ctx.logger.warn('could not read the stored cooldown stamp \u2014 the first run is let through', {
+        blockId: BLOCK_ID,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
+
+  function send(payload: { trace?: AutomationRunTrace; runStartedAt?: number }): Promise<void> {
+    if (BLOCK_ID === null) return Promise.resolve()
+    const blockId = BLOCK_ID
+    sendChain = sendChain.then(async () => {
+      try {
+        await ctx.api.coreBlocks.reportAutomationRun.mutate({ blockId, keepTraces: KEEP_TRACES, ...payload })
+      } catch (err: unknown) {
+        ctx.logger.warn('could not report the run to the hub ledger', {
+          blockId,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      }
+    })
+    return sendChain
+  }
+
+  function flushSkip(): void {
+    if (skipTimer !== undefined) {
+      clearTimeout(skipTimer)
+      skipTimer = undefined
+    }
+    if (pendingSkip === undefined) return
+    const trace = pendingSkip
+    pendingSkip = undefined
+    void send({ trace })
+  }
+
+  /** A skip identical to the one waiting is COUNTED on it; anything else flushes it first. */
+  function record(trace: AutomationRunTrace): void {
+    if (isSkippedTrace(trace)) {
+      if (pendingSkip !== undefined) {
+        const merged = mergeSkipTraces(pendingSkip, trace)
+        if (merged !== null) {
+          pendingSkip = merged
+          return
+        }
+        flushSkip()
+      }
+      pendingSkip = trace
+      skipTimer = setTimeout(flushSkip, SKIP_FLUSH_MS)
+      return
+    }
+    flushSkip()
+    void send({ trace })
+  }
+
+  // \u2500\u2500 the condition mirror (D49): memory only at fire time \u2500\u2500
+  async function refreshMirror(): Promise<void> {
+    const report = await mirror.refresh({
+      fetchSlice: (deviceId, cap) => ctx.api.deviceState.getCapSlice.query({ deviceId, capName: cap }),
+      fetchStableIds: async () => {
+        const all = await ctx.api.deviceManager.listAll.query({})
+        return new Map(all.devices.flatMap((d: { stableId?: string; id: number }) =>
+          d.stableId === undefined ? [] : [[d.stableId, d.id] as [string, number]]))
+      },
+    })
+    if (report.kept > 0) {
+      ctx.logger.debug('condition mirror kept stale values for sources it could not read', report)
+    }
+  }
+
+  /** Read one cap field off the state mirror. Returns undefined when the device,
+   *  the cap or the field cannot be resolved \u2014 the caller decides what that
+   *  means, and it always logs. (Used by the device-state TRIGGER, which the
+   *  reconcile backs; conditions read the ConditionMirror instead.) */
+  async function readField(
+    deviceId: number,
+    cap: string,
+    fieldPath: string,
+  ): Promise<unknown> {
+    try {
+      const slice = await ctx.api.deviceState.getCapSlice.query({ deviceId, capName: cap })
+      let cursor: unknown = slice
+      for (const part of fieldPath.split('.')) {
+        if (cursor === null || typeof cursor !== 'object') return undefined
+        cursor = (cursor as Record<string, unknown>)[part]
+      }
+      return cursor
+    } catch {
+      return undefined
+    }
+  }
+
+  /** A {$var} action target, resolved from the run's bag BEFORE dispatch \u2014 the
+   *  action runner only ever sees a number. */
+  function resolveTarget(vars: Record<string, unknown>, name: string): number {
+    return resolveDeviceTarget(vars, name)
+  }
+
+  function warnMissingVar(name: string): void {
+    ctx.logger.warn('template referenced a var that was never set', { var: name })
+  }
+
+  /** Substitute {{vars.x}} slots and { $var } values. Substitution only \u2014 never evaluation. */
+  function substitute(value: unknown, vars: Record<string, unknown>): unknown {
+    return resolveStepArgs(value, vars, warnMissingVar)
+  }
+
+  /** The variables handed to an Action step, substituted and kept to primitives. */
+  function substituteVariables(
+    raw: Record<string, string | number | boolean>,
+    vars: Record<string, unknown>,
+  ): Record<string, string | number | boolean> {
+    const out: Record<string, string | number | boolean> = {}
+    for (const [key, value] of Object.entries(raw)) {
+      const resolved = substitute(value, vars)
+      if (typeof resolved === 'string' || typeof resolved === 'number' || typeof resolved === 'boolean') {
+        out[key] = resolved
+      }
+    }
+    return out
+  }
+
+  async function actuate(
+    deviceId: number,
+    cap: string,
+    method: string,
+    args: Record<string, unknown>,
+    vars: Record<string, unknown>,
+  ): Promise<void> {
+    const substituted = substitute(args, vars)
+    const resolved: Record<string, unknown> =
+      substituted !== null && typeof substituted === 'object' ? { ...substituted } : {}
+    // 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))
+    const proc: unknown =
+      client !== null && client !== undefined ? Reflect.get(client as object, method) : undefined
+    const mutate: unknown =
+      proc !== null && proc !== undefined ? Reflect.get(proc as object, 'mutate') : undefined
+    if (typeof mutate !== 'function') {
+      throw new Error('no such device method: ' + cap + '.' + method)
+    }
+    await mutate({ ...resolved, deviceId })
+  }
+
+  /** The THEN half, through the ONE shared step runner: stops at the first
+   *  failure (continuing past a failed step executes an intent the operator
+   *  never expressed); every step is traced, the ones after a failure (or an
+   *  abort) are marked not-run. */
+  async function runActions(
+    vars: Record<string, unknown>,
+    token: RunToken,
+  ): Promise<{ steps: readonly AutomationStepTrace[]; failed: boolean }> {
+    const sleep = (ms: number): Promise<void> => abortableSleep(ms, token)
+    const steps: RunnableStep[] = [
+${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
+    ]
+    return runSteps(steps, {
+      pathPrefix: 'actions',
+      isAborted: () => token.aborted,
+      abortReason: 'aborted by a restart',
+      now: () => Date.now(),
+      onFailure: (failure) => {
+        ctx.logger.warn('action failed \u2014 stopping the sequence', {
+          ...(failure.deviceId === undefined ? {} : { tags: { deviceId: failure.deviceId } }),
+          step: failure.index,
+          error: failure.message,
+        })
+      },
+    })
+  }
+
+  function deviceTags(trigger: Record<string, unknown>): { tags?: { deviceId: number } } {
+    const deviceId = trigger['deviceId']
+    return typeof deviceId === 'number' ? { tags: { deviceId } } : {}
+  }
+
+  function newRunId(at: number): string {
+    runCounter += 1
+    return at.toString(36) + '-' + runCounter.toString(36)
+  }
+
+  /** A trigger that never became a run (rejected, or dropped by the run mode). */
+  function skipTrace(
+    trigger: Record<string, unknown>,
+    reason: string,
+    outcome: AutomationRunTrace['outcome'],
+    verdict: AutomationRunVerdict | undefined,
+    accepted: boolean,
+  ): AutomationRunTrace {
+    const now = Date.now()
+    return {
+      runId: newRunId(now),
+      startedAt: now,
+      endedAt: now,
+      trigger: buildTriggerTrace(trigger, accepted ? 'pass' : 'fail', reason),
+      conditions: [],
+      ...(verdict === undefined ? {} : { verdict }),
+      steps: [],
+      outcome,
+      repeat: 1,
+      lastAt: now,
+    }
+  }
+
+  /** One admitted run: conditions (memory only), the cooldown, the actions. */
+  async function execute(
+    trigger: Record<string, unknown>,
+    reason: string,
+    admission: AutomationRunVerdict,
+  ): Promise<void> {
+    const token: RunToken = { aborted: false }
+    runningTokens.add(token)
+    const startedAt = Date.now()
+    const runId = newRunId(startedAt)
+    let verdict = admission
+    let outcome: AutomationRunTrace['outcome'] = 'ran'
+    let nodes: AutomationConditionTraceNode[] = []
+    let steps: AutomationStepTrace[] = []
+    try {
+      const evaluation = evaluateConditionTree(CONDITIONS, mirror, Date.now())
+      nodes = [...evaluation.nodes]
+      for (const node of nodes) {
+        if (node.kind === 'condition' && node.observed === null && node.deviceId !== undefined) {
+          ctx.logger.warn('condition leaf value unknown \u2014 treated as false', {
+            tags: { deviceId: node.deviceId },
+            path: node.path,
+            cap: node.cap,
+            fieldPath: node.fieldPath,
+          })
+        }
+      }
+      if (!evaluation.pass) {
+        outcome = 'skipped-conditions'
+        ctx.logger.debug('automation did not run \u2014 conditions were false', { trigger, ...deviceTags(trigger) })
+        return
+      }
+      const letThrough = stampUnknown && RUN_MODE.mode === 'cooldown'
+      const cooldown = letThrough
+        ? { ok: true, bypassed: true, reason: 'cooldown stamp unreadable at start \u2014 run let through' }
+        : gate.cooldown({
+            manual: trigger['kind'] === 'manual',
+            now: Date.now(),
+            lastRunStartedAt,
+          })
+      if (!cooldown.ok) {
+        outcome = 'skipped-cooldown'
+        verdict = { mode: RUN_MODE, decision: 'cooldown', reason: cooldown.reason }
+        ctx.logger.info('automation did not run \u2014 ' + cooldown.reason, deviceTags(trigger))
+        return
+      }
+      if (cooldown.bypassed) verdict = { mode: RUN_MODE, decision: 'bypass', reason: cooldown.reason }
+      // Stamped when the actions START, and reported to the hub before they run,
+      // so a restart mid-run cannot fire again inside the window.
+      lastRunStartedAt = startedAt
+      stampUnknown = false
+      await send({ runStartedAt: startedAt })
+      ctx.logger.info('automation running', { trigger, ...deviceTags(trigger) })
+      const vars: Record<string, unknown> = { ...trigger }
+      const result = await runActions(vars, token)
+      steps = result.steps
+      outcome = token.aborted ? 'aborted' : result.failed ? 'failed' : 'ran'
+    } catch (err: unknown) {
+      outcome = 'failed'
+      ctx.logger.warn('automation run failed', { error: err instanceof Error ? err.message : String(err), ...deviceTags(trigger) })
+    } finally {
+      runningTokens.delete(token)
+      const endedAt = Date.now()
+      record({
+        runId,
+        startedAt,
+        endedAt,
+        trigger: buildTriggerTrace(trigger, 'pass', reason),
+        conditions: nodes,
+        verdict,
+        steps,
+        outcome,
+        repeat: 1,
+        lastAt: endedAt,
+      })
+      if (gate.release()) {
+        const next = queue.shift()
+        if (next !== undefined && !stopped) {
+          void execute(next.trigger, next.reason, {
+            mode: RUN_MODE,
+            decision: 'queued',
+            reason: 'queued, then ran after waiting ' + (Date.now() - next.queuedAt) + ' ms',
+          })
+        }
+      }
+    }
+  }
+
+  /** Every trigger lands here. \`accepted\` = the trigger itself was satisfied
+   *  (a rejected detection event is only traced). */
+  async function run(
+    trigger: Record<string, unknown>,
+    reason = 'fired',
+    accepted = true,
+  ): Promise<void> {
+    await ready
+    if (stopped) return
+    if (!accepted) {
+      record(skipTrace(trigger, reason, 'skipped-trigger', undefined, false))
+      return
+    }
+    const admission = gate.admit()
+    const verdict: AutomationRunVerdict = { mode: RUN_MODE, decision: admission.decision, reason: admission.reason }
+    switch (admission.decision) {
+      case 'drop':
+        ctx.logger.info('automation trigger dropped \u2014 ' + admission.reason, deviceTags(trigger))
+        record(skipTrace(trigger, reason, 'skipped-overlap', verdict, true))
+        return
+      case 'queued':
+        ctx.logger.info('automation trigger queued \u2014 ' + admission.reason, deviceTags(trigger))
+        queue.push({ trigger, reason, queuedAt: Date.now() })
+        return
+      case 'restart':
+        ctx.logger.info('automation restarting \u2014 ' + admission.reason, deviceTags(trigger))
+        for (const running of runningTokens) {
+          running.aborted = true
+          running.wake?.()
+        }
+        break
+      case 'run':
+        break
+    }
+    await execute(trigger, reason, verdict)
+  }
+
+  const ready: Promise<void> = (async () => {
+    await loadState()
+    await refreshMirror()
+  })()
+
+  if (CONDITIONS !== undefined) {
+    disposers.push(
+      ctx.eventBus.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
+        const data = event.data
+        const deviceId = data['deviceId']
+        const capName = data['capName']
+        if (typeof deviceId === 'number' && typeof capName === 'string') {
+          mirror.apply(deviceId, capName, data['slice'])
+        }
+      }),
+    )
+    const mirrorReconcile = setInterval(() => { void refreshMirror() }, RECONCILE_MS)
+    disposers.push(() => clearInterval(mirrorReconcile))
+  }
+
+${recipe.triggers.map((t2, i) => emitTrigger(t2, i)).join("\n\n")}
+
+  return () => {
+    stopped = true
+    queue.length = 0
+    flushSkip()
+    for (const running of runningTokens) {
+      running.aborted = true
+      running.wake?.()
+    }
+    for (const dispose of disposers) dispose()
+  }
+}
+`;
+}
 var MACRO_LABELS = [
   {
     id: "person",
@@ -7628,6 +8541,16 @@ var ActionRunChangedSchema = z4.object({
   lastRunAt: z4.number().nullable(),
   lastError: z4.string().nullable()
 });
+function baseUnitForQuantity(quantity) {
+  return baseUnitOf(quantity);
+}
+function unitsForQuantity(quantity) {
+  const base = baseUnitForQuantity(quantity);
+  if (base === void 0) return [];
+  const dimension = unitDimension(base);
+  if (dimension === void 0) return [base];
+  return [base, ...unitsForDimension(dimension).filter((unit) => unit !== base)];
+}
 var UnitWarningSchema = z4.object({
   /** Where in the saved record, e.g. `conditions.children.0` or `steps.2.args.grams`. */
   path: z4.string(),
@@ -7637,6 +8560,260 @@ var UnitWarningSchema = z4.object({
   assumedUnit: z4.string(),
   message: z4.string()
 });
+function objectInput(schema) {
+  const inner = unwrapSchema(schema);
+  return inner instanceof z4.ZodObject ? inner : void 0;
+}
+function capUnitResolver(defs) {
+  const byName = new Map(defs.map((def) => [def.name, def]));
+  return {
+    fieldQuantity(cap, fieldPath) {
+      const status = byName.get(cap)?.status;
+      if (status === void 0) return void 0;
+      return [...enumerateSchemaFields(status.schema), ...status.itemArray === void 0 ? [] : enumerateItemArrayFields(status.itemArray)].find((f) => f.path === fieldPath)?.quantity;
+    },
+    paramMeta(cap, method2, arg) {
+      const input = byName.get(cap)?.methods[method2]?.input;
+      if (input === void 0) return void 0;
+      const field = objectInput(input)?.shape[arg];
+      return field === void 0 ? void 0 : paramMetaOf(field);
+    }
+  };
+}
+function pickedUnit(raw) {
+  return normalizeUnit(raw) ?? raw;
+}
+function hasUnitChoice(quantity) {
+  return unitsForQuantity(quantity).length > 1;
+}
+function bareWarning(input) {
+  return {
+    ...input,
+    message: `${input.field}: the bare number ${input.value} was taken as ${input.assumedUnit} \u2014 send { value, unit } to state the unit`
+  };
+}
+function checkPickedUnit(unit, target) {
+  convertQuantityInput({
+    value: 1,
+    unit,
+    target
+  });
+}
+function normalizeLeaf(leaf, resolver, path2) {
+  const quantity = resolver.fieldQuantity(leaf.cap, leaf.fieldPath);
+  const base = quantity === void 0 ? void 0 : baseUnitForQuantity(quantity);
+  const wantsUnit = isQuantityValue(leaf.value) || leaf.unit !== void 0;
+  if (base === void 0 || quantity === void 0) {
+    if (wantsUnit) throw new QuantityUnitError("no-quantity", `${leaf.cap}.${leaf.fieldPath} is not a quantity \u2014 it takes no unit`);
+    return {
+      leaf,
+      warnings: []
+    };
+  }
+  if (isQuantityValue(leaf.value)) {
+    const converted = convertQuantityInput({
+      value: leaf.value.value,
+      unit: leaf.value.unit,
+      target: base
+    });
+    return {
+      leaf: {
+        ...leaf,
+        value: converted,
+        unit: pickedUnit(leaf.value.unit)
+      },
+      warnings: []
+    };
+  }
+  if (typeof leaf.value !== "number") return {
+    leaf,
+    warnings: []
+  };
+  if (leaf.unit !== void 0) {
+    checkPickedUnit(leaf.unit, base);
+    return {
+      leaf,
+      warnings: []
+    };
+  }
+  if (!hasUnitChoice(quantity)) return {
+    leaf,
+    warnings: []
+  };
+  return {
+    leaf,
+    warnings: [bareWarning({
+      path: path2,
+      deviceId: leaf.deviceId,
+      field: leaf.fieldPath,
+      value: leaf.value,
+      assumedUnit: base
+    })]
+  };
+}
+function normalizeConditionUnits(condition, resolver, path2 = "conditions") {
+  switch (condition.kind) {
+    case "condition": {
+      const { leaf, warnings } = normalizeLeaf(condition, resolver, path2);
+      return {
+        value: leaf,
+        warnings
+      };
+    }
+    case "not": {
+      const inner = normalizeConditionUnits(condition.child, resolver, `${path2}.child`);
+      return {
+        value: {
+          ...condition,
+          child: inner.value
+        },
+        warnings: inner.warnings
+      };
+    }
+    case "all":
+    case "any": {
+      const children = condition.children.map((child, i) => normalizeConditionUnits(child, resolver, `${path2}.children.${i}`));
+      return {
+        value: {
+          ...condition,
+          children: children.map((c) => c.value)
+        },
+        warnings: children.flatMap((c) => c.warnings)
+      };
+    }
+    default:
+      return {
+        value: condition,
+        warnings: []
+      };
+  }
+}
+function normalizeCapStep(step, resolver, path2) {
+  const deviceId = typeof step.deviceId === "number" ? step.deviceId : void 0;
+  const args = { ...step.args };
+  const argUnits = { ...step.argUnits };
+  const warnings = [];
+  for (const [arg, picked] of Object.entries(step.argUnits ?? {})) {
+    const meta = resolver.paramMeta(step.cap, step.method, arg);
+    if (meta === void 0) throw new QuantityUnitError("no-quantity", `${step.cap}.${step.method}(${arg}) is not a quantity \u2014 it takes no unit`);
+    checkPickedUnit(picked, meta.unit);
+  }
+  for (const [arg, given] of Object.entries(step.args ?? {})) {
+    const meta = resolver.paramMeta(step.cap, step.method, arg);
+    if (meta === void 0) continue;
+    if (isQuantityValue(given)) {
+      args[arg] = convertQuantityInput({
+        value: given.value,
+        unit: given.unit,
+        target: meta.unit
+      });
+      argUnits[arg] = pickedUnit(given.unit);
+    } else if (typeof given === "number" && argUnits[arg] === void 0 && hasUnitChoice(meta.quantity)) warnings.push(bareWarning({
+      path: `${path2}.args.${arg}`,
+      ...deviceId === void 0 ? {} : { deviceId },
+      field: arg,
+      value: given,
+      assumedUnit: meta.unit
+    }));
+  }
+  const { argUnits: _dropped, ...rest } = step;
+  return {
+    value: {
+      ...rest,
+      ...step.args === void 0 ? {} : { args },
+      ...Object.keys(argUnits).length > 0 ? { argUnits } : {}
+    },
+    warnings
+  };
+}
+function normalizeActionUnits(actions, resolver, path2 = "steps") {
+  const out = [];
+  const warnings = [];
+  actions.forEach((action, i) => {
+    if (action.kind !== "cap") {
+      out.push(action);
+      return;
+    }
+    const normalized = normalizeCapStep(action, resolver, `${path2}.${i}`);
+    out.push(normalized.value);
+    warnings.push(...normalized.warnings);
+  });
+  return {
+    value: out,
+    warnings
+  };
+}
+function normalizeRecipeUnits(recipe, resolver) {
+  const conditions = recipe.conditions === void 0 ? void 0 : normalizeConditionUnits(recipe.conditions, resolver, "conditions");
+  const actions = normalizeActionUnits(recipe.actions, resolver, "actions");
+  return {
+    value: {
+      ...recipe,
+      ...conditions === void 0 ? {} : { conditions: conditions.value },
+      actions: actions.value
+    },
+    warnings: [...conditions?.warnings ?? [], ...actions.warnings]
+  };
+}
+function stampCondition(condition, resolver) {
+  switch (condition.kind) {
+    case "condition": {
+      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;
+      const base = baseUnitForQuantity(quantity);
+      return base === void 0 ? condition : {
+        ...condition,
+        unit: base
+      };
+    }
+    case "not":
+      return {
+        ...condition,
+        child: stampCondition(condition.child, resolver)
+      };
+    case "all":
+    case "any":
+      return {
+        ...condition,
+        children: condition.children.map((child) => stampCondition(child, resolver))
+      };
+    default:
+      return condition;
+  }
+}
+function stampAction(action, resolver) {
+  if (action.kind !== "cap" || action.args === void 0) return action;
+  const argUnits = { ...action.argUnits };
+  for (const [arg, value] of Object.entries(action.args)) {
+    if (typeof value !== "number" || argUnits[arg] !== void 0) continue;
+    const meta = resolver.paramMeta(action.cap, action.method, arg);
+    if (meta !== void 0 && unitsForQuantity(meta.quantity).length > 1) argUnits[arg] = meta.unit;
+  }
+  return Object.keys(argUnits).length === 0 ? action : {
+    ...action,
+    argUnits
+  };
+}
+function prepareRecipeUnits(recipe, resolver) {
+  const stamped = {
+    ...recipe,
+    ...recipe.conditions === void 0 ? {} : { conditions: stampCondition(recipe.conditions, resolver) },
+    actions: recipe.actions.map((action) => stampAction(action, resolver))
+  };
+  try {
+    return {
+      ok: true,
+      recipe: normalizeRecipeUnits(stamped, resolver).value
+    };
+  } catch (error) {
+    if (error instanceof QuantityUnitError) return {
+      ok: false,
+      error: error.message
+    };
+    throw error;
+  }
+}
 var AttachmentMediaTypeSchema = z4.enum([
   "image",
   "video",
@@ -58990,6 +60167,71 @@ var powerMeterCustomize = {
     powerTarget("current", "A")
   ]
 };
+var powerMeterCapability = {
+  name: "power-meter",
+  scope: "device",
+  deviceNative: true,
+  mode: "singleton",
+  deviceTypes: POWER_METER_DEVICE_TYPES,
+  methods: {},
+  status: {
+    schema: PowerMeterStatusSchema,
+    kind: "push"
+  },
+  runtimeState: PowerMeterStatusSchema,
+  /**
+  * Runtime-state durability: **restored** — as `numeric-sensor`; `energy` is an accumulator whose restored value is the baseline.
+  *
+  * See `RuntimeStateDurability`. Enforced by
+  * `scripts/check-runtime-state-durability.ts`.
+  */
+  durability: "restored",
+  /**
+  * History (D850): recorded series. Gauges are floored at 30 s; `energy` is the one monotonic meter (counter).
+  */
+  history: { fields: {
+    power: {
+      kind: "gauge",
+      unit: "W",
+      deadband: 1,
+      minIntervalMs: 3e4
+    },
+    energy: {
+      kind: "counter",
+      unit: "kWh",
+      deadband: 0.01,
+      minIntervalMs: 6e4
+    },
+    voltage: {
+      kind: "gauge",
+      unit: "V",
+      deadband: 1,
+      minIntervalMs: 3e4
+    },
+    current: {
+      kind: "gauge",
+      unit: "A",
+      deadband: 0.05,
+      minIntervalMs: 3e4
+    },
+    apparentPower: {
+      kind: "gauge",
+      unit: "VA",
+      deadband: 1,
+      minIntervalMs: 3e4
+    },
+    powerFactor: {
+      kind: "gauge",
+      unit: "ratio",
+      deadband: 0.01,
+      minIntervalMs: 6e4
+    }
+  } },
+  /** Clock fields: written, but excluded from the compare that decides
+  *  whether persisting is worth a SQLite commit. */
+  volatileStateFields: ["lastFetchedAt"],
+  customize: powerMeterCustomize
+};
 var GpsLocationSchema = z4.object({
   /** Latitude in decimal degrees, -90..90. */
   latitude: z4.number().min(-90).max(90).meta(readingMeta("angle")),
@@ -59653,6 +60895,27 @@ var runningCustomize = {
     advancedExpression: true
   }]
 };
+var runningStateCapability = {
+  name: "running-state",
+  scope: "device",
+  deviceNative: true,
+  mode: "singleton",
+  deviceTypes: RUNNING_DEVICE_TYPES,
+  methods: {},
+  events: {
+    onStarted: { data: RunningFlipEventDataSchema },
+    onFinished: { data: RunningFlipEventDataSchema }
+  },
+  status: {
+    schema: RunningStateStatusSchema,
+    kind: "push"
+  },
+  runtimeState: RunningStateStatusSchema,
+  durability: "restored",
+  history: { fields: { running: { kind: "boolean" } } },
+  volatileStateFields: ["lastFetchedAt"],
+  customize: runningCustomize
+};
 var rebootCapability = {
   name: "reboot",
   scope: "device",
@@ -78817,6 +80080,201 @@ var APPLIANCE_EXPORT = {
   matter: withheld(MATTER_REASON)
 };
 var OPERATOR_WRITTEN_STALE_MS = 10 * 6e4;
+var ALL_CAPABILITY_DEFINITIONS = [
+  accessoriesCapability,
+  actionSourceCapability,
+  actionsCapability,
+  addonPagesCapability,
+  addonPagesSourceCapability,
+  addonRoutesCapability,
+  addonSettingsCapability,
+  addonWidgetsCapability,
+  addonWidgetsSourceCapability,
+  addonsCapability,
+  adminUiCapability,
+  airQualitySensorCapability,
+  alarmPanelCapability,
+  alertsCapability,
+  ambientLightSensorCapability,
+  audioAnalysisCapability,
+  audioAnalyzerCapability,
+  audioCodecCapability,
+  audioMetricsCapability,
+  authProviderCapability,
+  automationControlCapability,
+  backupCapability,
+  batteryCapability,
+  binaryCapability,
+  brightnessCapability,
+  brokerCapability,
+  buttonCapability,
+  calendarSourceCapability,
+  calendarsCapability,
+  cameraCredentialsCapability,
+  cameraGridLayoutCapability,
+  cameraPipelineConfigCapability,
+  cameraStreamsCapability,
+  carbonMonoxideCapability,
+  climateControlCapability,
+  colorCapability,
+  composerCapability,
+  connectionTestCapability,
+  connectivityCapability,
+  consumablesCapability,
+  contactCapability,
+  controlCapability,
+  coreBlocksCapability,
+  coverCapability,
+  customModelRegistryCapability,
+  dataStoreProviderCapability,
+  databaseSnapshotCapability,
+  dayNightCapability,
+  decoderCapability,
+  detectionPipelineCapability,
+  deviceAdminLinkCapability,
+  deviceAdoptionCapability,
+  deviceCredentialsCapability,
+  deviceDiscoveryCapability,
+  deviceExportCapability,
+  deviceExtensionCapability,
+  deviceHistoryCapability,
+  deviceManagerCapability,
+  deviceOpsCapability,
+  deviceProviderCapability,
+  deviceRemovalHookCapability,
+  deviceStateCapability,
+  deviceStatusCapability,
+  dishwasherCapability,
+  displayPaletteCapability,
+  doorbellCapability,
+  embeddingEncoderCapability,
+  enumSensorCapability,
+  eventEmitterCapability,
+  faceGalleryCapability,
+  failureContributionCapability,
+  fanControlCapability,
+  featureProbeCapability,
+  filesystemBrowseCapability,
+  floodCapability,
+  gasCapability,
+  groupActiveCapability,
+  groupCommandsCapability,
+  groupStatusCapability,
+  heatingValveCapability,
+  humidifierCapability,
+  humiditySensorCapability,
+  imageCapability,
+  imageSettingsCapability,
+  integrationsCapability,
+  intercomCapability,
+  irTransmitterCapability,
+  keychainCapability,
+  keychainAdminCapability,
+  lawnMowerControlCapability,
+  llmCapability,
+  llmRuntimeCapability,
+  loadContributionCapability,
+  localNetworkCapability,
+  lockControlCapability,
+  logChannelsCapability,
+  logDestinationCapability,
+  loginMethodCapability,
+  mediaPlayerCapability,
+  meshNetworkCapability,
+  meterCapability,
+  metricsProviderCapability,
+  modelConvertCapability,
+  modelDistributorCapability,
+  motionCapability,
+  motionDetectionCapability,
+  motionTriggerCapability,
+  motionZonesCapability,
+  mqttBrokerCapability,
+  nativeObjectDetectionCapability,
+  navigationCapability,
+  networkAccessCapability,
+  networkLinkCapability,
+  networkQualityCapability,
+  nodeCertificatesCapability,
+  nodeRemovalHookCapability,
+  nodesCapability,
+  notificationOutputCapability,
+  notificationRulesCapability,
+  notifierCapability,
+  numericSensorCapability,
+  oauthIntegrationCapability,
+  oidcConnectionsCapability,
+  osdCapability,
+  osdManagerCapability,
+  petFeederCapability,
+  petFountainCapability,
+  pipelineAnalyticsCapability,
+  pipelineExecutorCapability,
+  pipelineOrchestratorCapability,
+  pipelineRunnerCapability,
+  plateGalleryCapability,
+  platformProbeCapability,
+  powerMeterCapability,
+  presenceCapability,
+  pressureSensorCapability,
+  privacyMaskCapability,
+  ptzCapability,
+  ptzAutotrackCapability,
+  rebootCapability,
+  recordEntriesCapability,
+  recordingCapability,
+  recordingArchiveCapability,
+  recordingExportCapability,
+  recordingOnboardCapability,
+  recordingSignalCapability,
+  recordsCapability,
+  remoteCapability,
+  remoteLayoutComponentsCapability,
+  runningStateCapability,
+  sceneMonitorCapability,
+  scriptRunnerCapability,
+  serverManagementCapability,
+  settingsStoreCapability,
+  smokeCapability,
+  smtpProviderCapability,
+  snapshotCapability,
+  ssoBridgeCapability,
+  storageCapability,
+  storageAdminCapability,
+  storageEvictableCapability,
+  storageMigrationCapability,
+  storageOccupancyCapability,
+  storageProviderCapability,
+  streamBrokerCapability,
+  streamCatalogCapability,
+  streamParamsCapability,
+  streamSignalsCapability,
+  switchCapability,
+  systemCapability,
+  tamperCapability,
+  temperatureSensorCapability,
+  templateCapability,
+  terminalSessionCapability,
+  toastCapability,
+  trainingCapability,
+  trainingProviderCapability,
+  turnProviderCapability,
+  updateCapability,
+  userManagementCapability,
+  userPasskeysCapability,
+  vacuumControlCapability,
+  valveCapability,
+  vectorStoreCapability,
+  vibrationCapability,
+  videoclipsCapability,
+  viewerUiCapability,
+  waterHeaterCapability,
+  weatherCapability,
+  webrtcSessionCapability,
+  zoneAnalyticsCapability,
+  zoneRulesCapability,
+  zonesCapability
+];
 var METHOD_DEVICE_SELECTORS = Object.freeze({
   "accessories.getStatus": [{
     name: "deviceId",
@@ -83863,9 +85321,21 @@ function describeHub(hub) {
 }
 
 export {
+  isReadingQuantity,
   FFMPEG_PATH_ENV,
+  AutomationRecipeSchema,
+  validateRecipeBounds,
+  generateAutomationBlock,
+  MACRO_LABELS,
+  unitsForQuantity,
+  capUnitResolver,
+  prepareRecipeUnits,
   buildViewerLink,
+  AlarmArmModeSchema,
+  NcRuleInputSchema,
+  ZoneKindEnum,
   DETECTOR_PERF,
+  ALL_CAPABILITY_DEFINITIONS,
   classifyInferenceHardware,
   acceleratorKindOf,
   validateManualHubUrl,