@camstack/system 1.2.485 → 1.2.487

package/dist/{dist-xCNJAQMh.js → dist-CrsVjBbk.js}

@@ -1,6 +1,6 @@
 let zod = require("zod");
 require("node:crypto");
-//#region ../types/dist/event-category-DHXxB8t9.mjs
+//#region ../types/dist/event-category-CT-hz5Rb.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -326,6 +326,14 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	/** The recovery edge of {@link PipelineMotionNoisy}: the motion fell back, or a detection arrived. */
 	EventCategory["PipelineMotionCalm"] = "pipeline.motion-calm";
 	/**
+	* A camera's package LLM confirm has failed closed three times in a row
+	* (D931, 2026-10-26). One edge per camera until
+	* {@link PipelinePackageLlmAnswered}.
+	*/
+	EventCategory["PipelinePackageLlmSilent"] = "pipeline.package-llm-silent";
+	/** The recovery edge of {@link PipelinePackageLlmSilent}: a confirm returned yes or no. */
+	EventCategory["PipelinePackageLlmAnswered"] = "pipeline.package-llm-answered";
+	/**
 	* Per-camera pipeline config was mutated by the orchestrator
 	* (a settings change via `setAgentInferenceDevices` /
 	* `setCameraStepToggle` / `setCameraStepSettings`). Orchestrator
@@ -765,7 +773,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-CARd6wZF.mjs
+//#region ../types/dist/sleep-bykKrTgu.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -5183,6 +5191,8 @@ var CAP_NAMES = Object.freeze([
 	"filesystem-browse",
 	"flood",
 	"gas",
+	"group-commands",
+	"group-status",
 	"heating-valve",
 	"humidifier",
 	"humidity-sensor",
@@ -6001,6 +6011,20 @@ Object.freeze({
 		"path": "detected",
 		"valueType": "boolean"
 	}],
+	"group-status": [
+		{
+			"path": "included",
+			"valueType": "number"
+		},
+		{
+			"path": "excluded",
+			"valueType": "number"
+		},
+		{
+			"path": "total",
+			"valueType": "number"
+		}
+	],
 	"heating-valve": [{
 		"path": "position",
 		"valueType": "number"
@@ -7468,7 +7492,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-kEl9mevu.mjs
+//#region ../types/dist/composition-OhpuespA.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -8986,6 +9010,75 @@ function evaluateExpressionSource(expr, bindingValues, now, opts) {
 	}
 }
 /**
+* A composition source identity: `(addonId, stableId)`, never a numeric device
+* id. Split out so helper schemas can name it without a cycle through
+* `composition.ts` (D659).
+*/
+var CompositionSourceRefSchema = zod.z.object({
+	/** The owning addon; `stableId` is unique only within it. */
+	addonId: zod.z.string().min(1),
+	stableId: zod.z.string().min(1)
+});
+var GROUP_TEMPLATE_IDS = [
+	"temperature",
+	"humidity",
+	"pressure",
+	"illuminance",
+	"power",
+	"energy",
+	"battery",
+	"numeric",
+	"motion",
+	"contact",
+	"leak",
+	"smoke",
+	"occupancy",
+	"binary",
+	"switch",
+	"light"
+];
+var NUMERIC_AGGREGATES = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum"
+];
+var BINARY_AGGREGATES = ["any", "all"];
+/** How an actuator group decides it is on. Unknown members never count as off. */
+var ACTIVE_CRITERIA = ["at-least-one", "all"];
+var AGGREGATE_REDUCERS = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum",
+	"any",
+	"all"
+];
+var GroupTemplateIdSchema = zod.z.enum(GROUP_TEMPLATE_IDS);
+var AggregateReducerSchema = zod.z.enum(AGGREGATE_REDUCERS);
+var ActiveCriterionSchema = zod.z.enum(ACTIVE_CRITERIA);
+/** One member. The field is stored so occupancy can name motion or binary. */
+var HelperMemberSchema = zod.z.object({
+	source: CompositionSourceRefSchema,
+	cap: zod.z.string().min(1),
+	fieldPath: zod.z.string().min(1)
+});
+/**
+* Phase 1a is groups only. Math, integral and statistics stay off this union
+* until the composer can run them — a control must not save a spec it cannot.
+*/
+var GroupHelperSpecSchema = zod.z.object({
+	kind: zod.z.literal("group"),
+	templateId: GroupTemplateIdSchema,
+	aggregate: AggregateReducerSchema,
+	members: zod.z.array(HelperMemberSchema).min(1).max(64),
+	/** Actuator groups only. Readings leave this unset. */
+	active: ActiveCriterionSchema.optional()
+});
+var HelperSpecSchema = zod.z.discriminatedUnion("kind", [GroupHelperSpecSchema]);
+/**
 * A COMPOSITION: a device assembled from other devices' state (D659).
 *
 * The data half of the composed-devices spec §1. A composition is stored inside
@@ -9010,11 +9103,6 @@ var COMPOSER_ADDON_ID = "composer";
 var COMPOSED_DEVICE_STABLE_ID_PREFIX = "composed-";
 /** Longest snippet a `code` source may carry (slice 4). */
 var MAX_COMPOSITION_CODE_LENGTH = 2e4;
