@camstack/types 1.2.541 → 1.2.543

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -32418,6 +32418,316 @@ function zoneOnlySite(timeZone) {
32418
32418
  };
32419
32419
  }
32420
32420
  //#endregion
32421
+ //#region src/automation/hold.ts
32422
+ /**
32423
+ * Hold semantics — "for N seconds" on a leaf of the `when` tree (#498).
32424
+ *
32425
+ * ONE primitive, `for: { ms, mode, tolerance? }`, shared by `device-becomes`,
32426
+ * `device-is` and `expression`:
32427
+ *
32428
+ * - `held`: the condition stays true for `ms`;
32429
+ * - `stable`: the value does not move by more than `tolerance` (absolute, in
32430
+ * the field's base unit) for `ms` while the condition holds.
32431
+ *
32432
+ * {@link HoldCore} is the pure state machine (an input observation → a reading).
32433
+ * {@link HoldTracker} keys cores by a leaf path for the STATE leaves the tree
32434
+ * evaluator judges. {@link BecomesWatch} wraps a core with a timer for the
32435
+ * `device-becomes` EVENT leaf: the deadline is armed when the hold starts and
32436
+ * cancelled when it breaks, and the leaf fires ONCE per episode.
32437
+ *
32438
+ * Hold state is memory only. A hold that is already running when the watcher
32439
+ * first looks (a restart) is INHERITED: nobody knows when it began, so it never
32440
+ * fires for that episode and a state leaf reads it as unknown until the window
32441
+ * has elapsed from the moment the watcher started (D49: not-known is not false).
32442
+ */
32443
+ var HOLD_MAX_MS = 864e5;
32444
+ var HoldModeSchema = zod.z.enum(["held", "stable"]);
32445
+ var HoldSpecSchema = zod.z.object({
32446
+ /** How long the condition (or the value) must hold. */
32447
+ ms: zod.z.number().int().min(1).max(HOLD_MAX_MS),
32448
+ mode: HoldModeSchema,
32449
+ /** `stable` only: the largest move of the value that still counts as unchanged (absolute, base unit). */
32450
+ tolerance: zod.z.number().min(0).optional()
32451
+ });
32452
+ /** What a trace says about a hold. */
32453
+ var HoldTraceSchema = zod.z.object({
32454
+ phase: zod.z.enum([
32455
+ "pending",
32456
+ "cancelled",
32457
+ "fired",
32458
+ "reseeded"
32459
+ ]),
32460
+ ms: zod.z.number().int(),
32461
+ mode: HoldModeSchema,
32462
+ /** When the hold started (ms epoch). */
32463
+ since: zod.z.number().optional(),
32464
+ /** When it completes (ms epoch), for a pending hold. */
32465
+ deadline: zod.z.number().optional()
32466
+ });
32467
+ /**
32468
+ * The ONE reader of a leaf's hold. A leaf stored before #498 carries `forMs`
32469
+ * (a `held` window); it reads as `for: { ms, mode: 'held' }`. `0` is no hold.
32470
+ */
32471
+ function holdOf(leaf) {
32472
+ if (leaf.for !== void 0) return leaf.for;
32473
+ if (leaf.forMs !== void 0 && leaf.forMs > 0) return {
32474
+ ms: leaf.forMs,
32475
+ mode: "held"
32476
+ };
32477
+ }
32478
+ /** `30 s`, `5 min`, `1 h 5 min` — a hold window for a human. */
32479
+ function describeHoldMs(ms) {
32480
+ const s = Math.round(ms / 1e3);
32481
+ if (s < 60) return `${s} s`;
32482
+ const m = Math.floor(s / 60);
32483
+ const rest = s % 60;
32484
+ if (m < 60) return rest === 0 ? `${m} min` : `${m} min ${rest} s`;
32485
+ const h = Math.floor(m / 60);
32486
+ return m % 60 === 0 ? `${h} h` : `${h} h ${m % 60} min`;
32487
+ }
32488
+ /** The operators a `device-becomes` leaf may carry: a threshold or a range. */
32489
+ var BecomesOperatorSchema = zod.z.enum([
32490
+ "eq",
32491
+ "ne",
32492
+ "gt",
32493
+ "gte",
32494
+ "lt",
32495
+ "lte",
32496
+ "between",
32497
+ "outside"
32498
+ ]);
32499
+ function compareValues(actual, operator, expected) {
32500
+ switch (operator) {
32501
+ case "eq": return actual === expected;
32502
+ case "ne": return actual !== expected;
32503
+ case "gt": return typeof actual === "number" && typeof expected === "number" && actual > expected;
32504
+ case "gte": return typeof actual === "number" && typeof expected === "number" && actual >= expected;
32505
+ case "lt": return typeof actual === "number" && typeof expected === "number" && actual < expected;
32506
+ case "lte": return typeof actual === "number" && typeof expected === "number" && actual <= expected;
32507
+ case "contains": return typeof actual === "string" && typeof expected === "string" && actual.includes(expected);
32508
+ case "in": return Array.isArray(expected) && expected.some((v) => v === actual);
32509
+ case "between":
32510
+ case "outside": {
32511
+ if (typeof actual !== "number" || !Array.isArray(expected)) return false;
32512
+ const [low, high] = expected;
32513
+ if (typeof low !== "number" || typeof high !== "number") return false;
32514
+ const inside = actual >= low && actual <= high;
32515
+ return operator === "between" ? inside : !inside;
32516
+ }
32517
+ }
32518
+ }
32519
+ function moved(value, anchor, tolerance) {
32520
+ if (typeof value === "number" && typeof anchor === "number") return Math.abs(value - anchor) > tolerance;
32521
+ return value !== anchor;
32522
+ }
32523
+ var HoldCore = class {
32524
+ spec;
32525
+ seen = false;
32526
+ since = null;
32527
+ inherited = false;
32528
+ anchor = void 0;
32529
+ constructor(spec) {
32530
+ this.spec = spec;
32531
+ }
32532
+ /**
32533
+ * One KNOWN observation. `holds` is whether the condition is true now; `value`
32534
+ * is the field (used by `stable`). A read that failed is not an observation —
32535
+ * the caller simply does not call this (D49: it never cancels a hold).
32536
+ */
32537
+ observe(holds, value, now) {
32538
+ const first = !this.seen;
32539
+ this.seen = true;
32540
+ const wasRunning = this.since !== null;
32541
+ let restarted = false;
32542
+ if (!holds) {
32543
+ this.since = null;
32544
+ this.inherited = false;
32545
+ this.anchor = void 0;
32546
+ } else if (this.spec.mode === "held") {
32547
+ if (this.since === null) {
32548
+ this.since = now;
32549
+ this.inherited = first;
32550
+ restarted = true;
32551
+ }
32552
+ } else if (this.since === null || moved(value, this.anchor, this.spec.tolerance ?? 0)) {
32553
+ this.anchor = value;
32554
+ this.since = now;
32555
+ this.inherited = first;
32556
+ restarted = true;
32557
+ }
32558
+ const transition = !holds ? wasRunning ? "cancelled" : "none" : restarted ? wasRunning ? "cancelled" : "started" : "none";
32559
+ return {
32560
+ ...this.read(now),
32561
+ transition
32562
+ };
32563
+ }
32564
+ /** The reading at `now` with no new observation. */
32565
+ read(now) {
32566
+ if (this.since === null) return {
32567
+ phase: "idle",
32568
+ since: null,
32569
+ remainingMs: this.spec.ms
32570
+ };
32571
+ const remainingMs = Math.max(0, this.since + this.spec.ms - now);
32572
+ if (remainingMs === 0) return {
32573
+ phase: "met",
32574
+ since: this.since,
32575
+ remainingMs: 0
32576
+ };
32577
+ return {
32578
+ phase: this.inherited ? "inherited" : "pending",
32579
+ since: this.since,
32580
+ remainingMs
32581
+ };
32582
+ }
32583
+ };
32584
+ /** Hold cores of the state leaves of one tree, keyed by the leaf's path. */
32585
+ var HoldTracker = class {
32586
+ cores = /* @__PURE__ */ new Map();
32587
+ observe(key, spec, input, now) {
32588
+ let core = this.cores.get(key);
32589
+ if (core === void 0) {
32590
+ core = new HoldCore(spec);
32591
+ this.cores.set(key, core);
32592
+ }
32593
+ return core.observe(input.holds, input.value, now);
32594
+ }
32595
+ };
32596
+ /** Is the leaf's predicate true for `value`? `undefined` for "any change" (no predicate). */
32597
+ function predicateOf(spec, value) {
32598
+ if (spec.becomes !== void 0) return value === spec.becomes;
32599
+ if (spec.operator !== void 0) return compareValues(value, spec.operator, spec.value);
32600
+ }
32601
+ /**
32602
+ * The runtime of a `device-becomes` leaf. It fires on a TRANSITION and never on a
32603
+ * re-report; with a hold it arms a timer for the deadline and fires once per
32604
+ * episode.
32605
+ */
32606
+ var BecomesWatch = class {
32607
+ spec;
32608
+ deps;
32609
+ previous = void 0;
32610
+ seeded = false;
32611
+ core;
32612
+ handle = void 0;
32613
+ consumed = false;
32614
+ disposed = false;
32615
+ constructor(spec, deps) {
32616
+ this.spec = spec;
32617
+ this.deps = deps;
32618
+ const hold = spec.hold;
32619
+ this.core = hold === void 0 ? void 0 : new HoldCore(predicateOf(spec, void 0) === void 0 ? {
32620
+ ...hold,
32621
+ mode: "stable"
32622
+ } : hold);
32623
+ }
32624
+ dispose() {
32625
+ this.disposed = true;
32626
+ this.disarm();
32627
+ }
32628
+ disarm() {
32629
+ if (this.handle !== void 0) this.deps.timers.clear(this.handle);
32630
+ this.handle = void 0;
32631
+ }
32632
+ trace(phase, reading) {
32633
+ const hold = this.spec.hold;
32634
+ const ms = hold?.ms ?? 0;
32635
+ const base = {
32636
+ phase,
32637
+ ms,
32638
+ mode: this.core === void 0 || hold === void 0 ? "held" : hold.mode
32639
+ };
32640
+ if (reading.since === null) return base;
32641
+ return {
32642
+ ...base,
32643
+ since: reading.since,
32644
+ ...phase === "pending" ? { deadline: reading.since + ms } : {}
32645
+ };
32646
+ }
32647
+ /** A KNOWN value. A failed read is not one: do not call this with it. */
32648
+ observe(value) {
32649
+ if (this.disposed) return;
32650
+ const now = this.deps.timers.now();
32651
+ const previous = this.previous;
32652
+ const first = !this.seeded;
32653
+ this.seeded = true;
32654
+ this.previous = value;
32655
+ const holds = predicateOf(this.spec, value);
32656
+ if (this.core === void 0) {
32657
+ if (first) return;
32658
+ if (holds === void 0 ? value !== previous : holds && predicateOf(this.spec, previous) !== true) this.deps.emit({
32659
+ kind: "fire",
32660
+ value
32661
+ });
32662
+ return;
32663
+ }
32664
+ const reading = this.core.observe(holds ?? true, value, now);
32665
+ if (reading.transition === "cancelled" || reading.phase === "idle") {
32666
+ if (reading.transition === "cancelled" && this.handle !== void 0) this.deps.emit({
32667
+ kind: "hold",
32668
+ value,
32669
+ hold: this.trace("cancelled", reading)
32670
+ });
32671
+ this.disarm();
32672
+ }
32673
+ if (reading.phase === "inherited") {
32674
+ this.consumed = true;
32675
+ if (reading.transition === "started") this.deps.emit({
32676
+ kind: "hold",
32677
+ value,
32678
+ hold: this.trace("reseeded", reading)
32679
+ });
32680
+ return;
32681
+ }
32682
+ if (reading.transition !== "none" && reading.phase === "pending") {
32683
+ this.consumed = false;
32684
+ this.disarm();
32685
+ this.handle = this.deps.timers.set(() => {
32686
+ this.due();
32687
+ }, reading.remainingMs);
32688
+ this.deps.emit({
32689
+ kind: "hold",
32690
+ value,
32691
+ hold: this.trace("pending", reading)
32692
+ });
32693
+ }
32694
+ }
32695
+ /** The deadline: re-read the field (a missed event must not fire a broken hold), then fire once. */
32696
+ async due() {
32697
+ this.handle = void 0;
32698
+ if (this.disposed || this.core === void 0) return;
32699
+ const read = await this.deps.read();
32700
+ if (this.disposed) return;
32701
+ if (read.ok) this.observe(read.value);
32702
+ if (this.handle !== void 0 || this.disposed) return;
32703
+ const now = this.deps.timers.now();
32704
+ const reading = this.core.read(now);
32705
+ if (reading.phase === "pending") {
32706
+ this.handle = this.deps.timers.set(() => {
32707
+ this.due();
32708
+ }, reading.remainingMs);
32709
+ return;
32710
+ }
32711
+ if (reading.phase !== "met" || this.consumed) return;
32712
+ this.consumed = true;
32713
+ this.deps.emit({
32714
+ kind: "fire",
32715
+ value: this.previous,
32716
+ hold: this.trace("fired", reading)
32717
+ });
32718
+ }
32719
+ };
32720
+ /** One line for a trace or a log: what a hold did. */
32721
+ function describeHold(hold) {
32722
+ const window = `${hold.mode === "stable" ? "stable" : "held"} for ${describeHoldMs(hold.ms)}`;
32723
+ switch (hold.phase) {
32724
+ case "pending": return `hold pending: ${window}${hold.deadline === void 0 ? "" : `, due ${new Date(hold.deadline).toISOString()}`}`;
32725
+ case "cancelled": return `hold cancelled: ${window} was broken before it completed`;
32726
+ case "fired": return `hold fired: ${window} completed`;
32727
+ case "reseeded": return `hold re-seeded: ${window} was already running when watching began, so it will not fire for this episode`;
32728
+ }
32729
+ }
32730
+ //#endregion
32421
32731
  //#region src/automation/when.ts
