@camstack/types 1.2.423 → 1.2.425

package/dist/{composition-CPRAP41h.js → composition-CpAc0YfQ.js}

@@ -1138,7 +1138,7 @@ var ExpressionEvalError = class extends Error {
 //#endregion
 //#region src/expression/builtins.ts
 function isStatefulBuiltin(name) {
-	return name === "rose" || name === "count" || name === "dwell" || name === "latchedAt";
+	return name === "rose" || name === "count" || name === "dwell" || name === "latchedAt" || name === "schmitt";
 }
 function asFiniteNumber(value, name, index) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
@@ -1266,6 +1266,41 @@ function evaluateDwell(activeRaw, onForMsRaw, offForMsRaw, call, nowMs, hooks) {
 	hooks?.noteDeadline?.(call.pendingSince + delay);
 	return call.latched;
 }
+/**
+* `schmitt(x, high, low[, onForMs, offForMs])`: true once `x >= high`, false
+* once `x <= low`, and the last answer in between. A transition waits its delay
+* and is dropped if `x` returns to the held side first. The first answer needs
+* a crossing, or the restored output as `seed`: a reading inside the band with
+* nothing to hold is unknown, never off (D393). A null reading throws, so the
+* field is unavailable and the latch is kept.
+*/
+function evaluateSchmitt(args, call, nowMs, seed, hooks) {
+	const x = asFiniteNumber(args[0], "schmitt", 0);
+	const high = asFiniteNumber(args[1], "schmitt", 1);
+	const low = asFiniteNumber(args[2], "schmitt", 2);
+	const onForMs = args.length > 3 ? asNonNegativeMs(args[3], "schmitt", 3) : 0;
+	const offForMs = args.length > 4 ? asNonNegativeMs(args[4], "schmitt", 4) : 0;
+	if (low > high) throw new ExpressionEvalError("schmitt: the low edge is above the high edge");
+	if (call.latched === null && seed !== null) call.latched = seed;
+	const wants = x >= high ? true : x <= low ? false : call.latched;
+	if (call.latched === null) {
+		if (wants !== null) call.latched = wants;
+		return call.latched;
+	}
+	if (wants === null || wants === call.latched) {
+		call.pendingSince = null;
+		return call.latched;
+	}
+	if (call.pendingSince === null) call.pendingSince = nowMs;
+	const delay = wants ? onForMs : offForMs;
+	if (nowMs - call.pendingSince >= delay) {
+		call.latched = wants;
+		call.pendingSince = null;
+		return call.latched;
+	}
+	hooks?.noteDeadline?.(call.pendingSince + delay);
+	return call.latched;
+}
 /** `latchedAt(value)`: epoch ms when `value` last changed; null clears the stamp. */
 function evaluateLatchedAt(value, call, nowMs) {
 	if (value === null) {
@@ -1463,6 +1498,13 @@ var table = {
 		apply: () => {
 			throw new ExpressionEvalError("latchedAt: stateful evaluation context is required");
 		}
+	},
+	schmitt: {
+		minArgs: 3,
+		maxArgs: 5,
+		apply: () => {
+			throw new ExpressionEvalError("schmitt: stateful evaluation context is required");
+		}
 	}
 };
 /** Frozen, null-prototype builtin table. */
@@ -2072,6 +2114,16 @@ function evaluateStatefulExpressionCall(invocation, memory, env, hooks) {
 			memory.calls.set(invocation.path, call);
 			return evaluateDwell(invocation.args[0], invocation.args[1], invocation.args[2], call, env.nowMs, hooks);
 		}
+		case "schmitt": {
+			const call = existing?.kind === "schmitt" ? existing : {
+				kind: "schmitt",
+				latched: null,
+				pendingSince: null
+			};
+			memory.calls.set(invocation.path, call);
+			const seed = typeof env.currentOutput === "boolean" ? env.currentOutput : null;
+			return evaluateSchmitt(invocation.args, call, env.nowMs, seed, hooks);
+		}
 		case "latchedAt": {
 			const call = existing?.kind === "latchedAt" ? existing : {
 				kind: "latchedAt",
@@ -2442,6 +2494,58 @@ function integrateReading(read, scale) {
 	for (const segment of covered.segments) unitMs += segment.value * segment.ms;
 	return numberValue(scale === "energy-kwh" ? wattMillisecondsToKwh(unitMs) : unitMs / 1e3, covered.included, covered.gaps, GAP_REASON);
 }
+function samplesOf(read) {
+	const out = [];
+	if (read.before !== null && finite(read.before.value)) out.push({
+		at: read.from,
+		value: read.before.value
+	});
+	for (const point of read.points) {
+		if (point.t < read.from || point.t > read.to) continue;
+		const value = pointValue(point);
+		if (value === null) continue;
+		const at = read.tier === "raw" || !finite(point.twMs) ? point.t : point.t + point.twMs;
+		out.push({
+			at: Math.min(at, read.to),
+			value
+		});
+	}
+	return out.toSorted((a, b) => a.at - b.at);
+}
+/** A sample-less tail or head longer than this share of the window is counted as a gap. */
+var UNCOVERED_LIMIT = .1;
+var DERIVATIVE_GAP_REASON = "history stops short of the window — the rate is over the part that was measured";
+function derivativeValue(change, spanMs, perMs, included, windowMs) {
+	return numberValue(change / (spanMs / perMs), included, windowMs - spanMs > windowMs * UNCOVERED_LIMIT ? 1 : 0, DERIVATIVE_GAP_REASON);
+}
+/**
+* Rate of change over a window, per `perMs`. The slope is taken between the
+* first and the last measured sample, so a hole inside the window neither
+* counts as zero nor stretches the elapsed time. A gauge that reported
+* nothing after the value held at the start is flat (rate 0); fewer than two
+* samples and no held value is a known gap (D393).
+*/
+function evaluateDerivative(read, perMs) {
+	if (read.truncated) return hold("the history query was truncated — the last rate is kept");
+	if (read.to <= read.from) return gapValue("the range is empty", 0);
+	const windowMs = read.to - read.from;
+	const samples = samplesOf(read);
+	const first = samples[0];
+	const last = samples[samples.length - 1];
+	if (first === void 0 || last === void 0) return gapValue("history has no reading in this window", 0);
+	if (read.kind === "counter") {
+		const heldAtStart = read.before !== null && finite(read.before.value);
+		const startsAt = heldAtStart ? read.from : first.at;
+		const deltas = read.points.flatMap((point) => point.t >= read.from && point.t <= read.to && finite(point.delta) && (heldAtStart || point.t > first.at) ? [point.delta] : []);
+		const spanMs = last.at - startsAt;
+		if (deltas.length === 0 || spanMs <= 0) return gapValue("the counter has no growth in this window", samples.length);
+		return derivativeValue(deltas.reduce((sum, delta) => sum + delta, 0), spanMs, perMs, samples.length, windowMs);
+	}
+	if (samples.length === 1 && first.at === read.from && read.before !== null) return numberValue(0, 1, 0, null);
+	const spanMs = last.at - first.at;
+	if (samples.length < 2 || spanMs <= 0) return gapValue("the rate needs two readings in the window", samples.length);
+	return derivativeValue(last.value - first.value, spanMs, perMs, samples.length, windowMs);
+}
 //#endregion
 //#region src/composition/helpers/history-window.ts
 /**
@@ -2805,7 +2909,13 @@ var GROUP_TEMPLATE_IDS = [
 	"occupancy",
 	"binary",
 	"switch",
-	"light"
+	"light",
+	"fan",
+	"cover",
+	"valve",
+	"lock",
+	"media-player",
+	"climate"
 ];
 var NUMERIC_AGGREGATES = [
 	"mean",
@@ -2868,19 +2978,73 @@ var integralHelperObject = zod.z.object({
 	source: HelperMemberSchema
 });
 var IntegralHelperSpecSchema = integralHelperObject;
+var thresholdHelperObject = zod.z.object({
+	kind: zod.z.literal("threshold"),
+	source: HelperMemberSchema,
+	high: zod.z.number(),
+	low: zod.z.number(),
+	onForMs: zod.z.number().int().nonnegative(),
+	offForMs: zod.z.number().int().nonnegative()
+});
+var ThresholdHelperSpecSchema = thresholdHelperObject;
+var ARITHMETIC_OPS = [
+	"sum",
+	"difference",
+	"ratio"
+];
+var arithmeticHelperObject = zod.z.object({
+	kind: zod.z.literal("arithmetic"),
+	op: zod.z.enum(ARITHMETIC_OPS),
+	inputs: zod.z.array(HelperMemberSchema).min(2).max(64)
+});
+var ArithmeticHelperSpecSchema = arithmeticHelperObject;
+var EXPRESSION_OUTPUTS = ["number", "boolean"];
+var expressionHelperObject = zod.z.object({
+	kind: zod.z.literal("expression"),
+	expr: zod.z.string().min(1),
+	inputs: zod.z.array(zod.z.object({
+		name: zod.z.string().min(1),
+		member: HelperMemberSchema
+	})).min(1).max(64),
+	output: zod.z.enum(EXPRESSION_OUTPUTS)
+});
+var ExpressionHelperSpecSchema = expressionHelperObject;
+var DERIVATIVE_UNITS = [
+	"second",
+	"minute",
+	"hour"
+];
+var derivativeHelperObject = zod.z.object({
+	kind: zod.z.literal("derivative"),
+	window: RollingWindowSchema,
+	per: zod.z.enum(DERIVATIVE_UNITS),
+	source: HelperMemberSchema
+});
+var DerivativeHelperSpecSchema = derivativeHelperObject;
 var HelperSpecSchema = zod.z.discriminatedUnion("kind", [
 	GroupHelperSpecSchema,
 	ApplianceHelperSpecSchema,
 	statisticHelperObject,
-	integralHelperObject
+	integralHelperObject,
+	thresholdHelperObject,
+	arithmeticHelperObject,
+	expressionHelperObject,
+	derivativeHelperObject
 ]);
+function isHistoryHelper(spec) {
+	return spec.kind === "statistic" || spec.kind === "integral" || spec.kind === "derivative";
+}
 /** Every member a helper reads. A group has many; the others have one. */
 function helperMembers(spec) {
 	switch (spec.kind) {
 		case "group": return spec.members;
 		case "appliance": return [spec.member];
 		case "statistic":
-		case "integral": return [spec.source];
+		case "integral":
+		case "threshold":
+		case "derivative": return [spec.source];
+		case "arithmetic": return spec.inputs;
+		case "expression": return spec.inputs.map((input) => input.member);
 	}
 }
 //#endregion
@@ -2978,6 +3142,12 @@ var CompositionAggregateSourceSchema = zod.z.object({
 		"all"
 	]),
 	reads: zod.z.array(CompositionFieldReadSchema).min(1).max(64),
+	/**
+	* Set when the reads are an enum state, not a yes/no: the listed states
+	* count as active (a cover is `open`). A state outside the list is inactive;
+	* a read that is not a state at all is left out. Only `any` / `all` use it.
+	*/
+	activeWhen: zod.z.array(zod.z.string().min(1)).min(1).optional(),
 	/** `value` is the reading; the others are the member counts. */
 	publish: zod.z.enum([
 		"value",
@@ -3198,6 +3368,12 @@ Object.defineProperty(exports, "APPLIANCE_TEMPLATE_ID", {
 		return APPLIANCE_TEMPLATE_ID;
 	}
 });
+Object.defineProperty(exports, "ARITHMETIC_OPS", {
+	enumerable: true,
+	get: function() {
+		return ARITHMETIC_OPS;
+	}
+});
 Object.defineProperty(exports, "AUDIO_PRESETS", {
 	enumerable: true,
 	get: function() {
@@ -3222,6 +3398,12 @@ Object.defineProperty(exports, "ApplianceHelperSpecSchema", {
 		return ApplianceHelperSpecSchema;
 	}
 });
+Object.defineProperty(exports, "ArithmeticHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return ArithmeticHelperSpecSchema;
+	}
+});
 Object.defineProperty(exports, "BINARY_AGGREGATES", {
 	enumerable: true,
 	get: function() {
@@ -3408,6 +3590,18 @@ Object.defineProperty(exports, "DEFAULT_HISTORY_RETENTION", {
 		return DEFAULT_HISTORY_RETENTION;
 	}
 });
+Object.defineProperty(exports, "DERIVATIVE_UNITS", {
+	enumerable: true,
+	get: function() {
+		return DERIVATIVE_UNITS;
+	}
+});
+Object.defineProperty(exports, "DerivativeHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return DerivativeHelperSpecSchema;
+	}
+});
 Object.defineProperty(exports, "EXPRESSION_BUILTINS", {
 	enumerable: true,
 	get: function() {
@@ -3438,12 +3632,24 @@ Object.defineProperty(exports, "EXPRESSION_INJECTED_NOW", {
 		return EXPRESSION_INJECTED_NOW;
 	}
 });
+Object.defineProperty(exports, "EXPRESSION_OUTPUTS", {
+	enumerable: true,
+	get: function() {
+		return EXPRESSION_OUTPUTS;
+	}
+});
 Object.defineProperty(exports, "ExpressionEvalError", {
 	enumerable: true,
 	get: function() {
 		return ExpressionEvalError;
 	}
 });
+Object.defineProperty(exports, "ExpressionHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return ExpressionHelperSpecSchema;
+	}
+});
 Object.defineProperty(exports, "ExpressionParseError", {
 	enumerable: true,
 	get: function() {
@@ -3690,6 +3896,12 @@ Object.defineProperty(exports, "StatisticWindowSchema", {
 		return StatisticWindowSchema;
 	}
 });
+Object.defineProperty(exports, "ThresholdHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return ThresholdHelperSpecSchema;
+	}
+});
 Object.defineProperty(exports, "applianceDeviceType", {
 	enumerable: true,
 	get: function() {
@@ -3828,6 +4040,12 @@ Object.defineProperty(exports, "evaluateCount", {
 		return evaluateCount;
 	}
 });
+Object.defineProperty(exports, "evaluateDerivative", {
+	enumerable: true,
+	get: function() {
+		return evaluateDerivative;
+	}
+});
 Object.defineProperty(exports, "evaluateExpressionSource", {
 	enumerable: true,
 	get: function() {
@@ -3930,6 +4148,12 @@ Object.defineProperty(exports, "isApplianceKind", {
 		return isApplianceKind;
 	}
 });
+Object.defineProperty(exports, "isHistoryHelper", {
+	enumerable: true,
+	get: function() {
+		return isHistoryHelper;
+	}
+});
 Object.defineProperty(exports, "isSoftwareDecode", {
 	enumerable: true,
 	get: function() {

package/dist/device/cap-vocabulary/entries/sensors.d.ts

@@ -1,5 +1,5 @@
 import type { CapVocabularySlice } from '../types.js';
-type SensorCap = 'air-quality-sensor' | 'ambient-light-sensor' | 'binary' | 'carbon-monoxide' | 'connectivity' | 'contact' | 'enum-sensor' | 'flood' | 'gas' | 'group-commands' | 'group-status' | 'humidity-sensor' | 'meter' | 'motion' | 'numeric-sensor' | 'power-meter' | 'presence' | 'pressure-sensor' | 'smoke' | 'tamper' | 'temperature-sensor' | 'vibration' | 'weather' | 'battery' | 'network-link' | 'device-status' | 'doorbell' | 'event-emitter';
+type SensorCap = 'air-quality-sensor' | 'ambient-light-sensor' | 'binary' | 'carbon-monoxide' | 'connectivity' | 'contact' | 'enum-sensor' | 'flood' | 'gas' | 'group-active' | 'group-commands' | 'group-status' | 'humidity-sensor' | 'meter' | 'motion' | 'numeric-sensor' | 'power-meter' | 'presence' | 'pressure-sensor' | 'smoke' | 'tamper' | 'temperature-sensor' | 'vibration' | 'weather' | 'battery' | 'network-link' | 'device-status' | 'doorbell' | 'event-emitter';
 /** The sensor family of the vocabulary. */
 export declare const SENSOR_CAP_VOCABULARY: CapVocabularySlice<SensorCap>;
 export {};

package/dist/expression/builtins.d.ts

@@ -16,7 +16,7 @@
  * closed rather than emitting a garbage value.
  */
 import type { ExpressionValue } from './ast.js';
-import type { CountCallState, DwellCallState, LatchedAtCallState, RoseCallState, StatefulExpressionMemory } from './expression-source.js';
+import type { CountCallState, DwellCallState, LatchedAtCallState, RoseCallState, SchmittCallState, StatefulExpressionMemory } from './expression-source.js';
 /** Optional runtime hooks the evaluator threads through to builtins. */
 export interface ExpressionEvalHooks {
     /** Convert `value` from unit `from` to unit `to`; `null` when the pair is
@@ -41,7 +41,7 @@ export interface ExpressionBuiltin {
     readonly maxArgs: number;
     readonly apply: (args: readonly ExpressionValue[], hooks: ExpressionEvalHooks) => ExpressionValue;
 }
-export type StatefulExpressionBuiltin = 'rose' | 'count' | 'dwell' | 'latchedAt';
+export type StatefulExpressionBuiltin = 'rose' | 'count' | 'dwell' | 'latchedAt' | 'schmitt';
 export declare function isStatefulBuiltin(name: string): name is StatefulExpressionBuiltin;
 export declare function evaluateRose(level: unknown, changedAt: unknown, debounceMs: unknown, call: RoseCallState, field: StatefulExpressionMemory, env: {
     readonly currentOutput: number | null;
@@ -55,6 +55,15 @@ export declare function disarmRoseMemory(memory: StatefulExpressionMemory): void
  * the latched boolean through gaps shorter than the opposing delay (D933).
  */
 export declare function evaluateDwell(activeRaw: unknown, onForMsRaw: unknown, offForMsRaw: unknown, call: DwellCallState, nowMs: number, hooks?: ExpressionEvalHooks): boolean | null;
+/**
+ * `schmitt(x, high, low[, onForMs, offForMs])`: true once `x >= high`, false
+ * once `x <= low`, and the last answer in between. A transition waits its delay
+ * and is dropped if `x` returns to the held side first. The first answer needs
+ * a crossing, or the restored output as `seed`: a reading inside the band with
+ * nothing to hold is unknown, never off (D393). A null reading throws, so the
+ * field is unavailable and the latch is kept.
+ */
+export declare function evaluateSchmitt(args: readonly unknown[], call: SchmittCallState, nowMs: number, seed: boolean | null, hooks?: ExpressionEvalHooks): boolean | null;
 /** `latchedAt(value)`: epoch ms when `value` last changed; null clears the stamp. */
 export declare function evaluateLatchedAt(value: unknown, call: LatchedAtCallState, nowMs: number): number | null;
 export declare function evaluateCount(input: unknown, call: CountCallState, currentOutput: unknown): number;

package/dist/expression/expression-source.d.ts

@@ -39,7 +39,12 @@ export interface LatchedAtCallState {
     last: ExpressionValue | undefined;
     at: number | null;
 }
-export type StatefulCallState = RoseCallState | CountCallState | DwellCallState | LatchedAtCallState;
+export interface SchmittCallState {
+    readonly kind: 'schmitt';
+    latched: boolean | null;
+    pendingSince: number | null;
+}
+export type StatefulCallState = RoseCallState | CountCallState | DwellCallState | LatchedAtCallState | SchmittCallState;
 export interface StatefulExpressionMemory {
     readonly calls: Map<string, StatefulCallState>;
     acceptedEdgeAt: number | null;

package/dist/generated/addon-api.d.ts

@@ -3850,6 +3850,20 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
+    groupActive: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        getStatus: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof DEVICE_STATUS_METHOD.getStatus.input>;
+            output: z.infer<typeof DEVICE_STATUS_METHOD.getStatus.output>;
+            meta: object;
+        }>;
+    }>>;
     groupCommands: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;

package/dist/generated/addon-cap-facts.d.ts

@@ -5,7 +5,7 @@
  * `ALL_CAPABILITY_DEFINITIONS` (the whole Zod schema graph, ~+100 MB heap per
  * runner). See docs/decisions/adr-0028.md.
  *
- * Coverage: 1 advance-derived caps, 76 caps with 352 state leaves.
+ * Coverage: 1 advance-derived caps, 77 caps with 353 state leaves.
  */
 /** A bindable scalar in a capability's runtime state. */
 export interface CapStateLeaf {

package/dist/generated/cap-status-types.d.ts

@@ -30,6 +30,7 @@ import type { FanControlStatusSchema } from '../capabilities/fan-control.cap.js'
 import type { FeatureProbeStatusSchema } from '../capabilities/feature-probe.cap.js';
 import type { FloodStatusSchema } from '../capabilities/flood.cap.js';
 import type { GasStatusSchema } from '../capabilities/gas.cap.js';
+import type { groupActiveCapability } from '../capabilities/group-active.cap.js';
 import type { groupCommandsCapability } from '../capabilities/group-commands.cap.js';
 import type { groupStatusCapability } from '../capabilities/group-status.cap.js';
 import type { HeatingValveStatusSchema } from '../capabilities/heating-valve.cap.js';
@@ -114,6 +115,7 @@ export type CapStatusTypeMap = {
     readonly 'feature-probe': z.infer<typeof FeatureProbeStatusSchema>;
     readonly 'flood': z.infer<typeof FloodStatusSchema>;
     readonly 'gas': z.infer<typeof GasStatusSchema>;
+    readonly 'group-active': z.infer<(typeof groupActiveCapability)['status']['schema']>;
     readonly 'group-commands': z.infer<(typeof groupCommandsCapability)['status']['schema']>;
     readonly 'group-status': z.infer<(typeof groupStatusCapability)['status']['schema']>;
     readonly 'heating-valve': z.infer<typeof HeatingValveStatusSchema>;
@@ -169,4 +171,4 @@ export type CapNameWithStatus = keyof CapStatusTypeMap;
  * aggregator to enumerate caps whose `status` should be polled +
  * streamed via `subscribeDeviceStatusAggregate`.
  */
-export declare const CAP_NAMES_WITH_STATUS: readonly ["accessories", "air-quality-sensor", "alarm-panel", "ambient-light-sensor", "automation-control", "battery", "binary", "brightness", "broker", "camera-credentials", "carbon-monoxide", "climate-control", "color", "connectivity", "consumables", "contact", "control", "cover", "day-night", "device-adoption", "device-discovery", "device-export", "device-status", "dishwasher", "doorbell", "enum-sensor", "event-emitter", "fan-control", "feature-probe", "flood", "gas", "group-commands", "group-status", "heating-valve", "humidifier", "humidity-sensor", "image", "image-settings", "intercom", "lawn-mower-control", "lock-control", "media-player", "meter", "motion", "motion-trigger", "motion-zones", "mqtt-broker", "native-object-detection", "navigation", "network-link", "notifier", "numeric-sensor", "osd", "pet-feeder", "power-meter", "presence", "pressure-sensor", "privacy-mask", "ptz", "ptz-autotrack", "recording-archive", "recording-onboard", "recording-signal", "running-state", "scene-monitor", "script-runner", "smoke", "snapshot", "stream-params", "switch", "tamper", "temperature-sensor", "update", "vacuum-control", "valve", "vibration", "water-heater", "weather"];
+export declare const CAP_NAMES_WITH_STATUS: readonly ["accessories", "air-quality-sensor", "alarm-panel", "ambient-light-sensor", "automation-control", "battery", "binary", "brightness", "broker", "camera-credentials", "carbon-monoxide", "climate-control", "color", "connectivity", "consumables", "contact", "control", "cover", "day-night", "device-adoption", "device-discovery", "device-export", "device-status", "dishwasher", "doorbell", "enum-sensor", "event-emitter", "fan-control", "feature-probe", "flood", "gas", "group-active", "group-commands", "group-status", "heating-valve", "humidifier", "humidity-sensor", "image", "image-settings", "intercom", "lawn-mower-control", "lock-control", "media-player", "meter", "motion", "motion-trigger", "motion-zones", "mqtt-broker", "native-object-detection", "navigation", "network-link", "notifier", "numeric-sensor", "osd", "pet-feeder", "power-meter", "presence", "pressure-sensor", "privacy-mask", "ptz", "ptz-autotrack", "recording-archive", "recording-onboard", "recording-signal", "running-state", "scene-monitor", "script-runner", "smoke", "snapshot", "stream-params", "switch", "tamper", "temperature-sensor", "update", "vacuum-control", "valve", "vibration", "water-heater", "weather"];

package/dist/generated/capability-router-map.d.ts

@@ -72,6 +72,7 @@ export { featureProbeCapability } from '../capabilities/feature-probe.cap.js';
 export { filesystemBrowseCapability } from '../capabilities/filesystem-browse.cap.js';
 export { floodCapability } from '../capabilities/flood.cap.js';
 export { gasCapability } from '../capabilities/gas.cap.js';
+export { groupActiveCapability } from '../capabilities/group-active.cap.js';
 export { groupCommandsCapability } from '../capabilities/group-commands.cap.js';
 export { groupStatusCapability } from '../capabilities/group-status.cap.js';
 export { heatingValveCapability } from '../capabilities/heating-valve.cap.js';
@@ -257,6 +258,7 @@ export declare const CAPABILITY_NAMES: {
     readonly filesystemBrowse: 'filesystem-browse';
     readonly flood: 'flood';
     readonly gas: 'gas';
+    readonly groupActive: 'group-active';
     readonly groupCommands: 'group-commands';
     readonly groupStatus: 'group-status';
     readonly heatingValve: 'heating-valve';
@@ -455,6 +457,7 @@ export interface CapabilityRouterMap<TRouter = unknown> {
     readonly filesystemBrowse: TRouter;
     readonly flood: TRouter;
     readonly gas: TRouter;
+    readonly groupActive: TRouter;
     readonly groupCommands: TRouter;
     readonly groupStatus: TRouter;
     readonly heatingValve: TRouter;
@@ -566,8 +569,8 @@ export interface CapabilityRouterMap<TRouter = unknown> {
     readonly zoneRules: TRouter;
     readonly zones: TRouter;
 }
-/** Capability names whose mode is `singleton` (149 caps). */
-export declare const SINGLETON_CAPABILITY_NAMES: readonly ['accessories', 'addon-pages', 'addon-settings', 'addon-widgets', 'addons', 'admin-ui', 'air-quality-sensor', 'alarm-panel', 'alerts', 'ambient-light-sensor', 'audio-analysis', 'audio-analyzer', 'audio-codec', 'audio-metrics', 'automation-control', 'backup', 'battery', 'binary', 'brightness', 'button', 'calendars', 'camera-credentials', 'camera-grid-layout', 'camera-pipeline-config', 'camera-streams', 'carbon-monoxide', 'climate-control', 'color', 'composer', 'connectivity', 'consumables', 'contact', 'control', 'core-blocks', 'cover', 'database-snapshot', 'day-night', 'decoder', 'detection-pipeline', 'device-admin-link', 'device-credentials', 'device-discovery', 'device-history', 'device-manager', 'device-ops', 'device-state', 'device-status', 'dishwasher', 'display-palette', 'doorbell', 'enum-sensor', 'event-emitter', 'face-gallery', 'fan-control', 'feature-probe', 'filesystem-browse', 'flood', 'gas', 'group-commands', 'group-status', 'heating-valve', 'humidifier', 'humidity-sensor', 'image', 'image-settings', 'integrations', 'intercom', 'keychain', 'keychain-admin', 'lawn-mower-control', 'llm-runtime', 'local-network', 'lock-control', 'media-player', 'meter', 'metrics-provider', 'model-convert', 'model-distributor', 'motion', 'motion-detection', 'motion-trigger', 'motion-zones', 'native-object-detection', 'navigation', 'network-link', 'network-quality', 'node-certificates', 'nodes', 'notification-rules', 'notifier', 'numeric-sensor', 'oidc-connections', 'osd', 'osd-manager', 'pet-feeder', 'pipeline-analytics', 'pipeline-executor', 'pipeline-orchestrator', 'pipeline-runner', 'plate-gallery', 'platform-probe', 'power-meter', 'presence', 'pressure-sensor', 'privacy-mask', 'ptz', 'ptz-autotrack', 'reboot', 'record-entries', 'recording-archive', 'recording-export', 'recording-onboard', 'recording-signal', 'records', 'running-state', 'scene-monitor', 'script-runner', 'server-management', 'settings-store', 'smoke', 'snapshot', 'sso-bridge', 'storage', 'storage-admin', 'storage-migration', 'stream-broker', 'stream-catalog', 'stream-params', 'stream-signals', 'switch', 'system', 'tamper', 'temperature-sensor', 'terminal-session', 'toast', 'training', 'update', 'user-management', 'vacuum-control', 'valve', 'vector-store', 'vibration', 'viewer-ui', 'water-heater', 'weather', 'webrtc-session', 'zone-analytics', 'zone-rules', 'zones'];
+/** Capability names whose mode is `singleton` (150 caps). */
+export declare const SINGLETON_CAPABILITY_NAMES: readonly ['accessories', 'addon-pages', 'addon-settings', 'addon-widgets', 'addons', 'admin-ui', 'air-quality-sensor', 'alarm-panel', 'alerts', 'ambient-light-sensor', 'audio-analysis', 'audio-analyzer', 'audio-codec', 'audio-metrics', 'automation-control', 'backup', 'battery', 'binary', 'brightness', 'button', 'calendars', 'camera-credentials', 'camera-grid-layout', 'camera-pipeline-config', 'camera-streams', 'carbon-monoxide', 'climate-control', 'color', 'composer', 'connectivity', 'consumables', 'contact', 'control', 'core-blocks', 'cover', 'database-snapshot', 'day-night', 'decoder', 'detection-pipeline', 'device-admin-link', 'device-credentials', 'device-discovery', 'device-history', 'device-manager', 'device-ops', 'device-state', 'device-status', 'dishwasher', 'display-palette', 'doorbell', 'enum-sensor', 'event-emitter', 'face-gallery', 'fan-control', 'feature-probe', 'filesystem-browse', 'flood', 'gas', 'group-active', 'group-commands', 'group-status', 'heating-valve', 'humidifier', 'humidity-sensor', 'image', 'image-settings', 'integrations', 'intercom', 'keychain', 'keychain-admin', 'lawn-mower-control', 'llm-runtime', 'local-network', 'lock-control', 'media-player', 'meter', 'metrics-provider', 'model-convert', 'model-distributor', 'motion', 'motion-detection', 'motion-trigger', 'motion-zones', 'native-object-detection', 'navigation', 'network-link', 'network-quality', 'node-certificates', 'nodes', 'notification-rules', 'notifier', 'numeric-sensor', 'oidc-connections', 'osd', 'osd-manager', 'pet-feeder', 'pipeline-analytics', 'pipeline-executor', 'pipeline-orchestrator', 'pipeline-runner', 'plate-gallery', 'platform-probe', 'power-meter', 'presence', 'pressure-sensor', 'privacy-mask', 'ptz', 'ptz-autotrack', 'reboot', 'record-entries', 'recording-archive', 'recording-export', 'recording-onboard', 'recording-signal', 'records', 'running-state', 'scene-monitor', 'script-runner', 'server-management', 'settings-store', 'smoke', 'snapshot', 'sso-bridge', 'storage', 'storage-admin', 'storage-migration', 'stream-broker', 'stream-catalog', 'stream-params', 'stream-signals', 'switch', 'system', 'tamper', 'temperature-sensor', 'terminal-session', 'toast', 'training', 'update', 'user-management', 'vacuum-control', 'valve', 'vector-store', 'vibration', 'viewer-ui', 'water-heater', 'weather', 'webrtc-session', 'zone-analytics', 'zone-rules', 'zones'];
 /** Union of singleton capability names (literal string union). */
 export type SingletonCapabilityName = typeof SINGLETON_CAPABILITY_NAMES[number];
 /** Capability names whose mode is `collection` (35 caps). */

package/dist/generated/device-local-state.d.ts

@@ -27,6 +27,7 @@ import { fanControlCapability } from '../capabilities/fan-control.cap.js';
 import { featureProbeCapability } from '../capabilities/feature-probe.cap.js';
 import { floodCapability } from '../capabilities/flood.cap.js';
 import { gasCapability } from '../capabilities/gas.cap.js';
+import { groupActiveCapability } from '../capabilities/group-active.cap.js';
 import { groupCommandsCapability } from '../capabilities/group-commands.cap.js';
 import { groupStatusCapability } from '../capabilities/group-status.cap.js';
 import { heatingValveCapability } from '../capabilities/heating-valve.cap.js';
@@ -114,6 +115,7 @@ export interface DeviceLocalState {
     featureProbe: InferRuntimeState<typeof featureProbeCapability>;
     flood: InferRuntimeState<typeof floodCapability>;
     gas: InferRuntimeState<typeof gasCapability>;
+    groupActive: InferRuntimeState<typeof groupActiveCapability>;
     groupCommands: InferRuntimeState<typeof groupCommandsCapability>;
     groupStatus: InferRuntimeState<typeof groupStatusCapability>;
     heatingValve: InferRuntimeState<typeof heatingValveCapability>;
@@ -211,6 +213,7 @@ export interface CapNameToRuntimeStateMap {
     'feature-probe': InferRuntimeState<typeof featureProbeCapability>;
     'flood': InferRuntimeState<typeof floodCapability>;
     'gas': InferRuntimeState<typeof gasCapability>;
+    'group-active': InferRuntimeState<typeof groupActiveCapability>;
     'group-commands': InferRuntimeState<typeof groupCommandsCapability>;
     'group-status': InferRuntimeState<typeof groupStatusCapability>;
     'heating-valve': InferRuntimeState<typeof heatingValveCapability>;

package/dist/generated/device-proxy.d.ts

@@ -40,6 +40,7 @@ import type { fanControlCapability } from '../capabilities/fan-control.cap.js';
 import type { featureProbeCapability } from '../capabilities/feature-probe.cap.js';
 import type { floodCapability } from '../capabilities/flood.cap.js';
 import type { gasCapability } from '../capabilities/gas.cap.js';
+import type { groupActiveCapability } from '../capabilities/group-active.cap.js';
 import type { groupCommandsCapability } from '../capabilities/group-commands.cap.js';
 import type { groupStatusCapability } from '../capabilities/group-status.cap.js';
 import type { heatingValveCapability } from '../capabilities/heating-valve.cap.js';
@@ -148,6 +149,7 @@ export interface DeviceProxyState {
     readonly featureProbe: SliceHandle<InferRuntimeState<typeof featureProbeCapability>>;
     readonly flood: SliceHandle<InferRuntimeState<typeof floodCapability>>;
     readonly gas: SliceHandle<InferRuntimeState<typeof gasCapability>>;
+    readonly groupActive: SliceHandle<InferRuntimeState<typeof groupActiveCapability>>;
     readonly groupCommands: SliceHandle<InferRuntimeState<typeof groupCommandsCapability>>;
     readonly groupStatus: SliceHandle<InferRuntimeState<typeof groupStatusCapability>>;
     readonly heatingValve: SliceHandle<InferRuntimeState<typeof heatingValveCapability>>;
@@ -252,6 +254,7 @@ export interface DeviceProxy {
     readonly featureProbe?: InferDeviceProxyCap<typeof featureProbeCapability>;
     readonly flood?: InferDeviceProxyCap<typeof floodCapability>;
     readonly gas?: InferDeviceProxyCap<typeof gasCapability>;
+    readonly groupActive?: InferDeviceProxyCap<typeof groupActiveCapability>;
     readonly groupCommands?: InferDeviceProxyCap<typeof groupCommandsCapability>;
     readonly groupStatus?: InferDeviceProxyCap<typeof groupStatusCapability>;
     readonly heatingValve?: InferDeviceProxyCap<typeof heatingValveCapability>;

package/dist/generated/device-scoped-caps.d.ts

@@ -5,7 +5,7 @@
  * can answer "may a rule actuate this?" without importing the schema barrel
  * (~144MB RSS per runner, D28).
  *
- * Coverage: 94 device-scoped capabilities.
+ * Coverage: 95 device-scoped capabilities.
  */
 export declare const DEVICE_SCOPED_CAPS: ReadonlySet<string>;
 /**

package/dist/generated/history-catalog.d.ts

@@ -1,7 +1,7 @@
 import type { CapabilityHistoryField, CapabilityHistoryItems } from '../capabilities/capability-definition.js';
 /**
  * Cap history catalog, projected from every `*.cap.ts` `history` block.
- * 42 caps with series (76 series), 32 caps answered `'none'`.
+ * 42 caps with series (76 series), 33 caps answered `'none'`.
  * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
  */
 export declare const HISTORY_CATALOG: Readonly<Record<string, Readonly<Record<string, CapabilityHistoryField>>>>;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1386 method paths across 184 capabilities.
+ * Coverage: 1387 method paths across 185 capabilities.
  */
 import type { MethodRole } from '../auth/viewer-access.js';
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';

package/dist/generated/method-device-selectors.d.ts

@@ -6,7 +6,7 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 549 methods carry a device reference, of which
+ * Coverage: 550 methods carry a device reference, of which
  * 174 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying

package/dist/generated/runtime-state-durability.d.ts

@@ -11,7 +11,7 @@ export interface RuntimeStatePolicy {
 }
 /**
  * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
- * `runtimeState`. 75 caps: 39 `restored`, 36 `session`.
+ * `runtimeState`. 76 caps: 39 `restored`, 37 `session`.
  *
  * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
  * with `durability: 'session'` has one and has decided not to keep it.