-var CompositionSourceRefSchema = zod.z.object({
-	/** The owning addon; `stableId` is unique only within it. */
-	addonId: zod.z.string().min(1),
-	stableId: zod.z.string().min(1)
-});
 /** One field of one capability of one source device. */
 var CompositionFieldReadSchema = zod.z.object({
 	source: CompositionSourceRefSchema,
@@ -9057,10 +9145,42 @@ var CompositionCodeSourceSchema = zod.z.object({
 	kind: zod.z.literal("code"),
 	code: zod.z.string().min(1).max(MAX_COMPOSITION_CODE_LENGTH)
 });
+/**
+* `aggregate`: a group reducer. Offline and unknown reads are excluded, not
+* folded in as 0 or false (D944). Free expressions stay `expression` so a
+* stale member is still included there.
+*/
+var CompositionAggregateSourceSchema = zod.z.object({
+	kind: zod.z.literal("aggregate"),
+	reducer: zod.z.enum([
+		"mean",
+		"median",
+		"min",
+		"max",
+		"sum",
+		"any",
+		"all"
+	]),
+	reads: zod.z.array(CompositionFieldReadSchema).min(1).max(64),
+	/** `value` is the reading; the others are the member counts. */
+	publish: zod.z.enum([
+		"value",
+		"included",
+		"excluded",
+		"total"
+	]),
+	/** What a `value` publish does when nobody is included. Counts ignore this. */
+	empty: zod.z.enum([
+		"null",
+		"omit",
+		"offline"
+	])
+});
 var CompositionFieldSourceSchema = zod.z.discriminatedUnion("kind", [
 	CompositionFromSourceSchema,
 	CompositionExpressionSourceSchema,
-	CompositionCodeSourceSchema
+	CompositionCodeSourceSchema,
+	CompositionAggregateSourceSchema
 ]);
 /** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
 var CompositionForwardCommandSchema = zod.z.object({
@@ -9125,7 +9245,13 @@ var CompositionExistingTargetSchema = zod.z.object({
 var CompositionTargetSchema = zod.z.discriminatedUnion("kind", [CompositionNewTargetSchema, CompositionExistingTargetSchema]);
 var CompositionSchema = zod.z.object({
 	target: CompositionTargetSchema,
-	features: zod.z.array(CompositionFeatureSchema).min(1).max(16)
+	features: zod.z.array(CompositionFeatureSchema).min(1).max(16),
+	/**
+	* Present when the block is a helper template. Absent on a free
+	* composition (the room example, device 4603). The editor reads this,
+	* never the compiled features.
+	*/
+	helper: HelperSpecSchema.optional()
 }).superRefine((composition, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	composition.features.forEach((feature, index) => {
@@ -9172,6 +9298,7 @@ function fieldReads(source) {
 			cap: binding.cap,
 			fieldPath: binding.fieldPath
 		}] : []);
+		case "aggregate": return source.reads;
 		case "code": return [];
 	}
 }