32422
32732
  /**
32423
32733
  * The `when` tree — the ONE place an automation says when it runs.
@@ -32475,18 +32785,52 @@ var DeviceBecomesLeafSchema = zod.z.object({
32475
32785
  deviceId: zod.z.number().int().nonnegative(),
32476
32786
  cap: zod.z.string().min(1),
32477
32787
  fieldPath: zod.z.string().min(1),
32478
- /** Fire when the field takes this value. Omit to fire on any change. */
32788
+ /** Fire when the field takes this value. Omit (with no `operator`) to fire on any change. */
32479
32789
  becomes: zod.z.union([
32480
32790
  zod.z.string(),
32481
32791
  zod.z.number(),
32482
32792
  zod.z.boolean()
32483
32793
  ]).optional(),
32484
- /** Only on a CHANGE of value, not on every re-report. */
32794
+ /**
32795
+ * A threshold or a range instead of an equality: "crosses above 3000", "enters
32796
+ * 18..24". The leaf fires on the TRANSITION into the predicate, never on a re-report.
32797
+ * `value` is in the field's base unit; `between` / `outside` take `[low, high]`.
32798
+ */
32799
+ operator: BecomesOperatorSchema.optional(),
32800
+ value: zod.z.union([
32801
+ zod.z.number(),
32802
+ zod.z.string(),
32803
+ zod.z.boolean(),
32804
+ zod.z.array(zod.z.number()).length(2)
32805
+ ]).optional(),
32806
+ /**
32807
+ * Hold: the transition (or, with no predicate, the new value) must stay for
32808
+ * `for.ms` before the leaf fires, ONCE per episode. See `hold.ts`.
32809
+ */
32810
+ for: HoldSpecSchema.optional(),
32811
+ /** @deprecated every leaf fires on a transition now; read as always on. */
32485
32812
  edge: zod.z.boolean().optional(),
32486
- /** The new value must hold this long before it counts. */
32487
- forMs: zod.z.number().int().min(0).max(864e5).optional(),
32813
+ /** @deprecated legacy `held` window — read through `holdOf` as `for: { ms, mode: 'held' }`. */
32814
+ forMs: zod.z.number().int().min(0).max(HOLD_MAX_MS).optional(),
32488
32815
  /** Collapse a burst into one occurrence. */
32489
32816
  debounceMs: zod.z.number().int().min(0).max(6e5).optional()
32817
+ }).superRefine((leaf, ctx) => {
32818
+ if (leaf.becomes !== void 0 && leaf.operator !== void 0) ctx.addIssue({
32819
+ code: "custom",
32820
+ message: "a leaf names `becomes` or `operator`, not both",
32821
+ path: ["operator"]
32822
+ });
32823
+ if (leaf.operator !== void 0 && leaf.value === void 0) ctx.addIssue({
32824
+ code: "custom",
32825
+ message: "an operator needs the value to compare to",
32826
+ path: ["value"]
32827
+ });
32828
+ const range = leaf.operator === "between" || leaf.operator === "outside";
32829
+ if (leaf.operator !== void 0 && range !== Array.isArray(leaf.value)) ctx.addIssue({
32830
+ code: "custom",
32831
+ message: range ? "a range takes [low, high]" : "only a range takes [low, high]",
32832
+ path: ["value"]
32833
+ });
32490
32834
  });
32491
32835
  var DeviceEventLeafSchema = zod.z.object({
32492
32836
  kind: zod.z.literal("device-event"),
@@ -32551,7 +32895,9 @@ var DeviceIsLeafSchema = zod.z.object({
32551
32895
  QuantityValueSchema
32552
32896
  ]),
32553
32897
  /** The unit the person picked for `value` (display only; `value` is in the base unit). */
32554
- unit: zod.z.string().min(1).optional()
32898
+ unit: zod.z.string().min(1).optional(),
32899
+ /** The comparison must hold (`held`) or the value stay put (`stable`) this long. */
32900
+ for: HoldSpecSchema.optional()
32555
32901
  });