@@ -17363,7 +17490,10 @@ var CompositionProblemCodeSchema = zod.z.enum([
 	"target-missing",
 	"target-unreadable",
 	"not-replaceable",
-	"native-capability-replace"
+	"native-capability-replace",
+	"mixed-quantity",
+	"helper-mismatch",
+	"member-constraint"
 ]);
 /** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.celsius`. */
 var CompositionProblemSchema = zod.z.object({
@@ -17387,7 +17517,8 @@ var CompositionUnavailableModeSchema = zod.z.enum([
 	"null",
 	"offline",
 	"unknown",
-	"release"
+	"release",
+	"omit"
 ]);
 /**
 * `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
@@ -17749,6 +17880,24 @@ function inferExpressionKinds(input) {
 * planner (`composition-items.ts`). Internal to the composition module — NOT
 * in the barrel: these are planner internals, not a published contract.
 */
+function aggregateKinds(source) {
+	if (source.publish !== "value") return {
+		ok: true,
+		kinds: new Set(["number"])
+	};
+	if (source.reducer === "any" || source.reducer === "all") return {
+		ok: true,
+		kinds: new Set(["boolean"])
+	};
+	if (source.empty === "null") return {
+		ok: true,
+		kinds: new Set(["number", "null"])
+	};
+	return {
+		ok: true,
+		kinds: new Set(["number"])
+	};
+}
 function readKinds(read, lookupCap) {
 	const def = lookupCap(read.cap);
 	const schema = def?.runtimeState ?? def?.status?.schema;
@@ -17776,6 +17925,7 @@ function sourceKinds(source, lookupCap) {
 		code: "reserved-variant",
 		message: "code fields arrive in slice 4"
 	};
+	if (source.kind === "aggregate") return aggregateKinds(source);
 	const bindingKinds = /* @__PURE__ */ new Map();
 	for (const [name, binding] of Object.entries(source.bindings)) {
 		if (binding.kind === "literal") {
@@ -17970,6 +18120,515 @@ function planItems(def, feature, featureIndex, lookupCap, mode = "new") {
 	};
 }
 /**
+* One catalog row per base reading a group helper can build (D944 §3).
+* Data, not a form default written into the block.
+*/
+var NOW = {
+	fieldPath: "lastFetchedAt",
+	expr: "now"
+};
+var CHANGED = {
+	fieldPath: "lastChangedAt",
+	expr: "now"
+};
+function numeric(input) {
+	return {
+		...input,
+		family: "numeric",
+		deviceType: DeviceType.Sensor,
+		memberDeviceType: DeviceType.Sensor,
+		commandCaps: [],
+		baseUnit: baseUnitOf(input.quantity),
+		aggregates: NUMERIC_AGGREGATES,
+		accept: [{
+			cap: input.outputCap,
+			fieldPath: input.outputField
+		}]
+	};
+}
+function binary(input) {
+	return {
+		...input,
+		family: "binary",
+		deviceType: DeviceType.Sensor,
+		memberDeviceType: DeviceType.Sensor,
+		commandCaps: [],
+		quantity: "none",
+		baseUnit: void 0,
+		aggregates: BINARY_AGGREGATES,
+		empty: "offline"
+	};
+}
+var GROUP_TEMPLATES = [
+	numeric({
+		id: "temperature",
+		summary: "Mean, median, min, max or sum of temperatures. Offline and unknown members are left out, never read as 0 °C.",
+		role: DeviceRole.TemperatureSensor,
+		outputCap: "temperature-sensor",
+		outputField: "celsius",
+		quantity: "temperature",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "humidity",
+		summary: "Humidity in percent. Offline and unknown members are left out, never read as 0 %.",
+		role: DeviceRole.HumiditySensor,
+		outputCap: "humidity-sensor",
+		outputField: "percent",
+		quantity: "humidity",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "pressure",
+		summary: "Pressure in hectopascals. Offline and unknown members are left out, never read as 0 hPa.",
+		role: DeviceRole.PressureSensor,
+		outputCap: "pressure-sensor",
+		outputField: "hpa",
+		quantity: "pressure",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "illuminance",
+		summary: "Illuminance in lux. Offline and unknown members are left out, never read as 0 lx.",
+		role: DeviceRole.AmbientLightSensor,
+		outputCap: "ambient-light-sensor",
+		outputField: "lux",
+		quantity: "illuminance",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "power",
+		summary: "Power in watts, summed by default. Nobody reporting omits the key rather than writing 0 W.",
+		role: DeviceRole.PowerSensor,
+		outputCap: "power-meter",
+		outputField: "watts",
+		quantity: "power",
+		defaultAggregate: "sum",
+		empty: "omit",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "energy",
+		summary: "Energy in kilowatt-hours, summed by default. Nobody reporting omits the key rather than writing 0 kWh.",
+		role: DeviceRole.EnergySensor,
+		outputCap: "power-meter",
+		outputField: "kwhTotal",
+		quantity: "energy",
+		defaultAggregate: "sum",
+		empty: "omit",
+		companions: [NOW]
+	}),
+	numeric({
+		id: "battery",
+		summary: "Battery charge in percent. Offline and unknown members are left out, never read as 0 %.",
+		role: DeviceRole.BatterySensor,
+		outputCap: "battery",
+		outputField: "percentage",
+		quantity: "percentage",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [
+			{
+				fieldPath: "charging",
+				expr: "\"unknown\""
+			},
+			{
+				fieldPath: "sleeping",
+				expr: "false"
+			},
+			{
+				fieldPath: "lastUpdated",
+				expr: "now"
+			}
+		]
+	}),
+	numeric({
+		id: "numeric",
+		summary: "A numeric reading in the members’ shared quantity. Mixed quantities are refused. Nobody reporting publishes null, not 0.",
+		role: DeviceRole.NumericSensor,
+		outputCap: "numeric-sensor",
+		outputField: "value",
+		quantity: "device",
+		defaultAggregate: "mean",
+		empty: "null",
+		companions: [NOW]
+	}),
+	binary({
+		id: "motion",
+		summary: "Any or all motion. Offline and unknown members are left out, never read as off. Nobody reporting takes the device offline.",
+		role: DeviceRole.MotionSensor,
+		outputCap: "motion",
+		outputField: "detected",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "motion",
+			fieldPath: "detected"
+		}],
+		companions: [{
+			fieldPath: "lastDetectedAt",
+			expr: "null"
+		}, {
+			fieldPath: "autoClearAfterMs",
+			expr: "null"
+		}]
+	}),
+	binary({
+		id: "contact",
+		summary: "Any or all open contacts. Offline and unknown members are left out, never read as closed.",
+		role: DeviceRole.ContactSensor,
+		outputCap: "contact",
+		outputField: "entryOpen",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "contact",
+			fieldPath: "entryOpen"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "leak",
+		summary: "Any or all leak detections. Offline and unknown members are left out, never read as dry.",
+		role: DeviceRole.LeakSensor,
+		outputCap: "flood",
+		outputField: "flooded",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "flood",
+			fieldPath: "flooded"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "smoke",
+		summary: "Any or all smoke detections. Offline and unknown members are left out, never read as clear.",
+		role: DeviceRole.SmokeSensor,
+		outputCap: "smoke",
+		outputField: "detected",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "smoke",
+			fieldPath: "detected"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "occupancy",
+		summary: "Any or all of motion or binary sensors, published as a binary. Presence zones are not aggregated. Nobody reporting is offline, not off.",
+		role: DeviceRole.BinarySensor,
+		outputCap: "binary",
+		outputField: "on",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "motion",
+			fieldPath: "detected"
+		}, {
+			cap: "binary",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	}),
+	binary({
+		id: "binary",
+		summary: "Any or all generic binary sensors. Offline and unknown members are left out, never read as off.",
+		role: DeviceRole.BinarySensor,
+		outputCap: "binary",
+		outputField: "on",
+		defaultAggregate: "any",
+		accept: [{
+			cap: "binary",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	}),
+	actuator({
+		id: "switch",
+		summary: "On when at least one switch is on, or when all of them are. Offline and unknown members are left out of that decision, never read as off, and still receive the command.",
+		deviceType: DeviceType.Switch,
+		outputCap: "switch",
+		commandCaps: ["switch"]
+	}),
+	actuator({
+		id: "light",
+		summary: "On when at least one light is on, or when all of them are. Brightness and colour are offered only when every member has them. A command is not sent to a member that lacks it.",
+		deviceType: DeviceType.Light,
+		outputCap: "switch",
+		commandCaps: [
+			"switch",
+			"brightness",
+			"color"
+		]
+	})
+];
+function actuator(input) {
+	return {
+		...input,
+		family: "actuator",
+		role: void 0,
+		memberDeviceType: input.deviceType,
+		outputField: "on",
+		quantity: "none",
+		baseUnit: void 0,
+		aggregates: BINARY_AGGREGATES,
+		defaultAggregate: "any",
+		empty: "offline",
+		accept: [{
+			cap: "switch",
+			fieldPath: "on"
+		}],
+		companions: [CHANGED]
+	};
+}
+var BY_ID = new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
+function groupTemplate(id) {
+	return BY_ID.get(id) ?? null;
+}
+/**
+* Actuator groups (D944 phase 1b). The active boolean is the binary reducer
+* with unknown members left out. A command is one call per member that binds
+* the cap, including members that are offline. One failure does not cancel
+* the others.
+*/
+/** Caps a light group may expose, in display order. Switch is the active state. */
+var LIGHT_SHARED_CAPS = [
+	"switch",
+	"brightness",
+	"color"
+];
+var COLOR_MODE_FEATURES = [
+	DeviceFeature.LightColorRgb,
+	DeviceFeature.LightColorHsv,
+	DeviceFeature.LightColorMired
+];
+/** `at-least-one` is any included member on; `all` is every included member on. */
+function reducerForActive(active) {
+	return active === "all" ? "all" : "any";
+}
+/**
+* Caps every member binds, from {@link LIGHT_SHARED_CAPS}. An empty member
+* list shares nothing. A member that lacks colour drops colour from the group.
+*/
+function sharedLightCaps(memberCaps) {
+	if (memberCaps.length === 0) return [];
+	return LIGHT_SHARED_CAPS.filter((cap) => memberCaps.every((bound) => bound.includes(cap)));
+}
+/**
+* Colour modes every member advertises. Offline does not remove a mode:
+* the caller passes device features, not liveness. No members → no mode.
+*/
+function sharedColorModes(memberFeatures) {
+	if (memberFeatures.length === 0) return [];
+	return COLOR_MODE_FEATURES.filter((mode) => memberFeatures.every((features) => features.includes(mode)));
+}
+/**
+* One call per member that binds `cap`. Offline members stay in the list.
+* A member without the cap is not called — the command cannot reach it.
+*/
+function fanOutTargets(members, cap, method, args) {
+	return members.flatMap((member) => member.caps.includes(cap) ? [{
+		deviceId: member.deviceId,
+		cap,
+		method,
+		args: { ...args }
+	}] : []);
+}
+/**
+* Run every call. A throw is that member's result; the other calls still run.
+* At most {@link FAN_OUT_CONCURRENCY} are in flight.
+*/
+async function runFanOut(calls, invoke) {
+	const results = [];
+	let next = 0;
+	const worker = async () => {
+		for (;;) {
+			const index = next;
+			next += 1;
+			const call = calls[index];
+			if (call === void 0) return;
+			try {
+				await invoke(call);
+				results[index] = {
+					deviceId: call.deviceId,
+					ok: true
+				};
+			} catch (err) {
+				const error = err instanceof Error ? err.message : String(err);
+				results[index] = {
+					deviceId: call.deviceId,
+					ok: false,
+					error
+				};
+			}
+		}
+	};
+	const width = Math.min(4, calls.length);
+	await Promise.all(Array.from({ length: width }, () => worker()));
+	return results;
+}
+function sameSource(a, b) {
+	return a.addonId === b.addonId && a.stableId === b.stableId;
+}
+function sameMember(a, b) {
+	return sameSource(a.source, b.source) && a.cap === b.cap && a.fieldPath === b.fieldPath;
+}
+function accepted(template, member) {
+	return template.accept.some((field) => field.cap === member.cap && field.fieldPath === member.fieldPath);
+}
+function memberProblems(template, spec) {
+	return spec.members.flatMap((member, index) => {
+		const at = `helper.members[${index}]`;
+		const problems = [];
+		if (!accepted(template, member)) {
+			const allowed = template.accept.map((field) => `${field.cap}.${field.fieldPath}`).join(" or ");
+			problems.push(problem("member-constraint", at, `a ${template.id} group reads ${allowed}; this member is ${member.cap}.${member.fieldPath}`));
+		}
+		if (spec.members.slice(0, index).some((other) => sameMember(other, member))) problems.push(problem("member-constraint", at, "this member is already in the group"));
+		return problems;
+	});
+}
+function aggregateSource(template, spec, reads, publish) {
+	return {
+		kind: "aggregate",
+		reducer: spec.aggregate,
+		reads: [...reads],
+		publish,
+		empty: template.empty
+	};
+}
+function expressionSource(expr) {
+	return {
+		kind: "expression",
+		expr,
+		bindings: {}
+	};
+}
+function draftOf$1(template, spec) {
+	const reads = spec.members.map((member) => ({
+		source: member.source,
+		cap: member.cap,
+		fieldPath: member.fieldPath
+	}));
+	const companions = Object.fromEntries(template.companions.map((companion) => [companion.fieldPath, expressionSource(companion.expr)]));
+	return {
+		target: {
+			kind: "new",
+			type: template.deviceType,
+			...template.role === void 0 ? {} : { role: template.role }
+		},
+		helper: spec,
+		features: [{
+			kind: "fields",
+			cap: template.outputCap,
+			fields: {
+				[template.outputField]: aggregateSource(template, spec, reads, "value"),
+				...companions
+			}
+		}, {
+			kind: "fields",
+			cap: "group-status",
+			fields: {
+				included: aggregateSource(template, spec, reads, "included"),
+				excluded: aggregateSource(template, spec, reads, "excluded"),
+				total: aggregateSource(template, spec, reads, "total")
+			}
+		}]
+	};
+}
+function criterionProblems(template, spec) {
+	if (template.family === "actuator") {
+		if (spec.active === void 0) return [problem("kind-mismatch", "helper.active", `a ${template.id} group needs an active criterion (at-least-one or all)`)];
+		const reducer = reducerForActive(spec.active);
+		if (spec.aggregate !== reducer) return [problem("kind-mismatch", "helper.aggregate", `active \`${spec.active}\` aggregates by \`${reducer}\`, not \`${spec.aggregate}\``)];
+		return [];
+	}
+	if (spec.active !== void 0) return [problem("kind-mismatch", "helper.active", `a ${template.id} group has no active criterion — that belongs to an actuator group`)];
+	return [];
+}
+function parseDraft(draft) {
+	const parsed = CompositionSchema.safeParse(draft);
+	if (parsed.success) return {
+		ok: true,
+		composition: parsed.data
+	};
+	return {
+		ok: false,
+		problems: [problem("helper-mismatch", "helper", `the template did not compile: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`)]
+	};
+}
+/** Compile a group template to a new-device composition. Refusals are named. */
+function compileHelper(spec) {
+	const template = groupTemplate(spec.templateId);
+	if (template === null) return {
+		ok: false,
+		problems: [problem("member-constraint", "helper.templateId", `unknown template \`${spec.templateId}\``)]
+	};
+	const criterion = criterionProblems(template, spec);
+	if (criterion.length > 0) return {
+		ok: false,
+		problems: criterion
+	};
+	if (!template.aggregates.includes(spec.aggregate)) {
+		const allowed = template.aggregates.join(", ");
+		return {
+			ok: false,
+			problems: [problem("kind-mismatch", "helper.aggregate", `a ${template.id} group aggregates by ${allowed}, not \`${spec.aggregate}\``)]
+		};
+	}
+	const members = memberProblems(template, spec);
+	if (members.length > 0) return {
+		ok: false,
+		problems: members
+	};
+	return parseDraft(draftOf$1(template, spec));
+}
+/** The built body, ignoring `helper`, so a save can demand one writer. */
+function sameHelperBody(stored, compiled) {
+	return JSON.stringify(stored.target) === JSON.stringify(compiled.target) && JSON.stringify(stored.features) === JSON.stringify(compiled.features);
+}
+function quantityProblems(spec, facts) {
+	const template = groupTemplate(spec.templateId);
+	if (template === null || template.family !== "numeric") return [];
+	const known = spec.members.flatMap((member, index) => {
+		const quantity = facts.get(compositionSourceKey(member.source))?.quantity;
+		return quantity === void 0 ? [] : [{
+			index,
+			quantity
+		}];
+	});
+	if (template.quantity !== "device") return known.flatMap((member) => member.quantity === template.quantity ? [] : [problem("mixed-quantity", `helper.members[${member.index}]`, `a ${template.id} group is ${template.quantity}${template.baseUnit === void 0 ? "" : ` (${template.baseUnit})`}; this member is ${member.quantity}`)]);
+	const distinct = [...new Set(known.map((member) => member.quantity))];
+	if (distinct.length <= 1) return [];
+	return [problem("mixed-quantity", "helper.members", `a numeric group requires one quantity; members report ${distinct.join(" and ")}`)];
+}
+function deviceTypeProblems(spec, facts) {
+	const template = groupTemplate(spec.templateId);
+	if (template === null) return [];
+	return spec.members.flatMap((member, index) => {
+		const deviceType = facts.get(compositionSourceKey(member.source))?.deviceType;
+		if (deviceType === void 0 || deviceType === template.memberDeviceType) return [];
+		return [problem("member-constraint", `helper.members[${index}]`, `a ${template.id} group takes ${template.memberDeviceType} devices; this member is a ${deviceType}`)];
+	});
+}
+/**
+* Problems that refuse a save. No `helper` key means a free composition: this
+* returns nothing, and expression semantics stay as they are.
+*/
+function helperSaveProblems(composition, facts) {
+	const spec = composition.helper;
+	if (spec === void 0) return [];
+	const compiled = compileHelper(spec);
+	if (!compiled.ok) return compiled.problems;
+	if (!sameHelperBody(composition, compiled.composition)) return [problem("helper-mismatch", "helper", "the stored features are not this template — the helper spec is the only writer")];
+	return [...quantityProblems(spec, facts), ...deviceTypeProblems(spec, facts)];
+}
+/**
 * The field graph across every composition, and the cycles in it (D659).
 *
 * A node is ONE field of ONE device (`<addon>/<stableId>#<cap>.<field>`); an
@@ -18150,11 +18809,22 @@ function composableCap(feature, at, lookupCap) {
 * required field. A REPLACE needs none of it: the cap is bound (a fact), the
 * native keeps serving its methods, and only the named fields are owned (D663).
 */
-function builtCapProblems({ def, state, fields: targetFields }, feature, at, deviceType) {
+/**
+* Caps an actuator helper is allowed to serve. A free composition, and a
+* reading group, get an empty set — `has-commands` stays for them.
+*/
+function actuatorCommandCaps(composition) {
+	const spec = composition.helper;
+	if (spec === void 0) return /* @__PURE__ */ new Set();
+	const template = groupTemplate(spec.templateId);
+	if (template === null || template.family !== "actuator") return /* @__PURE__ */ new Set();
+	return new Set(template.commandCaps);
+}
+function builtCapProblems({ def, state, fields: targetFields }, feature, at, deviceType, servedCommands) {
 	const problems = [];
 	if (def.deviceTypes !== void 0 && !def.deviceTypes.includes(deviceType)) problems.push(problem("wrong-device-type", `${at}.cap`, `\`${def.name}\` is not offered on a \`${deviceType}\` device (it allows ${def.deviceTypes.join(", ")})`));
 	const served = Object.entries(def.methods).filter(([name, m]) => m.systemOnly !== true && def.composedMethods?.[name] === void 0).map(([name]) => `\`${name}\``);
-	if (served.length > 0) problems.push(problem("has-commands", `${at}.cap`, `\`${def.name}\` has ${served.join(", ")}, which a composed device cannot serve until commands arrive (slice 3)`));
+	if (served.length > 0 && !servedCommands.has(def.name)) problems.push(problem("has-commands", `${at}.cap`, `\`${def.name}\` has ${served.join(", ")}, which a composed device cannot serve until commands arrive (slice 3)`));
 	const itemArrayPath = feature.items === void 0 ? null : def.status?.itemArray?.path ?? null;
 	for (const key of requiredTopLevelKeys(state)) {
 		if (key === itemArrayPath) continue;
@@ -18174,6 +18844,7 @@ function planTopLevelField({ def, fields }, field, mode, lookupCap) {
 	const role = roleOf(source);
 	const unavailable = unavailableFor(tf, role, mode, def.name, fieldAt);
 	if (!unavailable.ok) return refused(unavailable.problem);
+	const omitEmpty = source.kind === "aggregate" && source.publish === "value" && source.empty === "omit";
 	const plan = {
 		cap: def.name,
 		path,
@@ -18181,7 +18852,7 @@ function planTopLevelField({ def, fields }, field, mode, lookupCap) {
 		kind: tf.kind,
 		nullable: tf.nullable,
 		required: tf.required,
-		unavailable: unavailable.unavailable,
+		unavailable: omitEmpty ? "omit" : unavailable.unavailable,
 		role,
 		source,
 		reads: [...fieldReads(source)]
@@ -18194,11 +18865,11 @@ function planTopLevelField({ def, fields }, field, mode, lookupCap) {
 		events: []
 	};
 }
-function planFeature(feature, featureIndex, target, lookupCap) {
+function planFeature(feature, featureIndex, target, lookupCap, servedCommands) {
 	const at = `features[${featureIndex}]`;
 	const cap = composableCap(feature, at, lookupCap);
 	if ("code" in cap) return refused(cap);
-	const capProblems = target.mode === "replace" ? [] : [...builtCapProblems(cap, feature, at, target.deviceType)];
+	const capProblems = target.mode === "replace" ? [] : [...builtCapProblems(cap, feature, at, target.deviceType, servedCommands)];
 	if (feature.commands !== void 0 && Object.keys(feature.commands).length > 0) capProblems.push(problem("reserved-variant", `${at}.commands`, "commands (`forward`) arrive in slice 3"));
 	const perField = Object.entries(feature.fields).map(([path, source]) => planTopLevelField(cap, {
 		featureIndex,
@@ -18284,6 +18955,7 @@ function featureTargetOf(target, cap, at) {
 function planComposition(composition, lookupCap, target) {
 	const planTarget = planTargetOf(composition, target);
 	if ("code" in planTarget) return refused(planTarget);
+	const servedCommands = actuatorCommandCaps(composition);
 	const results = composition.features.map((feature, index) => {
 		const at = `features[${index}]`;
 		if (feature.kind === "passthrough") return refused(problem("reserved-variant", at, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`));
@@ -18298,9 +18970,9 @@ function planComposition(composition, lookupCap, target) {
 			return nativeReplaceOrBlock(featureTarget, planFeature(feature, index, {
 				mode: "add",
 				deviceType: planTarget.found.type
-			}, lookupCap));
+			}, lookupCap, servedCommands));
 		}
-		const result = planFeature(feature, index, featureTarget, lookupCap);
+		const result = planFeature(feature, index, featureTarget, lookupCap, servedCommands);
 		return compositionFeatureEnabled(feature) ? result : {
 			problems: result.problems,
 			fields: [],
@@ -18446,10 +19118,15 @@ function validateComposition(composition, ctx) {
 		if (refusedFeatures.some((at) => item.path === at || item.path.startsWith(`${at}.`))) return false;
 		return refusedFeatures.length === 0 || item.path !== "features";
 	});
+	const facts = new Map([...ctx.sources].flatMap(([key, source]) => source.kind === "found" ? [[key, {
+		deviceType: source.deviceType,
+		quantity: source.quantity
+	}]] : []));
 	const problems = [
 		...plan.problems,
 		...sourceProblems(plan.fields, ctx, self),
-		...cycles
+		...cycles,
+		...helperSaveProblems(composition, facts)
 	];
 	return {
 		ok: problems.length === 0,
@@ -47747,6 +48424,8 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"detection-blind",
 	"motion-noisy",
 	"motion-calm",
+	"package-llm-silent",
+	"package-llm-answered",
 	"recording-stalled",
 	"recording-healthy",
 	"recording-degraded",
@@ -61712,6 +62391,28 @@ var PackageVersionInfoSchema = zod.z.object({
 	deprecated: zod.z.string().optional(),
 	distTags: zod.z.array(zod.z.string()).readonly()
 });
+/**
+* One published document. `ok` is markdown from the registry. `missing` means
+* the registry answered and the file was not there. `error` is a registry or
+* tarball failure — never an empty string standing in for either.
+*/
+var PackageDocBodySchema = zod.z.discriminatedUnion("status", [
+	zod.z.object({
+		status: zod.z.literal("ok"),
+		markdown: zod.z.string()
+	}),
+	zod.z.object({ status: zod.z.literal("missing") }),
+	zod.z.object({
+		status: zod.z.literal("error"),
+		message: zod.z.string()
+	})
+]);
+var PackageDocsSchema = zod.z.object({
+	name: zod.z.string(),
+	version: zod.z.string(),
+	readme: PackageDocBodySchema,
+	changelog: PackageDocBodySchema
+});
 var SearchResultSchema = zod.z.object({
 	name: zod.z.string(),
 	version: zod.z.string(),
@@ -62078,6 +62779,15 @@ var addonsCapability = {
 			auth: "admin"
 		}),
 		getVersions: method(zod.z.object({ name: zod.z.string() }), zod.z.array(PackageVersionInfoSchema).readonly()),
+		/**
+		* README and CHANGELOG for one registry package, read on the hub and
+		* cached. `version` omitted resolves the `latest` dist-tag. The browser
+		* never talks to the registry.
+		*/
+		getPackageDocs: method(zod.z.object({
+			name: zod.z.string().min(1),
+			version: zod.z.string().min(1).optional()
+		}), PackageDocsSchema, { auth: "admin" }),
 		restartAddon: method(zod.z.object({ addonId: zod.z.string() }), RestartAddonResultSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -63575,6 +64285,10 @@ var ColorStatusSchema = zod.z.object({
 	/** Ms epoch of the last operator-driven change. */
 	lastChangedAt: zod.z.number()
 });
+function parseColorInput(value) {
+	const parsed = ColorInputSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
 var colorCapability = {
 	name: "color",
 	scope: "device",
@@ -65651,6 +66365,95 @@ var gasCapability = {
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
 };
+/**
+* The last command a helper actuator group sent to each member (D944).
+* The composer writes this slice; the aggregate pass does not, so a later
+* reading does not wipe it. History is none — the outcome is the latest
+* attempt, not a series.
+*/
+var GroupCommandResultSchema = zod.z.object({
+	deviceId: zod.z.number().int().nonnegative(),
+	cap: zod.z.string().min(1),
+	method: zod.z.string().min(1),
+	ok: zod.z.boolean(),
+	error: zod.z.string().optional(),
+	/** Ms epoch of the attempt. */
+	at: zod.z.number()
+});
+var GroupCommandsSchema = zod.z.object({ 
+/** One row per member that has been commanded. A later command replaces that member's row. */
+results: zod.z.array(GroupCommandResultSchema) });
+var groupCommandsCapability = {
+	name: "group-commands",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.Switch, DeviceType.Light],
+	methods: {},
+	status: {
+		schema: GroupCommandsSchema,
+		kind: "push"
+	},
+	runtimeState: GroupCommandsSchema,
+	/**
+	* Runtime-state durability: **session** — the last attempt. A restored
+	* failure would outlive the command that caused it.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
+/**
+* How many members of a helper group answered (D944). Counts are integers,
+* not measurements: zero included is a real count, never a stand-in reading.
+* The reading itself stays on the output capability. History is none — the
+* series that later statistics read is the output cap's own history block.
+*/
+var GroupStatusSchema = zod.z.object({
+	/** Members whose current value entered the aggregate. */
+	included: zod.z.number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Reporting"
+	})),
+	/** Members left out: offline, unknown, or not a finite reading (D393). */
+	excluded: zod.z.number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Excluded"
+	})),
+	/** `included` + `excluded`. */
+	total: zod.z.number().int().nonnegative().meta(readingMeta("count", {
+		precision: 0,
+		label: "Members"
+	}))
+});
+var groupStatusCapability = {
+	name: "group-status",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		DeviceType.Sensor,
+		DeviceType.Switch,
+		DeviceType.Light
+	],
+	methods: {},
+	status: {
+		schema: GroupStatusSchema,
+		kind: "push"
+	},
+	runtimeState: GroupStatusSchema,
+	/**
+	* Runtime-state durability: **session** — recomputed from members on the
+	* next source event; a restored count would outlive the readings it named.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session",
+	history: "none"
+};
 var HeatingValveStatusSchema = zod.z.object({
 	/** Radiator valve opening 0 (closed) .. 100 (open). Null = not yet known. */
 	position: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
@@ -67715,12 +68518,18 @@ var motionCapability = {
 	methods: { 
 	/**
 	* Pull the current motion state synchronously. Convenience shortcut
-	* for consumers that don't need the full status object; equivalent
-	* to `getStatus()?.detected ?? false`. Will likely be folded into
-	* `getStatus` once the auto-injected status surface lands in every
-	* consumer.
+	* for consumers that don't need the full status object. A composed
+	* group answers from its slice (D944): unknown throws, it is not off.
 	*/
 isDetected: method(zod.z.object({ deviceId: zod.z.number() }), zod.z.boolean()) },
+	/**
+	* A composed motion group serves `isDetected` from `detected` (D944).
+	* Without this the cap stays uncomposable (`has-commands`).
+	*/
+	composedMethods: { isDetected: {
+		kind: "slice",
+		field: "detected"
+	} },
 	events: { 
 	/**
 	* Fires every time the runner transitions a camera between
@@ -76628,6 +77437,103 @@ function createDeviceExtensionProvider(options) {
 		}
 	};
 }
+function isBinaryReducer(reducer) {
+	return reducer === "any" || reducer === "all";
+}
+function includedValue(reducer, member) {
+	if (member.state !== "fresh") return null;
+	if (isBinaryReducer(reducer)) return typeof member.value === "boolean" ? member.value : null;
+	return typeof member.value === "number" && Number.isFinite(member.value) ? member.value : null;
+}
+function median$1(values) {
+	const sorted = [...values].toSorted((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	const right = sorted[mid];
+	const left = sorted[mid - 1];
+	if (right === void 0) throw new Error("median requires at least one finite number");
+	if (sorted.length % 2 === 1) return right;
+	if (left === void 0) throw new Error("median requires at least one finite number");
+	return (left + right) / 2;
+}
+function reduceNumbers(reducer, values) {
+	if (reducer === "min") return Math.min(...values);
+	if (reducer === "max") return Math.max(...values);
+	if (reducer === "sum") return values.reduce((sum, value) => sum + value, 0);
+	if (reducer === "median") return median$1(values);
+	return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function reduceBooleans(reducer, values) {
+	return reducer === "all" ? values.every((value) => value) : values.some((value) => value);
+}
+function countsOf(included, total) {
+	return {
+		included,
+		excluded: total - included,
+		total
+	};
+}
+function fatalReason(members) {
+	const reasons = members.flatMap((member) => member.state === "unavailable" && member.fatal === true ? [member.reason ?? "source gone"] : []);
+	return reasons.length === 0 ? null : reasons.join("; ");
+}
+function emptyOutcome(empty, counts) {
+	if (empty === "null") return {
+		kind: "value",
+		value: null,
+		counts
+	};
+	return {
+		kind: "unavailable",
+		fatal: false,
+		reason: "no member included — unknown is not 0 or off",
+		counts
+	};
+}
+/** Pure. `members` is not mutated. An empty included set is null or unavailable, never 0 or false. */
+function evaluateAggregate(input) {
+	const included = input.members.flatMap((member) => {
+		const value = includedValue(input.reducer, member);
+		return value === null ? [] : [value];
+	});
+	const counts = countsOf(included.length, input.members.length);
+	const gone = fatalReason(input.members);
+	if (gone !== null) return {
+		kind: "unavailable",
+		fatal: true,
+		reason: gone,
+		counts
+	};
+	if (input.publish === "included") return {
+		kind: "value",
+		value: counts.included,
+		counts
+	};
+	if (input.publish === "excluded") return {
+		kind: "value",
+		value: counts.excluded,
+		counts
+	};
+	if (input.publish === "total") return {
+		kind: "value",
+		value: counts.total,
+		counts
+	};
+	if (included.length === 0) return emptyOutcome(input.empty, counts);
+	if (isBinaryReducer(input.reducer)) {
+		const flags = included.filter((value) => typeof value === "boolean");
+		return {
+			kind: "value",
+			value: reduceBooleans(input.reducer, flags),
+			counts
+		};
+	}
+	const numbers = included.filter((value) => typeof value === "number");
+	return {
+		kind: "value",
+		value: reduceNumbers(input.reducer, numbers),
+		counts
+	};
+}
 /**
 * Frozen unit → spec table. `•` in the doc marks each dimension's canonical
 * unit (`factor: 1, offset: 0`). °F derives from `°C = (°F − 32) × 5/9` ⇒
@@ -77133,11 +78039,45 @@ function expressionOutcome(source, read, now, stateful) {
 		deadline: deadlines.length > 0 ? Math.min(...deadlines) : null
 	};
 }
+function aggregateRead(reading) {
+	if (reading.state === "unavailable") return {
+		state: "unavailable",
+		fatal: reading.fatal,
+		reason: reading.reason
+	};
+	return {
+		state: reading.state,
+		value: reading.value,
+		...reading.state === "stale" ? { reason: reading.reason } : {}
+	};
+}
+function aggregateField(source, read) {
+	const outcome = evaluateAggregate({
+		reducer: source.reducer,
+		members: source.reads.map((item) => aggregateRead(read(item))),
+		publish: source.publish,
+		empty: source.empty
+	});
+	if (outcome.kind === "value") return {
+		state: "fresh",
+		value: outcome.value,
+		reason: null,
+		deadline: null
+	};
+	return {
+		state: "unavailable",
+		value: null,
+		reason: outcome.reason,
+		fatal: outcome.fatal,
+		confirmed: true
+	};
+}
 function evaluateCompositionField(input) {
 	const { source } = input;
 	switch (source.kind) {
 		case "from": return fromReading(input.read(source), source);
 		case "expression": return expressionOutcome(source, input.read, input.now, input.stateful);
+		case "aggregate": return aggregateField(source, input.read);
 		case "code": return {
 			state: "unavailable",
 			value: null,
@@ -77484,6 +78424,8 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	featureProbe: featureProbeCapability,
 	flood: floodCapability,
 	gas: gasCapability,
+	groupCommands: groupCommandsCapability,
+	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
 	humidifier: humidifierCapability,
 	humiditySensor: humiditySensorCapability,
@@ -78638,6 +79580,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"addons.getPackageDocs": {
+		capName: "addons",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
 	"addons.getVersions": {
 		capName: "addons",
 		capScope: "system",
@@ -81746,6 +82695,20 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"groupCommands.getStatus": {
+		capName: "group-commands",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
+	"groupStatus.getStatus": {
+		capName: "group-status",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"heatingValve.getStatus": {
 		capName: "heating-valve",
 		capScope: "device",
@@ -91568,6 +92531,37 @@ var SENSOR_CAP_VOCABULARY = {
 			icon: "flame"
 		}]
 	},
+	"group-commands": {
+		scope: "device",
+		noun: t("Group command", "Comando di gruppo")
+	},
+	"group-status": {
+		scope: "device",
+		noun: t("Group", "Gruppo"),
+		state: [
+			{
+				kind: "numeric",
+				field: "included",
+				quantity: t("the members reporting", "i membri che rispondono"),
+				label: t("Reporting", "Rispondono"),
+				icon: "users"
+			},
+			{
+				kind: "numeric",
+				field: "excluded",
+				quantity: t("the members left out", "i membri esclusi"),
+				label: t("Excluded", "Esclusi"),
+				icon: "users"
+			},
+			{
+				kind: "numeric",
+				field: "total",
+				quantity: t("the member count", "il numero di membri"),
+				label: t("Members", "Membri"),
+				icon: "sigma"
+			}
+		]
+	},
 	"humidity-sensor": {
 		scope: "device",
 		noun: t("Humidity", "Umidità"),
@@ -92104,6 +93098,8 @@ var CAP_NAMES_WITH_STATUS = [
 	"feature-probe",
 	"flood",
 	"gas",
+	"group-commands",
+	"group-status",
 	"heating-valve",
 	"humidifier",
 	"humidity-sensor",
@@ -92233,6 +93229,8 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	filesystemBrowseCapability,
 	floodCapability,
 	gasCapability,
+	groupCommandsCapability,
+	groupStatusCapability,
 	heatingValveCapability,
 	humidifierCapability,
 	humiditySensorCapability,
@@ -93307,6 +94305,16 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"groupCommands.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"groupStatus.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"heatingValve.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -95116,7 +96124,7 @@ Object.freeze({
 });
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 72 caps: 38 `restored`, 34 `session`.
+* `runtimeState`. 74 caps: 38 `restored`, 36 `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.
@@ -95234,6 +96242,14 @@ var RUNTIME_STATE_POLICY = {
 		durability: "restored",
 		volatileFields: ["lastChangedAt"]
 	},
+	"group-commands": {
+		durability: "session",
+		volatileFields: []
+	},
+	"group-status": {
+		durability: "session",
+		volatileFields: []
+	},
 	"heating-valve": {
 		durability: "session",
 		volatileFields: ["lastFetchedAt"]
@@ -95428,7 +96444,7 @@ var SESSION_ONLY_POLICY = {
 };
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 41 caps with series (75 series), 30 caps answered `'none'`.
+* 41 caps with series (75 series), 32 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -96000,6 +97016,8 @@ new Map(Object.entries({
 	"detection-blind": "device-events",
 	"motion-noisy": "device-events",
 	"motion-calm": "device-events",
+	"package-llm-silent": "device-events",
+	"package-llm-answered": "device-events",
 	"recording-stalled": "device-events",
 	"recording-healthy": "device-events",
 	"recording-degraded": "device-events",
@@ -96083,6 +97101,12 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Motion without a subject",
 		kinds: ["motion-noisy", "motion-calm"]
 	},
+	{
+		id: "package-llm",
+		family: "device-events",
+		label: "Package confirm",
+		kinds: ["package-llm-silent", "package-llm-answered"]
+	},
 	{
 		id: "recording",
 		family: "device-events",
@@ -96306,6 +97330,8 @@ var DEVICE_EVENTS = [
 	"detection-blind",
 	"motion-noisy",
 	"motion-calm",
+	"package-llm-silent",
+	"package-llm-answered",
 	"recording-stalled",
 	"recording-healthy",
 	"recording-degraded",
@@ -96574,6 +97600,15 @@ new Map([
 		snapshotLabel: "Cameras with constant motion now",
 		snapshotSection: null
 	},
+	{
+		id: "package-llm-confirm",
+		family: "device-events",
+		label: "Package confirm (not answering / answering again)",
+		bad: ["package-llm-silent"],
+		recovery: ["package-llm-answered"],
+		snapshotLabel: "Cameras whose package confirm is not answering",
+		snapshotSection: null
+	},
 	{
 		id: "recording-health",
 		family: "device-events",
@@ -97859,6 +98894,12 @@ Object.defineProperty(exports, "ForeignSecretMarkerError", {
 		return ForeignSecretMarkerError;
 	}
 });
+Object.defineProperty(exports, "GroupCommandResultSchema", {
+	enumerable: true,
+	get: function() {
+		return GroupCommandResultSchema;
+	}
+});
 Object.defineProperty(exports, "HISTORY_CATALOG", {
 	enumerable: true,
 	get: function() {
@@ -98291,6 +99332,12 @@ Object.defineProperty(exports, "batteryCapability", {
 		return batteryCapability;
 	}
 });
+Object.defineProperty(exports, "brightnessCapability", {
+	enumerable: true,
+	get: function() {
+		return brightnessCapability;
+	}
+});
 Object.defineProperty(exports, "buildCapabilityLookup", {
 	enumerable: true,
 	get: function() {
@@ -98381,6 +99428,12 @@ Object.defineProperty(exports, "collectZodSecretPaths", {
 		return collectZodSecretPaths;
 	}
 });
+Object.defineProperty(exports, "colorCapability", {
+	enumerable: true,
+	get: function() {
+		return colorCapability;
+	}
+});
 Object.defineProperty(exports, "composedDeviceRef", {
 	enumerable: true,
 	get: function() {
@@ -98663,6 +99716,12 @@ Object.defineProperty(exports, "extractNestedAddonId", {
 		return extractNestedAddonId;
 	}
 });
+Object.defineProperty(exports, "fanOutTargets", {
+	enumerable: true,
+	get: function() {
+		return fanOutTargets;
+	}
+});
 Object.defineProperty(exports, "filesystemBrowseCapability", {
 	enumerable: true,
 	get: function() {
@@ -98699,6 +99758,18 @@ Object.defineProperty(exports, "gbToBytes", {
 		return gbToBytes;
 	}
 });
+Object.defineProperty(exports, "groupCommandsCapability", {
+	enumerable: true,
+	get: function() {
+		return groupCommandsCapability;
+	}
+});
+Object.defineProperty(exports, "groupTemplate", {
+	enumerable: true,
+	get: function() {
+		return groupTemplate;
+	}
+});
 Object.defineProperty(exports, "historyItemFieldPath", {
 	enumerable: true,
 	get: function() {
@@ -98993,6 +100064,12 @@ Object.defineProperty(exports, "parseAcceleratorFactsJson", {
 		return parseAcceleratorFactsJson;
 	}
 });
+Object.defineProperty(exports, "parseColorInput", {
+	enumerable: true,
+	get: function() {
+		return parseColorInput;
+	}
+});
 Object.defineProperty(exports, "parseJsonObject", {
 	enumerable: true,
 	get: function() {
@@ -99149,6 +100226,12 @@ Object.defineProperty(exports, "resolveSecretMarkers", {
 		return resolveSecretMarkers;
 	}
 });
+Object.defineProperty(exports, "runFanOut", {
+	enumerable: true,
+	get: function() {
+		return runFanOut;
+	}
+});
 Object.defineProperty(exports, "runtimeStatePolicyFor", {
 	enumerable: true,
 	get: function() {
@@ -99197,6 +100280,18 @@ Object.defineProperty(exports, "settingsStoreCapability", {
 		return settingsStoreCapability;
 	}
 });
+Object.defineProperty(exports, "sharedColorModes", {
+	enumerable: true,
+	get: function() {
+		return sharedColorModes;
+	}
+});
+Object.defineProperty(exports, "sharedLightCaps", {
+	enumerable: true,
+	get: function() {
+		return sharedLightCaps;
+	}
+});
 Object.defineProperty(exports, "shortHostname", {
 	enumerable: true,
 	get: function() {
@@ -99275,6 +100370,12 @@ Object.defineProperty(exports, "supportedRuntimes", {
 		return supportedRuntimes;
 	}
 });
+Object.defineProperty(exports, "switchCapability", {
+	enumerable: true,
+	get: function() {
+		return switchCapability;
+	}
+});
 Object.defineProperty(exports, "toExpressionValue", {
 	enumerable: true,
 	get: function() {