32556
32902
  /**
32557
32903
  * True when the camera currently has a PARKED object matching `subjects` in at
@@ -32574,7 +32920,9 @@ var StationaryPresentLeafSchema = zod.z.object({
32574
32920
  var ExpressionLeafSchema = zod.z.object({
32575
32921
  kind: zod.z.literal("expression"),
32576
32922
  expr: zod.z.string().min(1).max(require_implemented_methods.MAX_EXPRESSION_SOURCE_LENGTH),
32577
- bindings: zod.z.record(zod.z.string().regex(require_implemented_methods.EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
32923
+ bindings: zod.z.record(zod.z.string().regex(require_implemented_methods.EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema),
32924
+ /** The expression must stay true this long. An expression has no single value, so only `held`. */
32925
+ for: HoldSpecSchema.optional()
32578
32926
  }).superRefine((src, ctx) => {
32579
32927
  const err = require_implemented_methods.validateExpressionSource(src);
32580
32928
  if (err !== null) ctx.addIssue({
@@ -32582,6 +32930,11 @@ var ExpressionLeafSchema = zod.z.object({
32582
32930
  message: err,
32583
32931
  path: ["expr"]
32584
32932
  });
32933
+ if (src.for?.mode === "stable") ctx.addIssue({
32934
+ code: "custom",
32935
+ message: "an expression is held, not stable: it has no single value to keep still",
32936
+ path: ["for", "mode"]
32937
+ });
32585
32938
  });
32586
32939
  var AutomationWhenSchema = zod.z.lazy(() => zod.z.discriminatedUnion("kind", [
32587
32940
  zod.z.object({
@@ -33151,6 +33504,535 @@ function validateRecipeBounds(recipe) {
33151
33504
  return validateWhenTree(recipe.when);
33152
33505
  }
33153
33506
  //#endregion
33507
+ //#region src/automation/condition-eval.ts
33508
+ /**
33509
+ * Evaluating an automation's condition tree against the ConditionMirror.
33510
+ *
33511
+ * D49: a trigger is a one-shot event, so its gate must never hang on a read
33512
+ * that can fail. Every field a condition leaf names is therefore kept in
33513
+ * memory — filled at start, updated off device state-changed events, reconciled
33514
+ * on a timer — and evaluation reads that memory ONLY. A value the mirror does
33515
+ * not hold is UNKNOWN, which is `fail` with a reason, never a throw and never a
33516
+ * `pass`. A failed refresh changes nothing: the previous value stays.
33517
+ *
33518
+ * The evaluator returns a node per tree position (containers, leaves, and the
33519
+ * ones a short-circuit never reached) with a stable path and a human reason, so
33520
+ * the editor can paint each block.
33521
+ */
33522
+ /**
33523
+ * The key a `stableId → device id` map answers on. A pair (`addonId`, `stableId`)
33524
+ * is a device; a bare stableId is only a device while no other addon shares it,
33525
+ * so the map's producer puts the bare key in ONLY when it is unique.
33526
+ */
33527
+ function stableIdKey(stableId, addonId) {
33528
+ return addonId === void 0 ? stableId : `${addonId}\u0000${stableId}`;
33529
+ }
33530
+ /**
33531
+ * The `stableIdKey → device id` map a mirror refresh hands back, from a device
33532
+ * listing. Every device is reachable by its (addonId, stableId) pair; the bare
33533
+ * stableId is offered only while NO other device shares it, so a legacy binding
33534
+ * that names no addon reads nothing rather than the wrong device.
33535
+ */
33536
+ function stableIdMapOf(devices) {
33537
+ const out = /* @__PURE__ */ new Map();
33538
+ const bare = /* @__PURE__ */ new Map();
33539
+ for (const d of devices) {
33540
+ if (d.stableId === void 0) continue;
33541
+ if (d.addonId !== void 0) out.set(stableIdKey(d.stableId, d.addonId), d.id);
33542
+ bare.set(d.stableId, bare.has(d.stableId) ? null : d.id);
33543
+ }
33544
+ for (const [stableId, id] of bare) if (id !== null) out.set(stableId, id);
33545
+ return out;
33546
+ }
33547
+ /** The cap whose runtime-state slice IS the occupancy snapshot, parked objects included. */
33548
+ var ZONE_ANALYTICS_CAP = "zone-analytics";
33549
+ function collectInto(cond, out) {
33550
+ switch (cond.kind) {
33551
+ case "all":
33552
+ case "any":
33553
+ for (const child of cond.children) collectInto(child, out);
33554
+ return;
33555
+ case "not":
33556
+ collectInto(cond.child, out);
33557
+ return;
33558
+ case "device-is":
33559
+ out.push({
33560
+ kind: "device",
33561
+ deviceId: cond.deviceId,
33562
+ cap: cond.cap
33563
+ });
33564
+ return;
33565
+ case "stationary-present":
33566
+ out.push({
33567
+ kind: "device",
33568
+ deviceId: cond.deviceId,
33569
+ cap: ZONE_ANALYTICS_CAP
33570
+ });
33571
+ return;
33572
+ case "expression":
33573
+ for (const binding of Object.values(cond.bindings)) if (binding.kind === "global") out.push({
33574
+ kind: "stable",
33575
+ stableId: binding.sourceStableId,
33576
+ cap: binding.cap,
33577
+ ...binding.addonId !== void 0 ? { addonId: binding.addonId } : {}
33578
+ });
33579
+ return;
33580
+ default: return;
33581
+ }
33582
+ }
33583
+ /** Every (device, cap) a `when` tree's STATE leaves read, deduplicated. */
33584
+ function collectWhenMirrorSources(cond) {
33585
+ if (cond === void 0) return [];
33586
+ const all = [];
33587
+ collectInto(cond, all);
33588
+ const seen = /* @__PURE__ */ new Set();
33589
+ return all.filter((s) => {
33590
+ const key = s.kind === "device" ? `d|${s.deviceId}|${s.cap}` : `s|${stableIdKey(s.stableId, s.addonId)}|${s.cap}`;
33591
+ if (seen.has(key)) return false;
33592
+ seen.add(key);
33593
+ return true;
33594
+ });
33595
+ }
33596
+ /** Legacy name, for blocks generated before the single tree: an old condition tree. */
33597
+ function collectMirrorSources(cond) {
33598
+ return collectWhenMirrorSources(cond === void 0 ? void 0 : convertLegacyCondition(cond));
33599
+ }
33600
+ function sliceKey(deviceId, cap) {
33601
+ return `${deviceId}|${cap}`;
33602
+ }
33603
+ function pick$1(slice, fieldPath) {
33604
+ let cursor = slice;
33605
+ for (const part of fieldPath.split(".")) {
33606
+ if (cursor === null || typeof cursor !== "object") return void 0;
33607
+ cursor = Reflect.get(cursor, part);
33608
+ }
33609
+ return cursor;
33610
+ }
33611
+ function isSliceObject(value) {
33612
+ return typeof value === "object" && value !== null;
33613
+ }
33614
+ var ConditionMirror = class {
33615
+ sources;
33616
+ slices = /* @__PURE__ */ new Map();
33617
+ stableIds = /* @__PURE__ */ new Map();
33618
+ watched;
33619
+ constructor(sources) {
33620
+ this.sources = sources;
33621
+ this.watched = new Set(sources.filter((s) => s.kind === "device").map((s) => sliceKey(s.deviceId, s.cap)));
33622
+ }
33623
+ /** A `device.state-changed` event. Slices nobody reads are ignored. */
33624
+ apply(deviceId, cap, slice) {
33625
+ const key = sliceKey(deviceId, cap);
33626
+ if (!isSliceObject(slice)) return;
33627
+ if (!this.watched.has(key) && !this.isStableTarget(deviceId, cap)) return;
33628
+ this.slices.set(key, slice);
33629
+ }
33630
+ isStableTarget(deviceId, cap) {
33631
+ for (const s of this.sources) if (s.kind === "stable" && s.cap === cap && this.stableIds.get(stableIdKey(s.stableId, s.addonId)) === deviceId) return true;
33632
+ return false;
33633
+ }
33634
+ read(deviceId, cap, fieldPath) {
33635
+ const slice = this.slices.get(sliceKey(deviceId, cap));
33636
+ return slice === void 0 ? void 0 : pick$1(slice, fieldPath);
33637
+ }
33638
+ /** The whole slice the mirror holds for a device cap — `undefined` when it holds none. */
33639
+ sliceOf(deviceId, cap) {
33640
+ return this.slices.get(sliceKey(deviceId, cap));
33641
+ }
33642
+ readStable(stableId, cap, fieldPath, addonId) {
33643
+ const deviceId = this.stableIds.get(stableIdKey(stableId, addonId));
33644
+ return deviceId === void 0 ? void 0 : this.read(deviceId, cap, fieldPath);
33645
+ }
33646
+ /** Fill / reconcile. A read that fails or answers nothing keeps the old value. */
33647
+ async refresh(fetchers) {
33648
+ let updated = 0;
33649
+ let kept = 0;
33650
+ if (this.sources.some((s) => s.kind === "stable")) try {
33651
+ this.stableIds = await fetchers.fetchStableIds();
33652
+ } catch {}
33653
+ const targets = /* @__PURE__ */ new Map();
33654
+ for (const s of this.sources) {
33655
+ const deviceId = s.kind === "device" ? s.deviceId : this.stableIds.get(stableIdKey(s.stableId, s.addonId));
33656
+ if (deviceId === void 0) {
33657
+ kept += 1;
33658
+ continue;
33659
+ }
33660
+ targets.set(sliceKey(deviceId, s.cap), {
33661
+ deviceId,
33662
+ cap: s.cap
33663
+ });
33664
+ }
33665
+ for (const [key, target] of targets) try {
33666
+ const slice = await fetchers.fetchSlice(target.deviceId, target.cap);
33667
+ if (isSliceObject(slice)) {
33668
+ this.slices.set(key, slice);
33669
+ updated += 1;
33670
+ } else kept += 1;
33671
+ } catch {
33672
+ kept += 1;
33673
+ }
33674
+ return {
33675
+ updated,
33676
+ kept
33677
+ };
33678
+ }
33679
+ };
33680
+ var OPERATOR_SYMBOL = {
33681
+ eq: "=",
33682
+ ne: "≠",
33683
+ gt: ">",
33684
+ gte: "≥",
33685
+ lt: "<",
33686
+ lte: "≤",
33687
+ contains: "contains",
33688
+ in: "in"
33689
+ };
33690
+ var compare = compareValues;
33691
+ function toTraceValue(value) {
33692
+ if (value === void 0 || value === null) return null;
33693
+ if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
33694
+ if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) return value;
33695
+ return JSON.stringify(value);
33696
+ }
33697
+ function show(value) {
33698
+ return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
33699
+ }
33700
+ function markSkipped(cond, path, why, out) {
33701
+ out.push({
33702
+ path,
33703
+ kind: cond.kind,
33704
+ outcome: "not-evaluated",
33705
+ reason: why
33706
+ });
33707
+ if (cond.kind === "all" || cond.kind === "any") cond.children.forEach((c, i) => {
33708
+ markSkipped(c, `${path}.${i}`, why, out);
33709
+ });
33710
+ else if (cond.kind === "not") markSkipped(cond.child, `${path}.0`, why, out);
33711
+ }
33712
+ function parkedObjectsOf(value) {
33713
+ if (!Array.isArray(value)) return [];
33714
+ const rows = [];
33715
+ for (const item of value) {
33716
+ const id = Reflect.get(Object(item), "id");
33717
+ const className = Reflect.get(Object(item), "className");
33718
+ if (typeof id === "string" && typeof className === "string") rows.push({
33719
+ id,
33720
+ className
33721
+ });
33722
+ }
33723
+ return rows;
33724
+ }
33725
+ /** `zoneId`s whose `trackIds` list the parked object (`stationary:<id>`, as the snapshot builds it). */
33726
+ function zonesOfParked(zones, parkedId) {
33727
+ if (!Array.isArray(zones)) return [];
33728
+ const out = [];
33729
+ for (const zone of zones) {
33730
+ const zoneId = Reflect.get(Object(zone), "zoneId");
33731
+ const trackIds = Reflect.get(Object(zone), "trackIds");
33732
+ if (typeof zoneId === "string" && Array.isArray(trackIds) && trackIds.includes(`stationary:${parkedId}`)) out.push(zoneId);
33733
+ }
33734
+ return out;
33735
+ }
33736
+ /**
33737
+ * Is a matching parked object there NOW? Read off the mirrored zone-analytics
33738
+ * snapshot: `frame` is always present in a snapshot, so its absence means the
33739
+ * slice was never read (UNKNOWN, a fail that says so), while a snapshot without
33740
+ * `stationaryObjects` is a definite "nothing parked" (the provider omits an
33741
+ * empty list).
33742
+ */
33743
+ function judgeStationaryPresent(cond, reader) {
33744
+ if (reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "frame") === void 0) return {
33745
+ pass: false,
33746
+ why: `device ${cond.deviceId} occupancy snapshot unknown`,
33747
+ unknown: true
33748
+ };
33749
+ const parked = parkedObjectsOf(reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "stationaryObjects"));
33750
+ if (parked.length === 0) return {
33751
+ pass: false,
33752
+ why: `no parked objects on device ${cond.deviceId}`
33753
+ };
33754
+ const zones = reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "zones");
33755
+ const matching = [];
33756
+ for (const obj of parked) {
33757
+ if (cond.subjects !== void 0 && !anySubjectMatches(cond.subjects, { className: obj.className }).matches) continue;
33758
+ if (cond.zones !== void 0) {
33759
+ const inZones = zonesOfParked(zones, obj.id);
33760
+ if (!cond.zones.some((z) => inZones.includes(z))) continue;
33761
+ }
33762
+ matching.push(obj);
33763
+ }
33764
+ const needed = cond.minCount ?? 1;
33765
+ const first = matching[0];
33766
+ if (first !== void 0 && matching.length >= needed) return {
33767
+ pass: true,
33768
+ why: needed === 1 ? `parked ${first.className} (${first.id}) on device ${cond.deviceId}` : `${matching.length} parked matching on device ${cond.deviceId} (need ${needed})`
33769
+ };
33770
+ if (matching.length > 0) return {
33771
+ pass: false,
33772
+ why: `only ${matching.length} of ${needed} needed parked objects match on device ${cond.deviceId}`
33773
+ };
33774
+ return {
33775
+ pass: false,
33776
+ why: `${parked.length} parked on device ${cond.deviceId}, none matching the class/zone filter`
33777
+ };
33778
+ }
33779
+ function noteDue(state, hold) {
33780
+ if (hold?.due === void 0) return;
33781
+ state.holdDueInMs = state.holdDueInMs === void 0 ? hold.due : Math.min(state.holdDueInMs, hold.due);
33782
+ }
33783
+ /** What a state leaf's hold says, given whether the leaf's own condition is true NOW. */
33784
+ function judgeHold(hold, reading, conditionTrue) {
33785
+ const window = `${hold.mode === "stable" ? "stable" : "held"} for ${describeHoldMs(hold.ms)}`;
33786
+ if (reading === void 0) return {
33787
+ pass: false,
33788
+ unknown: true,
33789
+ why: `${window}: nothing keeps this leaf's history here`
33790
+ };
33791
+ switch (reading.phase) {
33792
+ case "met": return {
33793
+ pass: true,
33794
+ unknown: false,
33795
+ why: `${window}: met`
33796
+ };
33797
+ case "pending": return {
33798
+ due: reading.remainingMs,
33799
+ pass: false,
33800
+ unknown: false,
33801
+ why: `${window}: ${describeHoldMs(hold.ms - reading.remainingMs)} so far`
33802
+ };
33803
+ case "inherited": return {
33804
+ pass: false,
33805
+ unknown: true,
33806
+ why: `${window}: it was already true when watching began, so how long it has held is not known`
33807
+ };
33808
+ case "idle": return {
33809
+ pass: false,
33810
+ unknown: false,
33811
+ why: conditionTrue ? `${window}: just changed` : `${window}: the condition is not true`
33812
+ };
33813
+ }
33814
+ }
33815
+ function evalEventLeaf(cond, path, state, out) {
33816
+ const occurred = state.firedPath === path;
33817
+ out.push({
33818
+ path,
33819
+ kind: cond.kind,
33820
+ outcome: occurred ? "pass" : "fail",
33821
+ reason: occurred ? `${cond.kind} occurred → pass` : `${cond.kind} is an instant and did not occur now → fail`
33822
+ });
33823
+ return occurred;
33824
+ }
33825
+ function evalNode(cond, path, reader, now, out, state) {
33826
+ if (isEventLeaf(cond)) return evalEventLeaf(cond, path, state, out);
33827
+ switch (cond.kind) {
33828
+ case "device-is": {
33829
+ const observed = reader.read(cond.deviceId, cond.cap, cond.fieldPath);
33830
+ const base = {
33831
+ path,
33832
+ kind: cond.kind,
33833
+ deviceId: cond.deviceId,
33834
+ cap: cond.cap,
33835
+ fieldPath: cond.fieldPath,
33836
+ operator: cond.operator,
33837
+ expected: toTraceValue(cond.value),
33838
+ observed: toTraceValue(observed)
33839
+ };
33840
+ if (isQuantityValue(cond.value)) {
33841
+ out.push({
33842
+ ...base,
33843
+ outcome: "fail",
33844
+ reason: `${cond.fieldPath} expected value's unit was never converted → fail`
33845
+ });
33846
+ return false;
33847
+ }
33848
+ if (observed === void 0) {
33849
+ state.unknown = true;
33850
+ out.push({
33851
+ ...base,
33852
+ outcome: "fail",
33853
+ reason: `${cond.fieldPath} value unknown → fail`
33854
+ });
33855
+ return false;
33856
+ }
33857
+ const compared = compare(observed, cond.operator, cond.value);
33858
+ const hold = cond.for === void 0 ? void 0 : judgeHold(cond.for, state.holds?.observe(path, cond.for, {
33859
+ holds: compared,
33860
+ value: observed
33861
+ }, now), compared);
33862
+ if (hold?.unknown === true) state.unknown = true;
33863
+ noteDue(state, hold);
33864
+ const ok = compared && (hold === void 0 || hold.pass);
33865
+ out.push({
33866
+ ...base,
33867
+ outcome: ok ? "pass" : "fail",
33868
+ reason: `${cond.fieldPath} ${show(observed)}, expected ${OPERATOR_SYMBOL[cond.operator]} ${show(cond.value)}${hold === void 0 ? "" : ` (${hold.why})`} → ${ok ? "pass" : "fail"}`
33869
+ });
33870
+ return ok;
33871
+ }
33872
+ case "stationary-present": {
33873
+ const verdict = judgeStationaryPresent(cond, reader);
33874
+ if (verdict.unknown === true) state.unknown = true;
33875
+ out.push({
33876
+ path,
33877
+ kind: cond.kind,
33878
+ outcome: verdict.pass ? "pass" : "fail",
33879
+ reason: `${verdict.why} → ${verdict.pass ? "pass" : "fail"}`,
33880
+ deviceId: cond.deviceId,
33881
+ cap: ZONE_ANALYTICS_CAP
33882
+ });
33883
+ return verdict.pass;
33884
+ }
33885
+ case "expression": {
33886
+ const values = {};
33887
+ for (const [alias, binding] of Object.entries(cond.bindings)) {
33888
+ if (binding.kind === "literal") {
33889
+ values[alias] = require_implemented_methods.toExpressionValue(binding.value) ?? null;
33890
+ continue;
33891
+ }
33892
+ const raw = binding.kind === "global" ? reader.readStable(binding.sourceStableId, binding.cap, binding.fieldPath, binding.addonId) : void 0;
33893
+ if (raw === void 0) {
33894
+ out.push({
33895
+ path,
33896
+ kind: cond.kind,
33897
+ outcome: "fail",
33898
+ reason: `${alias} value unknown → fail`
33899
+ });
33900
+ state.unknown = true;
33901
+ return false;
33902
+ }
33903
+ values[alias] = require_implemented_methods.toExpressionValue(raw) ?? null;
33904
+ }
33905
+ const result = require_implemented_methods.evaluateExpressionSource(cond.expr, values, now);
33906
+ if (!result.ok) {
33907
+ out.push({
33908
+ path,
33909
+ kind: cond.kind,
33910
+ outcome: "fail",
33911
+ reason: `${cond.expr}: ${result.error} → fail`
33912
+ });
33913
+ return false;
33914
+ }
33915
+ const truth = result.value === true;
33916
+ const hold = cond.for === void 0 ? void 0 : judgeHold(cond.for, state.holds?.observe(path, cond.for, {
33917
+ holds: truth,
33918
+ value: truth
33919
+ }, now), truth);
33920
+ if (hold?.unknown === true) state.unknown = true;
33921
+ noteDue(state, hold);
33922
+ const ok = truth && (hold === void 0 || hold.pass);
33923
+ out.push({
33924
+ path,
33925
+ kind: cond.kind,
33926
+ outcome: ok ? "pass" : "fail",
33927
+ reason: `${cond.expr} with ${JSON.stringify(values)}${hold === void 0 ? "" : ` (${hold.why})`} → ${ok ? "pass" : "fail"}`
33928
+ });
33929
+ return ok;
33930
+ }
33931
+ case "not": {
33932
+ const at = out.length;
33933
+ out.push({
33934
+ path,
33935
+ kind: "not",
33936
+ outcome: "not-evaluated",
33937
+ reason: ""
33938
+ });
33939
+ const inner = evalNode(cond.child, `${path}.0`, reader, now, out, state);
33940
+ const ok = !inner;
33941
+ out.splice(at, 1, {
33942
+ path,
33943
+ kind: "not",
33944
+ outcome: ok ? "pass" : "fail",
33945
+ reason: `not (${inner ? "pass" : "fail"}) → ${ok ? "pass" : "fail"}`
33946
+ });
33947
+ return ok;
33948
+ }
33949
+ case "all":
33950
+ case "any": {
33951
+ const isAll = cond.kind === "all";
33952
+ const at = out.length;
33953
+ out.push({
33954
+ path,
33955
+ kind: cond.kind,
33956
+ outcome: "not-evaluated",
33957
+ reason: ""
33958
+ });
33959
+ let decided = null;
33960
+ for (let i = 0; i < cond.children.length; i += 1) {
33961
+ const child = cond.children[i];
33962
+ if (child === void 0) continue;
33963
+ if (decided !== null) {
33964
+ markSkipped(child, `${path}.${i}`, `short-circuited by ${path}.${decided}`, out);
33965
+ continue;
33966
+ }
33967
+ const ok = evalNode(child, `${path}.${i}`, reader, now, out, state);
33968
+ if (isAll ? !ok : ok) decided = i;
33969
+ }
33970
+ const ok = isAll ? decided === null : decided !== null;
33971
+ const reason = isAll ? ok ? `all ${cond.children.length} passed → pass` : `${path}.${decided} failed → fail` : ok ? `${path}.${decided} passed → pass` : `none of ${cond.children.length} passed → fail`;
33972
+ out.splice(at, 1, {
33973
+ path,
33974
+ kind: cond.kind,
33975
+ outcome: ok ? "pass" : "fail",
33976
+ reason
33977
+ });
33978
+ return ok;
33979
+ }
33980
+ }
33981
+ }
33982
+ /** Evaluate a `when` tree: the fired event leaf is true, every other event leaf false. */
33983
+ function evaluateWhenTree(when, reader, now, options = {}) {
33984
+ const nodes = [];
33985
+ const state = {
33986
+ firedPath: options.firedPath,
33987
+ holds: options.holds,
33988
+ unknown: false,
33989
+ holdDueInMs: void 0
33990
+ };
33991
+ return {
33992
+ pass: evalNode(when, options.rootPath ?? "when", reader, now, nodes, state),
33993
+ unknown: state.unknown,
33994
+ nodes,
33995
+ ...state.holdDueInMs === void 0 ? {} : { holdDueInMs: state.holdDueInMs }
33996
+ };
33997
+ }
33998
+ /** Does any state leaf of the tree carry a `for`? */
33999
+ function hasHoldLeaves(when) {
34000
+ let found = false;
34001
+ forEachLeaf(when, (leaf) => {
34002
+ if ((leaf.kind === "device-is" || leaf.kind === "expression") && leaf.for !== void 0) found = true;
34003
+ });
34004
+ return found;
34005
+ }
34006
+ /**
34007
+ * Feed the clock of EVERY `for` leaf, each on its own: a short-circuit in the
34008
+ * tree (an event leaf that is false right now) must not stop a hold from
34009
+ * counting. Returns the soonest a pending hold completes (ms), or undefined.
34010
+ */
34011
+ function observeHoldLeaves(when, reader, now, holds, rootPath = "when") {
34012
+ let due;
34013
+ forEachLeaf(when, (leaf, path) => {
34014
+ if (leaf.kind !== "device-is" && leaf.kind !== "expression" || leaf.for === void 0) return;
34015
+ const state = {
34016
+ firedPath: void 0,
34017
+ holds,
34018
+ unknown: false,
34019
+ holdDueInMs: void 0
34020
+ };
34021
+ evalNode(leaf, path, reader, now, [], state);
34022
+ if (state.holdDueInMs !== void 0) due = due === void 0 ? state.holdDueInMs : Math.min(due, state.holdDueInMs);
34023
+ }, rootPath);
34024
+ return due;
34025
+ }
34026
+ /** Legacy name, for blocks generated before the single tree. No tree is a pass with no nodes. */
34027
+ function evaluateConditionTree(cond, reader, now) {
34028
+ if (cond === void 0) return {
34029
+ pass: true,
34030
+ unknown: false,
34031
+ nodes: []
34032
+ };
34033
+ return evaluateWhenTree(convertLegacyCondition(cond), reader, now, { rootPath: "conditions" });
34034
+ }
34035
+ //#endregion
33154
34036
  //#region src/automation/trigger-variables.ts
33155
34037
  var DETECTION_DESCRIPTIONS = {
33156
34038
  deviceId: "the camera that saw it",
@@ -33290,44 +34172,67 @@ function emitLeaf(trigger, path) {
33290
34172
  ),
33291
34173
  )`;
33292
34174
  case "device-becomes": {
33293
- const becomes = trigger.becomes === void 0 ? "undefined" : j(trigger.becomes);
34175
+ const hold = holdOf(trigger);
33294
34176
  return ` // event leaf ${path}: device state — the mirror is the authority, the
33295
34177
  // event only WAKES the evaluation, so a dropped event delays and never loses.
34178
+ // It fires on a TRANSITION (never on a re-report or the reconcile); a hold is
34179
+ // a timer armed when the transition happens and fired ONCE per episode.
33296
34180
  {
33297
- let previous: unknown = undefined
33298
34181
  let debounce: ReturnType<typeof setTimeout> | undefined
33299
- let heldSince: number | undefined
34182
+ const watch = new BecomesWatch(${j({
34183
+ ...trigger.becomes === void 0 ? {} : { becomes: trigger.becomes },
34184
+ ...trigger.operator === void 0 ? {} : {
34185
+ operator: trigger.operator,
34186
+ value: trigger.value
34187
+ },
34188
+ ...hold === void 0 ? {} : { hold }
34189
+ })}, {
34190
+ timers: {
34191
+ set: (fn, ms) => setTimeout(fn, ms),
34192
+ clear: (handle) => clearTimeout(handle),
34193
+ now: () => Date.now(),
34194
+ },
34195
+ read: () => readField(${j(trigger.deviceId)}, ${j(trigger.cap)}, ${j(trigger.fieldPath)}),
34196
+ emit: (effect) => {
34197
+ const occurrence = {
34198
+ kind: 'device-becomes',
34199
+ leaf: ${at},
34200
+ at: Date.now(),
34201
+ deviceId: ${j(trigger.deviceId)},
34202
+ cap: ${j(trigger.cap)},
34203
+ field: ${j(trigger.fieldPath)},
34204
+ to: toTraceScalar(effect.value),
34205
+ ...(effect.hold === undefined ? {} : { hold: effect.hold }),
34206
+ }
34207
+ if (effect.kind === 'fire') {
34208
+ if (effect.hold !== undefined) {
34209
+ ctx.logger.info(describeHold(effect.hold), { tags: { deviceId: ${j(trigger.deviceId)} }, leaf: ${at} })
34210
+ }
34211
+ void run(occurrence, effect.hold === undefined ? 'fired' : describeHold(effect.hold))
34212
+ return
34213
+ }
34214
+ ctx.logger.debug(describeHold(effect.hold), { tags: { deviceId: ${j(trigger.deviceId)} }, leaf: ${at} })
34215
+ record(
34216
+ skipTrace(occurrence, describeHold(effect.hold), 'skipped-trigger', undefined, effect.hold.phase === 'pending'),
34217
+ )
34218
+ },
34219
+ })
34220
+ disposers.push(() => watch.dispose())
33300
34221
  const check = async (): Promise<void> => {
33301
- const value = await readField(${j(trigger.deviceId)}, ${j(trigger.cap)}, ${j(trigger.fieldPath)})
33302
- const want = ${becomes}
33303
- const matches = want === undefined ? value !== previous : value === want
33304
- const changed = value !== previous
33305
- previous = value
33306
- if (!matches) { heldSince = undefined; return }
33307
- if (${trigger.edge === true ? "true" : "false"} && !changed) return
33308
- const forMs = ${j(trigger.forMs ?? 0)}
33309
- if (forMs > 0) {
33310
- if (heldSince === undefined) { heldSince = Date.now(); return }
33311
- if (Date.now() - heldSince < forMs) return
33312
- }
33313
- heldSince = undefined
33314
- void run({
33315
- kind: 'device-becomes',
33316
- leaf: ${at},
33317
- at: Date.now(),
33318
- deviceId: ${j(trigger.deviceId)},
33319
- cap: ${j(trigger.cap)},
33320
- field: ${j(trigger.fieldPath)},
33321
- to: value,
33322
- })
34222
+ const read = await readField(${j(trigger.deviceId)}, ${j(trigger.cap)}, ${j(trigger.fieldPath)})
34223
+ if (!read.ok) return // a failed read changes nothing, and never cancels a hold (D49)
34224
+ watch.observe(read.value)
33323
34225
  }
33324
34226
  const wake = (): void => {
33325
34227
  if (debounce !== undefined) clearTimeout(debounce)
33326
34228
  debounce = setTimeout(() => { void check() }, ${j(trigger.debounceMs ?? 0)})
33327
34229
  }
34230
+ disposers.push(() => { if (debounce !== undefined) clearTimeout(debounce) })
33328
34231
  disposers.push(
33329
34232
  ctx.eventBus.subscribe({ category: 'device.state-changed', deviceId: ${j(trigger.deviceId)} }, wake),
33330
34233
  )
34234
+ // Seed what the field holds NOW without firing: a restart is not a transition.
34235
+ void check()
33331
34236
  const reconcile = setInterval(() => { void check() }, RECONCILE_MS)
33332
34237
  disposers.push(() => clearInterval(reconcile))
33333
34238
  }`;
@@ -33413,20 +34318,20 @@ function emitLeafBody(action) {
33413
34318
  }
33414
34319
  }
33415
34320
  /** A step's `if` (#472) and its else list, as the fields of a RunnableStep. */
33416
- function emitGuard(action) {
34321
+ function emitGuard(action, index) {
33417
34322
  if (action.kind !== "wait" && action.kind !== "cap") return "";
33418
34323
  if (action.if === void 0) return "";
33419
34324
  const otherwise = (action.else ?? []).map((el) => {
33420
34325
  const body = emitLeafBody(el);
33421
34326
  return `{ meta: ${j(stepMetaOf(el))}, run: async (scope) => {\n${body ?? ""}\n } }`;
33422
34327
  }).join(", ");
33423
- return ` guard: () => evaluateCondition(${j(action.if)}),${otherwise === "" ? "" : `\n otherwise: [${otherwise}],`}
34328
+ return ` guard: () => evaluateCondition(${j(action.if)}, ${j(`actions.${index}.if`)}),${otherwise === "" ? "" : `\n otherwise: [${otherwise}],`}
33424
34329
  `;
33425
34330
  }
33426
34331
  function emitAction(action, index) {
33427
34332
  const step = (body) => ` {
33428
34333
  meta: STEP_META[${index}]!,
33429
- ${emitGuard(action)} run: async (scope) => {
34334
+ ${emitGuard(action, index)} run: async (scope) => {
33430
34335
  ${body}
33431
34336
  },
33432
34337
  },`;
@@ -33466,6 +34371,10 @@ function generateAutomationBlock(input) {
33466
34371
  const runMode = recipe.runMode ?? { mode: "single" };
33467
34372
  const stepMeta = recipe.actions.map(stepMetaOf);
33468
34373
  const hasDomainTarget = recipe.actions.some((a) => a.kind === "cap" && normalizeCapStep(a).target.kind === "domain");
34374
+ const guardHoldTrees = recipe.actions.flatMap((a, i) => (a.kind === "wait" || a.kind === "cap") && a.if !== void 0 && hasHoldLeaves(a.if) ? [{
34375
+ path: `actions.${i}.if`,
34376
+ when: a.if
34377
+ }] : []);
33469
34378
  const eventLeaves = [];
33470
34379
  forEachLeaf(recipe.when, (leaf, path) => {
33471
34380
  if (isEventLeaf(leaf)) eventLeaves.push({
@@ -33489,18 +34398,22 @@ function generateAutomationBlock(input) {
33489
34398
  import {
33490
34399
  ACTION_TARGET_INVALIDATION_EVENTS,
33491
34400
  ActionTargetResolver,
34401
+ BecomesWatch,
33492
34402
  ConditionMirror,
34403
+ HoldTracker,
33493
34404
  DetectionTriggerFilter,
33494
34405
  EventCategory,
33495
34406
  RunGate,
33496
34407
  buildTriggerTrace,
33497
34408
  collectWhenMirrorSources,
33498
34409
  coreBlockIdFromAddonId,
34410
+ describeHold,
33499
34411
  evaluateWhenTree,
33500
34412
  evaluateStationaryTrigger,
33501
34413
  isSkippedTrace,
33502
34414
  mergeSkipTraces,
33503
34415
  nextOccurrence,
34416
+ observeHoldLeaves,
33504
34417
  stableIdMapOf,
33505
34418
  resolveStepArgs,
33506
34419
  resolveStepArgsWithTemplates,
@@ -33545,6 +34458,12 @@ const STEP_META: ReadonlyArray<{ kind: string; cap?: string; method?: string; ac
33545
34458
  /** True when a step acts on a whole domain: only then does the block listen for registry changes. */
33546
34459
  const HAS_DOMAIN_TARGET = ${hasDomainTarget}
33547
34460
 
34461
+ /** A state leaf of the tree carries a \`for\`: its clock is fed on every mirror update, so it counts while nothing fires. */
34462
+ const HAS_HOLD = ${hasHoldLeaves(recipe.when)}
34463
+
34464
+ /** Guards (a step's \`if\`) with a \`for\`: they keep their own mirror and clocks, fed the same way. */
34465
+ const GUARD_HOLD_TREES: ReadonlyArray<{ path: string; when: AutomationWhen }> = ${j(guardHoldTrees)}
34466
+
33548
34467
  /** setTimeout cannot arm past 2^31-1 ms; a longer wait re-arms on wake. */
33549
34468
  const MAX_TIMER_MS = 2_000_000_000
33550
34469
 
@@ -33601,6 +34520,12 @@ export default function block(ctx: AddonContext) {
33601
34520
  const gate = new RunGate(RUN_MODE)
33602
34521
  const MIRROR_SOURCES = collectWhenMirrorSources(WHEN)
33603
34522
  const mirror = new ConditionMirror(MIRROR_SOURCES)
34523
+ const holds = new HoldTracker()
34524
+ const guardMirror = new ConditionMirror(
34525
+ collectWhenMirrorSources({ kind: 'all', children: GUARD_HOLD_TREES.map((t) => t.when) }),
34526
+ )
34527
+ const guardHolds = new HoldTracker()
34528
+ let holdTimer: ReturnType<typeof setTimeout> | undefined
33604
34529
  const BLOCK_ID = coreBlockIdFromAddonId(ctx.id)
33605
34530
  /** The cooldown stamp: memory is the authority at fire time (D49); the hub ledger is read once at start. */
33606
34531
  let lastRunStartedAt: number | null = null
@@ -33710,6 +34635,40 @@ export default function block(ctx: AddonContext) {
33710
34635
  if (report.kept > 0) {
33711
34636
  ctx.logger.debug('condition mirror kept stale values for sources it could not read', report)
33712
34637
  }
34638
+ if (GUARD_HOLD_TREES.length > 0) await guardMirror.refresh(mirrorFetchers())
34639
+ }
34640
+
34641
+ function mirrorFetchers() {
34642
+ return {
34643
+ fetchSlice: (deviceId: number, cap: string) => ctx.api.deviceState.getCapSlice.query({ deviceId, capName: cap }),
34644
+ fetchStableIds: async () => {
34645
+ const all = await ctx.api.deviceManager.listAll.query({})
34646
+ return stableIdMapOf(all)
34647
+ },
34648
+ }
34649
+ }
34650
+
34651
+ /** Feed the clock of every \`for\` (the tree's and the guards'), and arm a timer for the
34652
+ * soonest pending one so a hold completes ON TIME, not at the next reconcile. */
34653
+ function feedHolds(): void {
34654
+ if (stopped) return
34655
+ const now = Date.now()
34656
+ const dues: number[] = []
34657
+ if (HAS_HOLD) {
34658
+ const due = observeHoldLeaves(WHEN, mirror, now, holds)
34659
+ if (due !== undefined) dues.push(due)
34660
+ }
34661
+ for (const tree of GUARD_HOLD_TREES) {
34662
+ const due = observeHoldLeaves(tree.when, guardMirror, now, guardHolds, tree.path)
34663
+ if (due !== undefined) dues.push(due)
34664
+ }
34665
+ if (holdTimer !== undefined) clearTimeout(holdTimer)
34666
+ holdTimer = undefined
34667
+ if (dues.length === 0) return
34668
+ holdTimer = setTimeout(() => {
34669
+ feedHolds()
34670
+ evaluateStateTree()
34671
+ }, Math.min(Math.max(Math.min(...dues), 0), MAX_TIMER_MS))
33713
34672
  }
33714
34673
 
33715
34674
  /** The next moment a schedule leaf fires, from the CURRENT site. A sun spec on
@@ -33740,28 +34699,39 @@ export default function block(ctx: AddonContext) {
33740
34699
  }
33741
34700
  }
33742
34701
 
33743
- /** Read one cap field off the state mirror. Returns undefined when the device,
34702
+ /** Read one cap field off the state mirror. \`ok: false\` when the device,
33744
34703
  * the cap or the field cannot be resolved — the caller decides what that
33745
- * means, and it always logs. (Used by the device-state TRIGGER, which the
33746
- * reconcile backs; conditions read the ConditionMirror instead.) */
34704
+ * means (the device-state trigger changes nothing), and it is logged at
34705
+ * debug with the device. (Conditions read the ConditionMirror instead.) */
33747
34706
  async function readField(
33748
34707
  deviceId: number,
33749
34708
  cap: string,
33750
34709
  fieldPath: string,
33751
- ): Promise<unknown> {
34710
+ ): Promise<{ readonly ok: true; readonly value: unknown } | { readonly ok: false }> {
33752
34711
  try {
33753
34712
  const slice = await ctx.api.deviceState.getCapSlice.query({ deviceId, capName: cap })
33754
34713
  let cursor: unknown = slice
33755
34714
  for (const part of fieldPath.split('.')) {
33756
- if (cursor === null || typeof cursor !== 'object') return undefined
33757
- cursor = (cursor as Record<string, unknown>)[part]
34715
+ if (cursor === null || typeof cursor !== 'object') return { ok: false }
34716
+ cursor = Reflect.get(cursor, part)
33758
34717
  }
33759
- return cursor
33760
- } catch {
33761
- return undefined
34718
+ if (cursor === undefined) return { ok: false }
34719
+ return { ok: true, value: cursor }
34720
+ } catch (err: unknown) {
34721
+ ctx.logger.debug('device state read failed — the leaf keeps what it knew', {
34722
+ tags: { deviceId },
34723
+ cap,
34724
+ error: err instanceof Error ? err.message : String(err),
34725
+ })
34726
+ return { ok: false }
33762
34727
  }
33763
34728
  }
33764
34729
 
34730
+ /** A trigger var keeps primitives only. */
34731
+ function toTraceScalar(value: unknown): string | number | boolean | null {
34732
+ return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' ? value : null
34733
+ }
34734
+
33765
34735
  /** WHO a step acts on (D983): picked devices, a \`$var\`, or a whole domain
33766
34736
  * resolved NOW. The cache is dropped on every registry event that can change
33767
34737
  * it; an empty answer is logged by the resolver and traced as \`empty\`. */
@@ -33865,14 +34835,11 @@ export default function block(ctx: AddonContext) {
33865
34835
  }
33866
34836
 
33867
34837
  /** A step's \`if\` (#472), read on a mirror filled for exactly its leaves, NOW (D49: unread = unknown). */
33868
- function evaluateCondition(when: AutomationWhen) {
33869
- return evaluateStepCondition(when, {
33870
- fetchSlice: (deviceId, cap) => ctx.api.deviceState.getCapSlice.query({ deviceId, capName: cap }),
33871
- fetchStableIds: async () => {
33872
- const all = await ctx.api.deviceManager.listAll.query({})
33873
- return stableIdMapOf(all)
33874
- },
33875
- })
34838
+ function evaluateCondition(when: AutomationWhen, path: string) {
34839
+ const history = GUARD_HOLD_TREES.some((t) => t.path === path)
34840
+ ? { mirror: guardMirror, holds: guardHolds, rootPath: path }
34841
+ : undefined
34842
+ return evaluateStepCondition(when, mirrorFetchers(), Date.now, history)
33876
34843
  }
33877
34844
 
33878
34845
  /** The THEN half, through the ONE shared step runner: stops at the first
@@ -33959,6 +34926,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
33959
34926
  try {
33960
34927
  const firedLeaf = trigger['leaf']
33961
34928
  const evaluation = evaluateWhenTree(WHEN, mirror, Date.now(), {
34929
+ holds,
33962
34930
  ...(typeof firedLeaf === 'string' ? { firedPath: firedLeaf } : {}),
33963
34931
  })
33964
34932
  nodes = [...evaluation.nodes]
@@ -34073,6 +35041,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
34073
35041
  const ready: Promise<void> = (async () => {
34074
35042
  await loadState()
34075
35043
  await refreshMirror()
35044
+ feedHolds()
34076
35045
  stateWatching = true
34077
35046
  evaluateStateTree()
34078
35047
  })()
@@ -34087,7 +35056,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
34087
35056
  let stateWatching = false
34088
35057
  function evaluateStateTree(): void {
34089
35058
  if (!STATE_ONLY || !stateWatching || stopped) return
34090
- const evaluation = evaluateWhenTree(WHEN, mirror, Date.now())
35059
+ const evaluation = evaluateWhenTree(WHEN, mirror, Date.now(), { holds })
34091
35060
  if (evaluation.unknown) return
34092
35061
  const was = treeWasTrue
34093
35062
  treeWasTrue = evaluation.pass
@@ -34096,7 +35065,7 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
34096
35065
  }
34097
35066
  }
34098
35067
 
34099
- if (MIRROR_SOURCES.length > 0) {
35068
+ if (MIRROR_SOURCES.length > 0 || GUARD_HOLD_TREES.length > 0) {
34100
35069
  disposers.push(
34101
35070
  ctx.eventBus.subscribe({ category: EventCategory.DeviceStateChanged }, (event) => {
34102
35071
  const data = event.data
@@ -34104,12 +35073,17 @@ ${recipe.actions.map((a, i) => emitAction(a, i)).join("\n")}
34104
35073
  const capName = data['capName']
34105
35074
  if (typeof deviceId === 'number' && typeof capName === 'string') {
34106
35075
  mirror.apply(deviceId, capName, data['slice'])
35076
+ guardMirror.apply(deviceId, capName, data['slice'])
35077
+ feedHolds()
34107
35078
  evaluateStateTree()
34108
35079
  }
34109
35080
  }),
34110
35081
  )
34111
35082
  const mirrorReconcile = setInterval(() => {
34112
- void refreshMirror().then(evaluateStateTree)
35083
+ void refreshMirror().then(() => {
35084
+ feedHolds()
35085
+ evaluateStateTree()
35086
+ })
34113
35087
  }, RECONCILE_MS)
34114
35088
  disposers.push(() => clearInterval(mirrorReconcile))
34115
35089
  }
@@ -34118,6 +35092,7 @@ ${eventLeaves.map(({ leaf, path }) => emitLeaf(leaf, path)).join("\n\n")}
34118
35092
 
34119
35093
  return () => {
34120
35094
  stopped = true
35095
+ if (holdTimer !== undefined) clearTimeout(holdTimer)
34121
35096
  queue.length = 0
34122
35097
  flushSkip()
34123
35098
  for (const running of runningTokens) {
@@ -34130,465 +35105,6 @@ ${eventLeaves.map(({ leaf, path }) => emitLeaf(leaf, path)).join("\n\n")}
34130
35105
  `;
34131
35106
  }
34132
35107
  //#endregion
34133
- //#region src/automation/condition-eval.ts
34134
- /**
34135
- * Evaluating an automation's condition tree against the ConditionMirror.
34136
- *
34137
- * D49: a trigger is a one-shot event, so its gate must never hang on a read
34138
- * that can fail. Every field a condition leaf names is therefore kept in
34139
- * memory — filled at start, updated off device state-changed events, reconciled
34140
- * on a timer — and evaluation reads that memory ONLY. A value the mirror does
34141
- * not hold is UNKNOWN, which is `fail` with a reason, never a throw and never a
34142
- * `pass`. A failed refresh changes nothing: the previous value stays.
34143
- *
34144
- * The evaluator returns a node per tree position (containers, leaves, and the
34145
- * ones a short-circuit never reached) with a stable path and a human reason, so
34146
- * the editor can paint each block.
34147
- */
34148
- /**
34149
- * The key a `stableId → device id` map answers on. A pair (`addonId`, `stableId`)
34150
- * is a device; a bare stableId is only a device while no other addon shares it,
34151
- * so the map's producer puts the bare key in ONLY when it is unique.
34152
- */
34153
- function stableIdKey(stableId, addonId) {
34154
- return addonId === void 0 ? stableId : `${addonId}\u0000${stableId}`;
34155
- }
34156
- /**
34157
- * The `stableIdKey → device id` map a mirror refresh hands back, from a device
34158
- * listing. Every device is reachable by its (addonId, stableId) pair; the bare
34159
- * stableId is offered only while NO other device shares it, so a legacy binding
34160
- * that names no addon reads nothing rather than the wrong device.
34161
- */
34162
- function stableIdMapOf(devices) {
34163
- const out = /* @__PURE__ */ new Map();
34164
- const bare = /* @__PURE__ */ new Map();
34165
- for (const d of devices) {
34166
- if (d.stableId === void 0) continue;
34167
- if (d.addonId !== void 0) out.set(stableIdKey(d.stableId, d.addonId), d.id);
34168
- bare.set(d.stableId, bare.has(d.stableId) ? null : d.id);
34169
- }
34170
- for (const [stableId, id] of bare) if (id !== null) out.set(stableId, id);
34171
- return out;
34172
- }
34173
- /** The cap whose runtime-state slice IS the occupancy snapshot, parked objects included. */
34174
- var ZONE_ANALYTICS_CAP = "zone-analytics";
34175
- function collectInto(cond, out) {
34176
- switch (cond.kind) {
34177
- case "all":
34178
- case "any":
34179
- for (const child of cond.children) collectInto(child, out);
34180
- return;
34181
- case "not":
34182
- collectInto(cond.child, out);
34183
- return;
34184
- case "device-is":
34185
- out.push({
34186
- kind: "device",
34187
- deviceId: cond.deviceId,
34188
- cap: cond.cap
34189
- });
34190
- return;
34191
- case "stationary-present":
34192
- out.push({
34193
- kind: "device",
34194
- deviceId: cond.deviceId,
34195
- cap: ZONE_ANALYTICS_CAP
34196
- });
34197
- return;
34198
- case "expression":
34199
- for (const binding of Object.values(cond.bindings)) if (binding.kind === "global") out.push({
34200
- kind: "stable",
34201
- stableId: binding.sourceStableId,
34202
- cap: binding.cap,
34203
- ...binding.addonId !== void 0 ? { addonId: binding.addonId } : {}
34204
- });
34205
- return;
34206
- default: return;
34207
- }
34208
- }
34209
- /** Every (device, cap) a `when` tree's STATE leaves read, deduplicated. */
34210
- function collectWhenMirrorSources(cond) {
34211
- if (cond === void 0) return [];
34212
- const all = [];
34213
- collectInto(cond, all);
34214
- const seen = /* @__PURE__ */ new Set();
34215
- return all.filter((s) => {
34216
- const key = s.kind === "device" ? `d|${s.deviceId}|${s.cap}` : `s|${stableIdKey(s.stableId, s.addonId)}|${s.cap}`;
34217
- if (seen.has(key)) return false;
34218
- seen.add(key);
34219
- return true;
34220
- });
34221
- }
34222
- /** Legacy name, for blocks generated before the single tree: an old condition tree. */
34223
- function collectMirrorSources(cond) {
34224
- return collectWhenMirrorSources(cond === void 0 ? void 0 : convertLegacyCondition(cond));
34225
- }
34226
- function sliceKey(deviceId, cap) {
34227
- return `${deviceId}|${cap}`;
34228
- }
34229
- function pick$1(slice, fieldPath) {
34230
- let cursor = slice;
34231
- for (const part of fieldPath.split(".")) {
34232
- if (cursor === null || typeof cursor !== "object") return void 0;
34233
- cursor = Reflect.get(cursor, part);
34234
- }
34235
- return cursor;
34236
- }
34237
- function isSliceObject(value) {
34238
- return typeof value === "object" && value !== null;
34239
- }
34240
- var ConditionMirror = class {
34241
- sources;
34242
- slices = /* @__PURE__ */ new Map();
34243
- stableIds = /* @__PURE__ */ new Map();
34244
- watched;
34245
- constructor(sources) {
34246
- this.sources = sources;
34247
- this.watched = new Set(sources.filter((s) => s.kind === "device").map((s) => sliceKey(s.deviceId, s.cap)));
34248
- }
34249
- /** A `device.state-changed` event. Slices nobody reads are ignored. */
34250
- apply(deviceId, cap, slice) {
34251
- const key = sliceKey(deviceId, cap);
34252
- if (!isSliceObject(slice)) return;
34253
- if (!this.watched.has(key) && !this.isStableTarget(deviceId, cap)) return;
34254
- this.slices.set(key, slice);
34255
- }
34256
- isStableTarget(deviceId, cap) {
34257
- for (const s of this.sources) if (s.kind === "stable" && s.cap === cap && this.stableIds.get(stableIdKey(s.stableId, s.addonId)) === deviceId) return true;
34258
- return false;
34259
- }
34260
- read(deviceId, cap, fieldPath) {
34261
- const slice = this.slices.get(sliceKey(deviceId, cap));
34262
- return slice === void 0 ? void 0 : pick$1(slice, fieldPath);
34263
- }
34264
- /** The whole slice the mirror holds for a device cap — `undefined` when it holds none. */
34265
- sliceOf(deviceId, cap) {
34266
- return this.slices.get(sliceKey(deviceId, cap));
34267
- }
34268
- readStable(stableId, cap, fieldPath, addonId) {
34269
- const deviceId = this.stableIds.get(stableIdKey(stableId, addonId));
34270
- return deviceId === void 0 ? void 0 : this.read(deviceId, cap, fieldPath);
34271
- }
34272
- /** Fill / reconcile. A read that fails or answers nothing keeps the old value. */
34273
- async refresh(fetchers) {
34274
- let updated = 0;
34275
- let kept = 0;
34276
- if (this.sources.some((s) => s.kind === "stable")) try {
34277
- this.stableIds = await fetchers.fetchStableIds();
34278
- } catch {}
34279
- const targets = /* @__PURE__ */ new Map();
34280
- for (const s of this.sources) {
34281
- const deviceId = s.kind === "device" ? s.deviceId : this.stableIds.get(stableIdKey(s.stableId, s.addonId));
34282
- if (deviceId === void 0) {
34283
- kept += 1;
34284
- continue;
34285
- }
34286
- targets.set(sliceKey(deviceId, s.cap), {
34287
- deviceId,
34288
- cap: s.cap
34289
- });
34290
- }
34291
- for (const [key, target] of targets) try {
34292
- const slice = await fetchers.fetchSlice(target.deviceId, target.cap);
34293
- if (isSliceObject(slice)) {
34294
- this.slices.set(key, slice);
34295
- updated += 1;
34296
- } else kept += 1;
34297
- } catch {
34298
- kept += 1;
34299
- }
34300
- return {
34301
- updated,
34302
- kept
34303
- };
34304
- }
34305
- };
34306
- var OPERATOR_SYMBOL = {
34307
- eq: "=",
34308
- ne: "≠",
34309
- gt: ">",
34310
- gte: "≥",
34311
- lt: "<",
34312
- lte: "≤",
34313
- contains: "contains",
34314
- in: "in"
34315
- };
34316
- function compare(actual, operator, expected) {
34317
- switch (operator) {
34318
- case "eq": return actual === expected;
34319
- case "ne": return actual !== expected;
34320
- case "gt": return typeof actual === "number" && typeof expected === "number" && actual > expected;
34321
- case "gte": return typeof actual === "number" && typeof expected === "number" && actual >= expected;
34322
- case "lt": return typeof actual === "number" && typeof expected === "number" && actual < expected;
34323
- case "lte": return typeof actual === "number" && typeof expected === "number" && actual <= expected;
34324
- case "contains": return typeof actual === "string" && typeof expected === "string" && actual.includes(expected);
34325
- case "in": return Array.isArray(expected) && expected.some((v) => v === actual);
34326
- }
34327
- }
34328
- function toTraceValue(value) {
34329
- if (value === void 0 || value === null) return null;
34330
- if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
34331
- if (Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number")) return value;
34332
- return JSON.stringify(value);
34333
- }
34334
- function show(value) {
34335
- return Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
34336
- }
34337
- function markSkipped(cond, path, why, out) {
34338
- out.push({
34339
- path,
34340
- kind: cond.kind,
34341
- outcome: "not-evaluated",
34342
- reason: why
34343
- });
34344
- if (cond.kind === "all" || cond.kind === "any") cond.children.forEach((c, i) => {
34345
- markSkipped(c, `${path}.${i}`, why, out);
34346
- });
34347
- else if (cond.kind === "not") markSkipped(cond.child, `${path}.0`, why, out);
34348
- }
34349
- function parkedObjectsOf(value) {
34350
- if (!Array.isArray(value)) return [];
34351
- const rows = [];
34352
- for (const item of value) {
34353
- const id = Reflect.get(Object(item), "id");
34354
- const className = Reflect.get(Object(item), "className");
34355
- if (typeof id === "string" && typeof className === "string") rows.push({
34356
- id,
34357
- className
34358
- });
34359
- }
34360
- return rows;
34361
- }
34362
- /** `zoneId`s whose `trackIds` list the parked object (`stationary:<id>`, as the snapshot builds it). */
34363
- function zonesOfParked(zones, parkedId) {
34364
- if (!Array.isArray(zones)) return [];
34365
- const out = [];
34366
- for (const zone of zones) {
34367
- const zoneId = Reflect.get(Object(zone), "zoneId");
34368
- const trackIds = Reflect.get(Object(zone), "trackIds");
34369
- if (typeof zoneId === "string" && Array.isArray(trackIds) && trackIds.includes(`stationary:${parkedId}`)) out.push(zoneId);
34370
- }
34371
- return out;
34372
- }
34373
- /**
34374
- * Is a matching parked object there NOW? Read off the mirrored zone-analytics
34375
- * snapshot: `frame` is always present in a snapshot, so its absence means the
34376
- * slice was never read (UNKNOWN, a fail that says so), while a snapshot without
34377
- * `stationaryObjects` is a definite "nothing parked" (the provider omits an
34378
- * empty list).
34379
- */
34380
- function judgeStationaryPresent(cond, reader) {
34381
- if (reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "frame") === void 0) return {
34382
- pass: false,
34383
- why: `device ${cond.deviceId} occupancy snapshot unknown`,
34384
- unknown: true
34385
- };
34386
- const parked = parkedObjectsOf(reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "stationaryObjects"));
34387
- if (parked.length === 0) return {
34388
- pass: false,
34389
- why: `no parked objects on device ${cond.deviceId}`
34390
- };
34391
- const zones = reader.read(cond.deviceId, ZONE_ANALYTICS_CAP, "zones");
34392
- const matching = [];
34393
- for (const obj of parked) {
34394
- if (cond.subjects !== void 0 && !anySubjectMatches(cond.subjects, { className: obj.className }).matches) continue;
34395
- if (cond.zones !== void 0) {
34396
- const inZones = zonesOfParked(zones, obj.id);
34397
- if (!cond.zones.some((z) => inZones.includes(z))) continue;
34398
- }
34399
- matching.push(obj);
34400
- }
34401
- const needed = cond.minCount ?? 1;
34402
- const first = matching[0];
34403
- if (first !== void 0 && matching.length >= needed) return {
34404
- pass: true,
34405
- why: needed === 1 ? `parked ${first.className} (${first.id}) on device ${cond.deviceId}` : `${matching.length} parked matching on device ${cond.deviceId} (need ${needed})`
34406
- };
34407
- if (matching.length > 0) return {
34408
- pass: false,
34409
- why: `only ${matching.length} of ${needed} needed parked objects match on device ${cond.deviceId}`
34410
- };
34411
- return {
34412
- pass: false,
34413
- why: `${parked.length} parked on device ${cond.deviceId}, none matching the class/zone filter`
34414
- };
34415
- }
34416
- function evalEventLeaf(cond, path, state, out) {
34417
- const occurred = state.firedPath === path;
34418
- out.push({
34419
- path,
34420
- kind: cond.kind,
34421
- outcome: occurred ? "pass" : "fail",
34422
- reason: occurred ? `${cond.kind} occurred → pass` : `${cond.kind} is an instant and did not occur now → fail`
34423
- });
34424
- return occurred;
34425
- }
34426
- function evalNode(cond, path, reader, now, out, state) {
34427
- if (isEventLeaf(cond)) return evalEventLeaf(cond, path, state, out);
34428
- switch (cond.kind) {
34429
- case "device-is": {
34430
- const observed = reader.read(cond.deviceId, cond.cap, cond.fieldPath);
34431
- const base = {
34432
- path,
34433
- kind: cond.kind,
34434
- deviceId: cond.deviceId,
34435
- cap: cond.cap,
34436
- fieldPath: cond.fieldPath,
34437
- operator: cond.operator,
34438
- expected: toTraceValue(cond.value),
34439
- observed: toTraceValue(observed)
34440
- };
34441
- if (isQuantityValue(cond.value)) {
34442
- out.push({
34443
- ...base,
34444
- outcome: "fail",
34445
- reason: `${cond.fieldPath} expected value's unit was never converted → fail`
34446
- });
34447
- return false;
34448
- }
34449
- if (observed === void 0) {
34450
- state.unknown = true;
34451
- out.push({
34452
- ...base,
34453
- outcome: "fail",
34454
- reason: `${cond.fieldPath} value unknown → fail`
34455
- });
34456
- return false;
34457
- }
34458
- const ok = compare(observed, cond.operator, cond.value);
34459
- out.push({
34460
- ...base,
34461
- outcome: ok ? "pass" : "fail",
34462
- reason: `${cond.fieldPath} ${show(observed)}, expected ${OPERATOR_SYMBOL[cond.operator]} ${show(cond.value)} → ${ok ? "pass" : "fail"}`
34463
- });
34464
- return ok;
34465
- }
34466
- case "stationary-present": {
34467
- const verdict = judgeStationaryPresent(cond, reader);
34468
- if (verdict.unknown === true) state.unknown = true;
34469
- out.push({
34470
- path,
34471
- kind: cond.kind,
34472
- outcome: verdict.pass ? "pass" : "fail",
34473
- reason: `${verdict.why} → ${verdict.pass ? "pass" : "fail"}`,
34474
- deviceId: cond.deviceId,
34475
- cap: ZONE_ANALYTICS_CAP
34476
- });
34477
- return verdict.pass;
34478
- }
34479
- case "expression": {
34480
- const values = {};
34481
- for (const [alias, binding] of Object.entries(cond.bindings)) {
34482
- if (binding.kind === "literal") {
34483
- values[alias] = require_implemented_methods.toExpressionValue(binding.value) ?? null;
34484
- continue;
34485
- }
34486
- const raw = binding.kind === "global" ? reader.readStable(binding.sourceStableId, binding.cap, binding.fieldPath, binding.addonId) : void 0;
34487
- if (raw === void 0) {
34488
- out.push({
34489
- path,
34490
- kind: cond.kind,
34491
- outcome: "fail",
34492
- reason: `${alias} value unknown → fail`
34493
- });
34494
- state.unknown = true;
34495
- return false;
34496
- }
34497
- values[alias] = require_implemented_methods.toExpressionValue(raw) ?? null;
34498
- }
34499
- const result = require_implemented_methods.evaluateExpressionSource(cond.expr, values, now);
34500
- if (!result.ok) {
34501
- out.push({
34502
- path,
34503
- kind: cond.kind,
34504
- outcome: "fail",
34505
- reason: `${cond.expr}: ${result.error} → fail`
34506
- });
34507
- return false;
34508
- }
34509
- const ok = result.value === true;
34510
- out.push({
34511
- path,
34512
- kind: cond.kind,
34513
- outcome: ok ? "pass" : "fail",
34514
- reason: `${cond.expr} with ${JSON.stringify(values)} → ${ok ? "pass" : "fail"}`
34515
- });
34516
- return ok;
34517
- }
34518
- case "not": {
34519
- const at = out.length;
34520
- out.push({
34521
- path,
34522
- kind: "not",
34523
- outcome: "not-evaluated",
34524
- reason: ""
34525
- });
34526
- const inner = evalNode(cond.child, `${path}.0`, reader, now, out, state);
34527
- const ok = !inner;
34528
- out.splice(at, 1, {
34529
- path,
34530
- kind: "not",
34531
- outcome: ok ? "pass" : "fail",
34532
- reason: `not (${inner ? "pass" : "fail"}) → ${ok ? "pass" : "fail"}`
34533
- });
34534
- return ok;
34535
- }
34536
- case "all":
34537
- case "any": {
34538
- const isAll = cond.kind === "all";
34539
- const at = out.length;
34540
- out.push({
34541
- path,
34542
- kind: cond.kind,
34543
- outcome: "not-evaluated",
34544
- reason: ""
34545
- });
34546
- let decided = null;
34547
- for (let i = 0; i < cond.children.length; i += 1) {
34548
- const child = cond.children[i];
34549
- if (child === void 0) continue;
34550
- if (decided !== null) {
34551
- markSkipped(child, `${path}.${i}`, `short-circuited by ${path}.${decided}`, out);
34552
- continue;
34553
- }
34554
- const ok = evalNode(child, `${path}.${i}`, reader, now, out, state);
34555
- if (isAll ? !ok : ok) decided = i;
34556
- }
34557
- const ok = isAll ? decided === null : decided !== null;
34558
- const reason = isAll ? ok ? `all ${cond.children.length} passed → pass` : `${path}.${decided} failed → fail` : ok ? `${path}.${decided} passed → pass` : `none of ${cond.children.length} passed → fail`;
34559
- out.splice(at, 1, {
34560
- path,
34561
- kind: cond.kind,
34562
- outcome: ok ? "pass" : "fail",
34563
- reason
34564
- });
34565
- return ok;
34566
- }
34567
- }
34568
- }
34569
- /** Evaluate a `when` tree: the fired event leaf is true, every other event leaf false. */
34570
- function evaluateWhenTree(when, reader, now, options = {}) {
34571
- const nodes = [];
34572
- const state = {
34573
- firedPath: options.firedPath,
34574
- unknown: false
34575
- };
34576
- return {
34577
- pass: evalNode(when, options.rootPath ?? "when", reader, now, nodes, state),
34578
- unknown: state.unknown,
34579
- nodes
34580
- };
34581
- }
34582
- /** Legacy name, for blocks generated before the single tree. No tree is a pass with no nodes. */
34583
- function evaluateConditionTree(cond, reader, now) {
34584
- if (cond === void 0) return {
34585
- pass: true,
34586
- unknown: false,
34587
- nodes: []
34588
- };
34589
- return evaluateWhenTree(convertLegacyCondition(cond), reader, now, { rootPath: "conditions" });
34590
- }
34591
- //#endregion
34592
35108
  //#region src/automation/detection-trigger.ts
34593
35109
  /**
34594
35110
  * The `detection` trigger's per-event decision: does this track-lifecycle
@@ -35224,7 +35740,9 @@ var AutomationTriggerTraceSchema = zod.z.object({
35224
35740
  /** Why an event was rejected ("class person not in [dog]") or what fired. */
35225
35741
  reason: zod.z.string(),
35226
35742
  /** deviceId, className, trackId, score … — only what the trigger exposes. */
35227
- vars: zod.z.record(zod.z.string(), TraceValueSchema)
35743
+ vars: zod.z.record(zod.z.string(), TraceValueSchema),
35744
+ /** A hold (`for`) this occurrence went through: pending, cancelled, fired or re-seeded. */
35745
+ hold: HoldTraceSchema.optional()
35228
35746
  });
35229
35747
  var AutomationConditionTraceNodeSchema = zod.z.object({
35230
35748
  /** `when` for the root, `when.<i>` for its i-th child, … (`conditions…` on an old trace). */
@@ -35459,12 +35977,14 @@ function buildTriggerTrace(trigger, outcome, reason) {
35459
35977
  }
35460
35978
  const kind = typeof trigger["kind"] === "string" ? trigger["kind"] : "unknown";
35461
35979
  const path = typeof trigger["leaf"] === "string" ? trigger["leaf"] : void 0;
35980
+ const hold = HoldTraceSchema.safeParse(trigger["hold"]);
35462
35981
  return {
35463
35982
  kind,
35464
35983
  ...path === void 0 ? {} : { path },
35465
35984
  outcome,
35466
35985
  reason,
35467
- vars
35986
+ vars,
35987
+ ...hold.success ? { hold: hold.data } : {}
35468
35988
  };
35469
35989
  }
35470
35990
  //#endregion
@@ -35705,10 +36225,13 @@ var ActionRunChangedSchema = zod.z.object({
35705
36225
  * nothing, and never decides a branch).
35706
36226
  */
35707
36227
  /** Fill a mirror for the tree's leaves from `fetchers` and judge it NOW. */
35708
- async function evaluateStepCondition(when, fetchers, now = Date.now) {
35709
- const mirror = new ConditionMirror(collectWhenMirrorSources(when));
36228
+ async function evaluateStepCondition(when, fetchers, now = Date.now, history) {
36229
+ const mirror = history?.mirror ?? new ConditionMirror(collectWhenMirrorSources(when));
35710
36230
  await mirror.refresh(fetchers);
35711
- const evaluation = evaluateWhenTree(when, mirror, now());
36231
+ const evaluation = evaluateWhenTree(when, mirror, now(), { ...history === void 0 ? {} : {
36232
+ holds: history.holds,
36233
+ rootPath: history.rootPath
36234
+ } });
35712
36235
  const first = evaluation.nodes.filter((n) => n.outcome !== "pass").map((n) => n.reason)[0];
35713
36236
  if (evaluation.unknown) return {
35714
36237
  result: "unknown",
@@ -56795,13 +57318,11 @@ var HeroConfirmSchema = zod.z.enum([
56795
57318
  "press"
56796
57319
  ]);
56797
57320
  var HeroActionSchema = zod.z.object({
56798
- /** Unique within the model; the `gated` list and the specs name it. */
56799
57321
  id: zod.z.string(),
56800
57322
  label: HeroTextSchema,
56801
57323
  icon: IconKeySchema,
56802
57324
  call: HeroCallSchema,
56803
57325
  emphasis: zod.z.enum(["primary", "normal"]),
56804
- /** Ask before running it. */
56805
57326
  confirm: HeroConfirmSchema.nullable()
56806
57327
  });
56807
57328
  var HeroControlSchema = zod.z.discriminatedUnion("kind", [
@@ -56897,9 +57418,18 @@ var HeroBadgeSchema = zod.z.object({
56897
57418
  value: zod.z.number().nullable(),
56898
57419
  label: HeroTextSchema
56899
57420
  });
56900
- var HeroRemoteSlotSchema = zod.z.object({
56901
- /** Saved commands; `null` = not known yet (the button still shows). */
56902
- commands: zod.z.number().int().nullable() });
57421
+ /** The id of the action a row recognises as "open the device's remote". */
57422
+ var REMOTE_OPEN_ACTION_ID = "remote.open";
57423
+ var HeroRemoteSlotSchema = zod.z.object({
57424
+ /** Saved commands; `null` = not known yet (the button still shows). */
57425
+ commands: zod.z.number().int().nullable(),
57426
+ /**
57427
+ * The control a list row draws as the "open the remote" icon. Recognised by its id
57428
+ * ({@link REMOTE_OPEN_ACTION_ID}); it changes no state, so a client opens the remote
57429
+ * instead of running `call`. Absent on a model from an older server.
57430
+ */
57431
+ open: HeroActionSchema.optional()
57432
+ });
56903
57433
  var HeroConsumableItemSchema = zod.z.object({
56904
57434
  key: zod.z.string(),
56905
57435
  label: zod.z.string(),
@@ -57070,6 +57600,8 @@ var HeroModelSchema = zod.z.object({
57070
57600
  * the FIRST row that has any (a later row's control is never promoted). When
57071
57601
  * the model lists that part in `gated`, the row has no inline control: the
57072
57602
  * projection never falls through to another control the caller could use.
57603
+ * - a climate or thermostat row's primary is its `climate.mode` control (no power
57604
+ * toggle: "off" is a mode); when the model gates it the rule above applies as before;
57073
57605
  * - a timed run, when the model carries the slot, sits beside that primary:
57074
57606
  * Run while idle, Stop while armed. Gating the slot hides the control.
57075
57607
  * - the status line is the head (what plays, else the state) plus at most
@@ -57077,6 +57609,13 @@ var HeroModelSchema = zod.z.object({
57077
57609
  * time left on an armed timed run;
57078
57610
  * - the trailing fact is the first of power, battery, consumables.
57079
57611
  *
57612
+ * - `extras` are the further inline controls of the types that carry more than one
57613
+ * ({@link ROW_EXTRAS_BY_TYPE}): climate setpoint, a robot's return to base,
57614
+ * a player's volume and remote. Each is a control the model already has, named by id,
57615
+ * in that order and at most {@link ROW_EXTRAS_MAX}; one the model lacks, or lists in
57616
+ * `gated`, is absent, and the one `primary` already is never repeats. Empty = the
57617
+ * row of an older server: `primary` alone.
57618
+ *
57080
57619
  * `projectDeviceRow` is pure and computes nothing: it selects from a
57081
57620
  * {@link HeroModel}. A row that needed a value the hero lacks would mean the
57082
57621
  * model is missing it, so the fix goes in the model.
@@ -57108,6 +57647,12 @@ var HeroRowModelSchema = zod.z.object({
57108
57647
  * while armed. `null` when there is no slot, or the caller may not act.
57109
57648
  */
57110
57649
  timedRun: HeroRowTimedRunSchema.nullable(),
57650
+ /**
57651
+ * The further inline controls after `primary`, in order (see the header). The remote
57652
+ * is an `action` with id `remote.open`: the client opens the remote, it does not run
57653
+ * the call. Absent or empty = `primary` alone.
57654
+ */
57655
+ extras: zod.z.array(HeroControlSchema).max(2).optional(),
57111
57656
  trailing: HeroFactSchema.nullable()
57112
57657
  });
57113
57658
  /** The trailing fact, in order of preference. */
@@ -57123,7 +57668,20 @@ function trailingOf(facts) {
57123
57668
  }
57124
57669
  return null;
57125
57670
  }
57671
+ /**
57672
+ * A type whose primary is a named control, not its power: a climate row is the mode
57673
+ * (which carries "off") and the setpoint, with no power toggle.
57674
+ */
57675
+ var ROW_PRIMARY_BY_TYPE = {
57676
+ [require_composed_stable_id.DeviceType.Climate]: "climate.mode",
57677
+ [require_composed_stable_id.DeviceType.Thermostat]: "climate.mode"
57678
+ };
57126
57679
  function primaryOf(model) {
57680
+ const named = ROW_PRIMARY_BY_TYPE[model.type];
57681
+ if (named !== void 0) {
57682
+ const found = extraOf(model, named);
57683
+ if (found !== null) return found;
57684
+ }
57127
57685
  const power = model.ownPower;
57128
57686
  if (power !== null) {
57129
57687
  if (model.gated.includes("own-power")) return null;
@@ -57143,6 +57701,43 @@ function primaryOf(model) {
57143
57701
  }
57144
57702
  return null;
57145
57703
  }
57704
+ /**
57705
+ * The extras of a type, by control id, in the order they are drawn. The ids are the
57706
+ * model's own: a `remote.open` is read from the model's remote slot, every other
57707
+ * from the rows. A type not listed has no extras.
57708
+ */
57709
+ var ROW_EXTRAS_BY_TYPE = {
57710
+ [require_composed_stable_id.DeviceType.Climate]: ["climate.target"],
57711
+ [require_composed_stable_id.DeviceType.Thermostat]: ["climate.target"],
57712
+ [require_composed_stable_id.DeviceType.Vacuum]: ["vacuum.base"],
57713
+ [require_composed_stable_id.DeviceType.LawnMower]: ["mower.dock"],
57714
+ [require_composed_stable_id.DeviceType.MediaPlayer]: ["volume.level", REMOTE_OPEN_ACTION_ID]
57715
+ };
57716
+ var controlId = (c) => c.kind === "action" ? c.action.id : c.id;
57717
+ function extraOf(model, id) {
57718
+ if (id === "remote.open") {
57719
+ const open = model.remote?.open;
57720
+ if (open === void 0 || model.gated.includes("remote")) return null;
57721
+ return {
57722
+ kind: "action",
57723
+ action: open
57724
+ };
57725
+ }
57726
+ for (const row of model.rows) {
57727
+ if (model.gated.includes(row.id)) continue;
57728
+ const found = row.controls.find((c) => controlId(c) === id);
57729
+ if (found !== void 0) return found;
57730
+ }
57731
+ return null;
57732
+ }
57733
+ function extrasOf(model, primary) {
57734
+ const ids = ROW_EXTRAS_BY_TYPE[model.type] ?? [];
57735
+ const taken = primary === null ? null : controlId(primary);
57736
+ return ids.filter((id) => id !== taken).flatMap((id) => {
57737
+ const found = extraOf(model, id);
57738
+ return found === null ? [] : [found];
57739
+ }).slice(0, 2);
57740
+ }
57146
57741
  function statusLineOf(model, trailing) {
57147
57742
  const head = model.rows.find((r) => r.id === "now-playing")?.status ?? null ?? model.title;
57148
57743
  const rest = model.facts.filter((f) => f !== trailing).map((f) => f.text).slice(0, 3);
@@ -57171,6 +57766,7 @@ function timedRunOf(model) {
57171
57766
  }
57172
57767
  function projectDeviceRow(model) {
57173
57768
  const trailing = trailingOf(model.facts);
57769
+ const primary = primaryOf(model);
57174
57770
  return {
57175
57771
  deviceId: model.deviceId,
57176
57772
  name: model.name,
@@ -57180,8 +57776,9 @@ function projectDeviceRow(model) {
57180
57776
  look: model.look,
57181
57777
  scene: model.scene,
57182
57778
  statusLine: statusLineOf(model, trailing),
57183
- primary: primaryOf(model),
57779
+ primary,
57184
57780
  timedRun: timedRunOf(model),
57781
+ extras: extrasOf(model, primary),
57185
57782
  trailing
57186
57783
  };
57187
57784
  }
@@ -104217,7 +104814,10 @@ var powerSourceContribution = contribution("power-source", PowerSourceStateSchem
104217
104814
  /** The remote cap has no status: the model's input carries how many commands it holds. */
104218
104815
  var remoteContribution = {
104219
104816
  cap: "remote",
104220
- contribute: (_slice, ctx) => ctx.remoteCommands === 0 ? {} : { remote: { commands: ctx.remoteCommands } }
104817
+ contribute: (_slice, ctx) => ctx.remoteCommands === 0 ? {} : { remote: {
104818
+ commands: ctx.remoteCommands,
104819
+ open: action(REMOTE_OPEN_ACTION_ID, require_sleep.t("Remote", "Telecomando"), "gamepad-2", "remote", "open")
104820
+ } }
104221
104821
  };
104222
104822
  var ATTENTION_STATUSES = [
104223
104823
  "low",
@@ -135761,6 +136361,8 @@ exports.BaseDevice = BaseDevice;
135761
136361
  exports.BaseDeviceProvider = BaseDeviceProvider;
135762
136362
  exports.BatchTooLargeError = require_sleep.BatchTooLargeError;
135763
136363
  exports.BatteryStatusSchema = BatteryStatusSchema;
136364
+ exports.BecomesOperatorSchema = BecomesOperatorSchema;
136365
+ exports.BecomesWatch = BecomesWatch;
135764
136366
  exports.BinaryStatusSchema = BinaryStatusSchema;
135765
136367
  exports.BirthDecisionCropSourceSchema = BirthDecisionCropSourceSchema;
135766
136368
  exports.BirthDecisionQueryInputSchema = BirthDecisionQueryInputSchema;
@@ -136534,8 +137136,12 @@ exports.HeroRowModelSchema = HeroRowModelSchema;
136534
137136
  exports.HfModelResolutionSchema = HfModelResolutionSchema;
136535
137137
  exports.HistoryPointSchema = HistoryPointSchema;
136536
137138
  exports.HistoryResolutionEnum = HistoryResolutionEnum;
137139
+ exports.HoldCore = HoldCore;
136537
137140
  exports.HoldOverrideSchema = HoldOverrideSchema;
137141
+ exports.HoldSpecSchema = HoldSpecSchema;
136538
137142
  exports.HoldTargetStatusSchema = HoldTargetStatusSchema;
137143
+ exports.HoldTraceSchema = HoldTraceSchema;
137144
+ exports.HoldTracker = HoldTracker;
136539
137145
  exports.HttpsLeafInfoSchema = HttpsLeafInfoSchema;
136540
137146
  exports.HubAddressRoleSchema = HubAddressRoleSchema;
136541
137147
  exports.HumidifierStatusSchema = HumidifierStatusSchema;
@@ -137377,6 +137983,7 @@ exports.REMOTE_GROUP_FRAMES = REMOTE_GROUP_FRAMES;
137377
137983
  exports.REMOTE_KNOWN_ROLES = REMOTE_KNOWN_ROLES;
137378
137984
  exports.REMOTE_MAX_REPEAT = REMOTE_MAX_REPEAT;
137379
137985
  exports.REMOTE_MEDIA_COMMANDS = REMOTE_MEDIA_COMMANDS;
137986
+ exports.REMOTE_OPEN_ACTION_ID = REMOTE_OPEN_ACTION_ID;
137380
137987
  exports.REMOTE_REFUSAL_REASONS = REMOTE_REFUSAL_REASONS;
137381
137988
  exports.REMOTE_ROLE_VOCABULARY = REMOTE_ROLE_VOCABULARY;
137382
137989
  exports.REMOTE_SOURCE_KINDS = REMOTE_SOURCE_KINDS;
@@ -138397,6 +139004,8 @@ exports.deriveRootFaceRefineRect = deriveRootFaceRefineRect;
138397
139004
  exports.deriveRootSupplies = deriveRootSupplies;
138398
139005
  exports.describeComposableCaps = describeComposableCaps;
138399
139006
  exports.describeCustomActions = require_sleep.describeCustomActions;
139007
+ exports.describeHold = describeHold;
139008
+ exports.describeHoldMs = describeHoldMs;
138400
139009
  exports.describeModelVariant = describeModelVariant;
138401
139010
  exports.describeOnboardClamp = describeOnboardClamp;
138402
139011
  exports.describeOnboardRefusal = describeOnboardRefusal;
@@ -138585,6 +139194,7 @@ exports.groupStatusCapability = groupStatusCapability;
138585
139194
  exports.groupTemplate = groupTemplate;
138586
139195
  exports.guardInstanceDelete = guardInstanceDelete;
138587
139196
  exports.hasEventLeaves = hasEventLeaves;
139197
+ exports.hasHoldLeaves = hasHoldLeaves;
138588
139198
  exports.hasModelBoundOverrides = hasModelBoundOverrides;
138589
139199
  exports.hasMotionTrigger = hasMotionTrigger;
138590
139200
  exports.hasOwnRunningPowerDefaults = hasOwnRunningPowerDefaults;
@@ -138603,6 +139213,7 @@ exports.historyFieldsFor = historyFieldsFor;
138603
139213
  exports.historyItemFieldPath = require_sleep.historyItemFieldPath;
138604
139214
  exports.historyRetentionFromSettings = require_implemented_methods.historyRetentionFromSettings;
138605
139215
  exports.historyUnitFor = require_sleep.historyUnitFor;
139216
+ exports.holdOf = holdOf;
138606
139217
  exports.holdRefusalOf = holdRefusalOf;
138607
139218
  exports.holdVarSlots = holdVarSlots;
138608
139219
  exports.htmlToText = htmlToText;
@@ -138895,6 +139506,7 @@ exports.oauthIntegrationCapability = oauthIntegrationCapability;
138895
139506
  exports.oauthLandingUrl = oauthLandingUrl;
138896
139507
  exports.objectInputDeclaresAddonId = objectInputDeclaresAddonId;
138897
139508
  exports.objectInputDeclaresRequiredDeviceId = objectInputDeclaresRequiredDeviceId;
139509
+ exports.observeHoldLeaves = observeHoldLeaves;
138898
139510
  exports.occupancyScope = occupancyScope;
138899
139511
  exports.occurrenceOn = occurrenceOn;
138900
139512
  exports.omitTransientConfig = require_sleep.omitTransientConfig;