@camstack/system 1.2.484 → 1.2.486

package/dist/{dist-k--OhKkO.js → dist-D-d_UWL4.js}

@@ -765,7 +765,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-BErAxhul.mjs
+//#region ../types/dist/sleep-B81gwQuR.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -3801,6 +3801,112 @@ function assertTransactScope(members) {
 	if (missing.length > 0) throw new TransactRefusedError(`no-family: ${missing.map((m) => m.kind).join(", ")} declare no transactFamily; kinds that must agree through transact share one`);
 	if (new Set(kinds.map((m) => m.declaration.transactFamily)).size > 1) throw new TransactRefusedError(`cross-family: the ops span more than one transactFamily (${kinds.map((m) => `${m.kind}=${String(m.declaration.transactFamily)}`).join(", ")})`);
 }
+var READING_QUANTITIES = [
+	"temperature",
+	"pressure",
+	"speed",
+	"precipitation",
+	"precipitation-rate",
+	"length",
+	"area",
+	"illuminance",
+	"irradiance",
+	"power",
+	"energy",
+	"voltage",
+	"current",
+	"apparent-power",
+	"humidity",
+	"percentage",
+	"concentration-volume",
+	"concentration-mass",
+	"concentration-ppb",
+	"volume",
+	"duration",
+	"duration-ms",
+	"information",
+	"sound-level",
+	"signal-level",
+	"colour-temperature",
+	"angle",
+	"bitrate",
+	"rate",
+	"mass",
+	"index",
+	"ratio",
+	"count",
+	"none",
+	"device"
+];
+var ReadingQuantitySchema = zod.z.enum(READING_QUANTITIES);
+var QUANTITY_SET = new Set(READING_QUANTITIES);
+function isReadingQuantity(value) {
+	return typeof value === "string" && QUANTITY_SET.has(value);
+}
+/**
+* Stored unit symbol for a quantity. `none` means the number is dimensionless
+* (or an index / ratio / count). `device` means the cap has no single unit.
+*/
+var QUANTITY_BASE = {
+	temperature: "°C",
+	pressure: "hPa",
+	speed: "m/s",
+	precipitation: "mm",
+	"precipitation-rate": "mm/h",
+	length: "m",
+	area: "m²",
+	illuminance: "lx",
+	irradiance: "W/m²",
+	power: "W",
+	energy: "kWh",
+	voltage: "V",
+	current: "A",
+	"apparent-power": "VA",
+	humidity: "%",
+	percentage: "%",
+	"concentration-volume": "ppm",
+	"concentration-mass": "µg/m³",
+	"concentration-ppb": "ppb",
+	volume: "L",
+	duration: "s",
+	"duration-ms": "ms",
+	information: "B",
+	"sound-level": "dBFS",
+	"signal-level": "dBm",
+	"colour-temperature": "mired",
+	angle: "°",
+	bitrate: "kbps",
+	rate: "fps",
+	mass: "kg",
+	index: "none",
+	ratio: "none",
+	count: "none",
+	none: "none",
+	device: "device"
+};
+/** The stored unit, or `undefined` when the quantity has no unit symbol. */
+function baseUnitOf(quantity) {
+	const symbol = QUANTITY_BASE[quantity];
+	if (symbol === "none" || symbol === "device") return void 0;
+	return symbol;
+}
+/**
+* History catalog label for a quantity. Index and ratio keep the labels the
+* series already used (`count`, `ratio`). A polymorphic reading has no
+* single label.
+*/
+function historyUnitFor(quantity) {
+	if (quantity === "index" || quantity === "count") return "count";
+	if (quantity === "ratio") return "ratio";
+	return baseUnitOf(quantity);
+}
+function readingMeta(quantity, extras) {
+	return {
+		quantity,
+		...extras?.precision !== void 0 ? { precision: extras.precision } : {},
+		...extras?.label !== void 0 ? { label: extras.label } : {}
+	};
+}
 /** Shared Zod schemas used across streaming capabilities. */
 var CamProfileSchema = zod.z.enum([
 	"high",
@@ -3828,8 +3934,8 @@ var CamStreamKindSchema = zod.z.enum([
 	"derived"
 ]);
 var CamStreamResolutionSchema = zod.z.object({
-	width: zod.z.number().int().positive(),
-	height: zod.z.number().int().positive()
+	width: zod.z.number().int().positive().meta(readingMeta("none")),
+	height: zod.z.number().int().positive().meta(readingMeta("none"))
 });
 var CameraStreamSchema = zod.z.object({
 	/** Stable, provider-assigned id unique within the (deviceId) scope. */
@@ -5077,6 +5183,7 @@ var CAP_NAMES = Object.freeze([
 	"filesystem-browse",
 	"flood",
 	"gas",
+	"group-status",
 	"heating-valve",
 	"humidifier",
 	"humidity-sensor",
@@ -5206,14 +5313,6 @@ Object.freeze({
 		{
 			"path": "aqi",
 			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
 		}
 	],
 	"alarm-panel": [
@@ -5249,20 +5348,10 @@ Object.freeze({
 			"valueType": "boolean"
 		}
 	],
-	"ambient-light-sensor": [
-		{
-			"path": "lux",
-			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		}
-	],
+	"ambient-light-sensor": [{
+		"path": "lux",
+		"valueType": "number"
+	}],
 	"audio-metrics": [
 		{
 			"path": "ts",
@@ -5342,6 +5431,10 @@ Object.freeze({
 			"path": "lastUpdated",
 			"valueType": "number"
 		},
+		{
+			"path": "volts",
+			"valueType": "number"
+		},
 		{
 			"path": "lastContactAt",
 			"valueType": "number"
@@ -5584,10 +5677,6 @@ Object.freeze({
 				"datetime"
 			]
 		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
 		{
 			"path": "min",
 			"valueType": "number"
@@ -5599,19 +5688,6 @@ Object.freeze({
 		{
 			"path": "step",
 			"valueType": "number"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		},
-		{
-			"path": "format",
-			"valueType": "enum",
-			"enumValues": [
-				"date",
-				"time",
-				"datetime"
-			]
 		}
 	],
 	"cover": [
@@ -5852,13 +5928,8 @@ Object.freeze({
 		"path": "value",
 		"valueType": "string"
 	}, {
-		"path": "format",
-		"valueType": "enum",
-		"enumValues": [
-			"date",
-			"time",
-			"datetime"
-		]
+		"path": "timestamp",
+		"valueType": "boolean"
 	}],
 	"event-emitter": [
 		{
@@ -5931,6 +6002,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"
@@ -5965,20 +6050,10 @@ Object.freeze({
 			"valueType": "number"
 		}
 	],
-	"humidity-sensor": [
-		{
-			"path": "percent",
-			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		}
-	],
+	"humidity-sensor": [{
+		"path": "percent",
+		"valueType": "number"
+	}],
 	"image": [{
 		"path": "url",
 		"valueType": "string"
@@ -6317,20 +6392,10 @@ Object.freeze({
 			"valueType": "boolean"
 		}
 	],
-	"numeric-sensor": [
-		{
-			"path": "value",
-			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		}
-	],
+	"numeric-sensor": [{
+		"path": "value",
+		"valueType": "number"
+	}],
 	"pet-feeder": [
 		{
 			"path": "foodLevel",
@@ -6422,14 +6487,6 @@ Object.freeze({
 		{
 			"path": "powerFactor",
 			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
 		}
 	],
 	"presence": [
@@ -6458,20 +6515,10 @@ Object.freeze({
 			"valueType": "number"
 		}
 	],
-	"pressure-sensor": [
-		{
-			"path": "hpa",
-			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		}
-	],
+	"pressure-sensor": [{
+		"path": "hpa",
+		"valueType": "number"
+	}],
 	"privacy-mask": [{
 		"path": "enabled",
 		"valueType": "boolean"
@@ -6782,20 +6829,10 @@ Object.freeze({
 		"path": "tampered",
 		"valueType": "boolean"
 	}],
-	"temperature-sensor": [
-		{
-			"path": "celsius",
-			"valueType": "number"
-		},
-		{
-			"path": "unit",
-			"valueType": "string"
-		},
-		{
-			"path": "precision",
-			"valueType": "number"
-		}
-	],
+	"temperature-sensor": [{
+		"path": "celsius",
+		"valueType": "number"
+	}],
 	"update": [
 		{
 			"path": "currentVersion",
@@ -6906,10 +6943,6 @@ Object.freeze({
 			"path": "temperature",
 			"valueType": "number"
 		},
-		{
-			"path": "temperatureUnit",
-			"valueType": "string"
-		},
 		{
 			"path": "humidity",
 			"valueType": "number"
@@ -6918,18 +6951,10 @@ Object.freeze({
 			"path": "pressure",
 			"valueType": "number"
 		},
-		{
-			"path": "pressureUnit",
-			"valueType": "string"
-		},
 		{
 			"path": "windSpeed",
 			"valueType": "number"
 		},
-		{
-			"path": "windSpeedUnit",
-			"valueType": "string"
-		},
 		{
 			"path": "windBearing",
 			"valueType": "number"
@@ -7458,7 +7483,7 @@ function errMsg(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-kEl9mevu.mjs
+//#region ../types/dist/composition-B85l9j1M.mjs
 var AUDIO_ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac",
@@ -8976,6 +9001,68 @@ 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"
+];
+var NUMERIC_AGGREGATES = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum"
+];
+var BINARY_AGGREGATES = ["any", "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);
+/** 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)
+});
+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
@@ -9000,11 +9087,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,
@@ -9047,10 +9129,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({
@@ -9115,7 +9229,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) => {
@@ -9162,6 +9282,7 @@ function fieldReads(source) {
 			cap: binding.cap,
 			fieldPath: binding.fieldPath
 		}] : []);
+		case "aggregate": return source.reads;
 		case "code": return [];
 	}
 }
@@ -17134,6 +17255,17 @@ function unwrapSchema(schema) {
 	while (s instanceof zod.z.ZodNullable || s instanceof zod.z.ZodOptional || s instanceof zod.z.ZodDefault) s = s.unwrap();
 	return s;
 }
+function isMetaBag(value) {
+	return typeof value === "object" && value !== null;
+}
+function metaQuantity(schema) {
+	const bag = zod.z.globalRegistry.get(schema);
+	if (isMetaBag(bag) && isReadingQuantity(bag.quantity)) return bag.quantity;
+}
+/** Quantity declared with `readingMeta` on the field or on the unwrapped leaf. */
+function quantityOfField(schema) {
+	return metaQuantity(schema) ?? metaQuantity(unwrapSchema(schema));
+}
 function leafKind(schema) {
 	const s = unwrapSchema(schema);
 	if (s instanceof zod.z.ZodEnum) return {
@@ -17162,11 +17294,15 @@ function enumerateSchemaFields(schema, prefix = "") {
 			continue;
 		}
 		const leaf = leafKind(field);
-		if (leaf) out.push({
-			path,
-			kind: leaf.kind,
-			...leaf.enumValues ? { enumValues: leaf.enumValues } : {}
-		});
+		if (leaf) {
+			const quantity = quantityOfField(field);
+			out.push({
+				path,
+				kind: leaf.kind,
+				...leaf.enumValues ? { enumValues: leaf.enumValues } : {},
+				...quantity !== void 0 ? { quantity } : {}
+			});
+		}
 	}
 	return out;
 }
@@ -17225,7 +17361,7 @@ function requiredTopLevelKeys(schema) {
 /**
 * The proper prefixes of `path` whose schema accepts `undefined`: a required
 * leaf under one of them is required only once something writes that parent
-* (`remaining.unit` is required only when `remaining` is present).
+* (`remaining.kind` is required only when `remaining` is present).
 */
 function optionalAncestors(schema, path) {
 	const segments = path.split(".");
@@ -17337,7 +17473,11 @@ var CompositionProblemCodeSchema = zod.z.enum([
 	"item-field-reserved",
 	"target-missing",
 	"target-unreadable",
-	"not-replaceable"
+	"not-replaceable",
+	"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({
@@ -17361,7 +17501,8 @@ var CompositionUnavailableModeSchema = zod.z.enum([
 	"null",
 	"offline",
 	"unknown",
-	"release"
+	"release",
+	"omit"
 ]);
 /**
 * `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
@@ -17403,9 +17544,11 @@ function compositionFieldKey(plan) {
 	return `${plan.cap}.${path}`;
 }
 /**
-* What a feature does to its target (D663): `new` builds a capability on a new
-* device; on an existing device it `add`s a capability the device lacks, or
-* `replace`s named fields of one it has natively.
+* What a feature does to its target (D663, D944): `new` builds a capability on a
+* new device; on an existing device it `add`s a capability the device lacks.
+* Replacing a capability the device already serves is refused
+* (`native-capability-replace`), not planned. `replace` remains on the claim
+* wire for a claim the hub already holds.
 */
 var CompositionFeatureModeSchema = zod.z.enum([
 	"new",
@@ -17721,6 +17864,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;
@@ -17748,6 +17909,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") {
@@ -17942,6 +18104,379 @@ 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,
+		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,
+		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]
+	})
+];
+var BY_ID = new Map(GROUP_TEMPLATES.map((template) => [template.id, template]));
+function groupTemplate(id) {
+	return BY_ID.get(id) ?? null;
+}
+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,
+			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 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}\``)]
+	};
+	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
@@ -18146,6 +18681,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,
@@ -18153,7 +18689,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)]
@@ -18202,6 +18738,9 @@ function isNativeCap(target, cap) {
 	const owner = target.nativeCaps.get(cap);
 	return owner !== void 0 && owner !== "composer";
 }
+function isPlanProblem(value) {
+	return "code" in value;
+}
 /** The target read, or the refusal that replaces the whole plan when it could not be (D391). */
 function planTargetOf(composition, target) {
 	if (composition.target.kind === "new") return {
@@ -18217,26 +18756,59 @@ function planTargetOf(composition, target) {
 		found: target
 	};
 }
-function featureTargetOf(target, cap) {
+var NATIVE_REPLACE_KEPT = new Set([
+	"not-composable",
+	"unknown-capability",
+	"reserved-variant"
+]);
+/** A native override is refused, unless the cap cannot be composed at all — that reason stays. */
+function nativeReplaceOrBlock(refusal, probed) {
+	const kept = probed.problems.filter((item) => NATIVE_REPLACE_KEPT.has(item.code));
+	if (kept.length > 0) return {
+		problems: kept,
+		fields: [],
+		features: [],
+		events: []
+	};
+	return refused(refusal);
+}
+function featureTargetOf(target, cap, at) {
 	if (target.kind === "new") return {
 		mode: "new",
 		deviceType: target.type
 	};
+	if (isNativeCap(target.found, cap)) return problem("native-capability-replace", at, `native-capability-replace: stored override replaces native capability \`${cap}\` on device ${target.found.deviceId} — refused (D944)`);
 	return {
-		mode: isNativeCap(target.found, cap) ? "replace" : "add",
+		mode: "add",
 		deviceType: target.found.type
 	};
 }
 /**
 * The static plan. `target` describes an EXISTING target device (one read);
-* it is ignored for a new one. On an existing target each feature REPLACES a
-* cap the device has natively, else ADDS it (D663).
+* it is ignored for a new one. On an existing target each feature ADDS a cap
+* the device lacks. A feature that would replace a native capability is
+* refused by name (D944). A new device is unchanged.
 */
 function planComposition(composition, lookupCap, target) {
 	const planTarget = planTargetOf(composition, target);
 	if ("code" in planTarget) return refused(planTarget);
 	const results = composition.features.map((feature, index) => {
-		const result = feature.kind === "passthrough" ? refused(problem("reserved-variant", `features[${index}]`, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`)) : planFeature(feature, index, featureTargetOf(planTarget, feature.cap), lookupCap);
+		const at = `features[${index}]`;
+		if (feature.kind === "passthrough") return refused(problem("reserved-variant", at, `whole-capability passthrough of \`${feature.cap}\` arrives in slice 3`));
+		const featureTarget = featureTargetOf(planTarget, feature.cap, at);
+		if (isPlanProblem(featureTarget)) {
+			if (!compositionFeatureEnabled(feature) || planTarget.kind !== "existing") return {
+				problems: [],
+				fields: [],
+				features: [],
+				events: []
+			};
+			return nativeReplaceOrBlock(featureTarget, planFeature(feature, index, {
+				mode: "add",
+				deviceType: planTarget.found.type
+			}, lookupCap));
+		}
+		const result = planFeature(feature, index, featureTarget, lookupCap);
 		return compositionFeatureEnabled(feature) ? result : {
 			problems: result.problems,
 			fields: [],
@@ -18377,11 +18949,20 @@ function cycleProblems(composition, ctx, fields, self) {
 function validateComposition(composition, ctx) {
 	const plan = planComposition(composition, ctx.lookupCap, ctx.target ?? void 0);
 	const self = candidateSelf(composition, ctx, plan);
-	const cycles = cycleProblems(composition, ctx, plan.fields, self);
+	const refusedFeatures = plan.problems.filter((item) => item.code === "native-capability-replace").map((item) => item.path);
+	const cycles = cycleProblems(composition, ctx, plan.fields, self).filter((item) => {
+		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,
@@ -20894,12 +21475,12 @@ getAdminLink: method(zod.z.object({ deviceId: zod.z.number().int().nonnegative()
 *      providers detect renames by matching `uniqueId` and patch `id`
 *      in-place so dispatch keeps working.
 *
-* **Rendering metadata is NOT stored here.** Display fields (`unit`,
-* `precision`) live in the cap STATUS SLICE so they flow live with every
-* state push and are the single source of truth. The `device_class` tag is
-* an HA-specific input that is consumed at the discovery boundary
-* (`ha-domain-mapping`) to derive the CamStack `DeviceRole`; it is never
-* stored after that point.
+* **Display unit and precision are NOT stored here.** They are a read-time
+* preference (D944). A polymorphic reading stores its `quantity` here once,
+* at adopt, and a date/time value stores `dateTimeShape` the same way —
+* neither is repeated on each sample. The `device_class` tag is an
+* HA-specific input consumed at the discovery boundary (`ha-domain-mapping`)
+* to derive the CamStack `DeviceRole`; it is never stored after that point.
 *
 * The `raw` escape hatch carries provider-specific attributes that don't
 * fit the structured slots (HA `attributes` whitelist, Reolink `deviceCache`
@@ -20913,6 +21494,14 @@ var SourceInfoSchema = zod.z.object({
 	/** Immutable upstream identifier when available (HA `unique_id`, … ).
 	*  Used to detect rename when `id` changes. */
 	uniqueId: zod.z.string().optional(),
+	/** Quantity of a polymorphic reading, written once at adopt (D944). */
+	quantity: ReadingQuantitySchema.optional(),
+	/** Date / time / datetime shape of a string reading, written once at adopt. */
+	dateTimeShape: zod.z.enum([
+		"date",
+		"time",
+		"datetime"
+	]).optional(),
 	/** Provider-specific extras that don't fit the structured slots.
 	*  Whitelist what goes here per provider — do NOT dump entire HA
 	*  attribute blobs (would explode the meta JSON column). */
@@ -20997,9 +21586,38 @@ function normalizeUnit(raw) {
 	if (lower === "mph") return "mph";
 	if (lower === "m/s") return "m/s";
 	if (lower === "m") return "m";
+	if (lower === "m²" || lower === "m2") return "m²";
+	if (lower === "mm") return "mm";
+	if (lower === "cm") return "cm";
 	if (lower === "km") return "km";
+	if (lower === "in" || lower === "inch" || lower === "inches") return "in";
+	if (lower === "ft" || lower === "foot" || lower === "feet") return "ft";
 	if (lower === "kg") return "kg";
 	if (lower === "g") return "g";
+	if (lower === "l" || lower === "liter" || lower === "litre" || lower === "liters" || lower === "litres") return "L";
+	if (lower === "ml") return "mL";
+	if (lower === "gal" || lower === "gallon" || lower === "gallons") return "gal";
+	if (lower === "s" || lower === "sec" || lower === "second" || lower === "seconds") return "s";
+	if (lower === "ms") return "ms";
+	if (lower === "min" || lower === "minute" || lower === "minutes") return "min";
+	if (lower === "h" || lower === "hr" || lower === "hour" || lower === "hours") return "h";
+	if (lower === "d" || lower === "day" || lower === "days") return "d";
+	if (lower === "b" || lower === "byte" || lower === "bytes") return "B";
+	if (lower === "kib") return "KiB";
+	if (lower === "mib") return "MiB";
+	if (lower === "gib") return "GiB";
+	if (lower === "tib") return "TiB";
+	if (lower === "kb") return "kB";
+	if (lower === "mb") return "MB";
+	if (lower === "gb") return "GB";
+	if (lower === "dbm") return "dBm";
+	if (lower === "dbfs") return "dBFS";
+	if (lower === "inhg") return "inHg";
+	if (lower === "mm/h") return "mm/h";
+	if (lower === "w/m²" || lower === "w/m2") return "W/m²";
+	if (lower === "°" || lower === "deg" || lower === "degree" || lower === "degrees") return "°";
+	if (lower === "kbps") return "kbps";
+	if (lower === "fps") return "fps";
 	return trimmed;
 }
 /**
@@ -42261,7 +42879,8 @@ var deviceManagerCapability = {
 					"enum"
 				]),
 				enumValues: zod.z.array(zod.z.string()).optional(),
-				item: zod.z.boolean().optional()
+				item: zod.z.boolean().optional(),
+				quantity: ReadingQuantitySchema.optional()
 			})).readonly(),
 			itemArray: zod.z.object({
 				path: zod.z.string(),
@@ -47526,8 +48145,8 @@ var MaskPolygonShapeSchema = zod.z.object({
 /** Boolean cell grid — row-major, length === gridWidth*gridHeight. */
 var MaskGridShapeSchema = zod.z.object({
 	kind: zod.z.literal("grid"),
-	gridWidth: zod.z.number(),
-	gridHeight: zod.z.number(),
+	gridWidth: zod.z.number().meta(readingMeta("none")),
+	gridHeight: zod.z.number().meta(readingMeta("none")),
 	cells: zod.z.array(zod.z.boolean())
 });
 /** Directed line / tripwire — an ordered list of normalized points (≥2). */
@@ -62076,27 +62695,17 @@ var addonsCapability = {
 */
 var AirQualitySensorStatusSchema = zod.z.object({
 	/** Carbon dioxide concentration in ppm. */
-	co2Ppm: zod.z.number().min(0).optional(),
+	co2Ppm: zod.z.number().min(0).optional().meta(readingMeta("concentration-volume")),
 	/** Total volatile organic compounds in ppb. */
-	vocPpb: zod.z.number().min(0).optional(),
+	vocPpb: zod.z.number().min(0).optional().meta(readingMeta("concentration-ppb")),
 	/** Particulate matter ≤ 2.5 μm in µg/m³. */
-	pm25: zod.z.number().min(0).optional(),
+	pm25: zod.z.number().min(0).optional().meta(readingMeta("concentration-mass")),
 	/** Particulate matter ≤ 10 μm in µg/m³. */
-	pm10: zod.z.number().min(0).optional(),
+	pm10: zod.z.number().min(0).optional().meta(readingMeta("concentration-mass")),
 	/** Composite AQI value (typically 0..500). */
-	aqi: zod.z.number().optional(),
+	aqi: zod.z.number().optional().meta(readingMeta("index")),
 	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit of the single metric this slice carries (e.g. HA
-	*  `attributes.unit_of_measurement` → 'ppm' / 'ppb' / 'µg/m³'). Each
-	*  upstream `sensor.*` entity surfaces ONE device_class, so one unit
-	*  per slice is unambiguous. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var airQualitySensorCapability = {
 	name: "air-quality-sensor",
@@ -62133,12 +62742,12 @@ var airQualitySensorCapability = {
 		},
 		pm25: {
 			kind: "gauge",
-			unit: "ug/m3",
+			unit: "µg/m³",
 			deadband: 1
 		},
 		pm10: {
 			kind: "gauge",
-			unit: "ug/m3",
+			unit: "µg/m³",
 			deadband: 1
 		},
 		aqi: {
@@ -62156,22 +62765,13 @@ var airQualitySensorCapability = {
 * entries with `device_class: illuminance`.
 */
 var AmbientLightSensorStatusSchema = zod.z.object({
-	/** Current illuminance in lux (lx). */
-	lux: zod.z.number().min(0).meta({
-		unit: "lx",
+	/** Current illuminance in lux (lx). `null` when the sample was refused (D393). */
+	lux: zod.z.number().min(0).nullable().meta(readingMeta("illuminance", {
+		precision: 0,
 		label: "Illuminance"
-	}),
+	})),
 	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit from the upstream source (e.g. HA
-	*  `attributes.unit_of_measurement`). The UI prefers this over the
-	*  role's canonical unit. Absent → fall back to the canonical unit. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var ambientLightSensorCapability = {
 	name: "ambient-light-sensor",
@@ -62203,12 +62803,7 @@ var ambientLightSensorCapability = {
 	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"],
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	volatileStateFields: ["lastFetchedAt"]
 };
 /**
 * Per-class audio metrics aggregated over a sliding window.
@@ -62444,10 +63039,7 @@ var BatteryStatusSchema = zod.z.object({
 	* Consumers must SKIP a null rather than coerce it — `battery-band` already
 	* declines to band a non-finite reading, which is the correct shape.
 	*/
-	percentage: zod.z.number().min(0).max(100).nullable().meta({
-		unit: "%",
-		label: "Charge"
-	}),
+	percentage: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage", { label: "Charge" })),
 	/**
 	* Charging source. `'dc'` covers wall/USB adapters; `'solar'` is
 	* Reolink-specific for the Solar Panel 2 accessory (will become
@@ -62474,7 +63066,14 @@ var BatteryStatusSchema = zod.z.object({
 	*/
 	sleeping: zod.z.boolean().meta({ label: "Sleeping" }),
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
-	lastUpdated: zod.z.number(),
+	lastUpdated: zod.z.number().meta(readingMeta("none")),
+	/**
+	* Battery voltage in volts, for a cell the firmware reports as voltage
+	* rather than a percentage (Ecowitt capacitor packs). Absent on cameras
+	* that only report charge. A second reading on this cap, not a second
+	* `numeric-sensor` on the same device.
+	*/
+	volts: zod.z.number().nullable().optional().meta(readingMeta("voltage", { label: "Voltage" })),
 	/**
 	* Ms epoch of the last time the device PROVED it was reachable — a
 	* completed firmware round-trip, an observed wake, or an inbound push
@@ -62526,7 +63125,6 @@ var BATTERY_DEVICE_TYPES = [
 /** Generic Customize target for the percentage reading (D936). */
 var batteryCustomize = {
 	version: 1,
-	advanced: "derive",
 	targets: [{
 		id: "percentage",
 		cardinality: "scalar",
@@ -62535,7 +63133,7 @@ var batteryCustomize = {
 			stateField: "percentage"
 		},
 		deviceTypes: BATTERY_DEVICE_TYPES,
-		apply: "add-or-replace",
+		apply: "add",
 		path: "percentage",
 		sources: [{
 			kind: "field",
@@ -62656,10 +63254,16 @@ onStatusChanged: { data: zod.z.object({
 	/**
 	* History (D850): recorded series. The generic capture replaces the `battery` series of `pipeline-analytics:stats-5m`.
 	*/
-	history: { fields: { percentage: {
-		kind: "gauge",
-		unit: "%"
-	} } },
+	history: { fields: {
+		percentage: {
+			kind: "gauge",
+			unit: "%"
+		},
+		volts: {
+			kind: "gauge",
+			unit: "V"
+		}
+	} },
 	customize: batteryCustomize,
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
@@ -62706,12 +63310,7 @@ var binaryCapability = {
 	history: { fields: { on: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastChangedAt"],
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	volatileStateFields: ["lastChangedAt"]
 };
 /**
 * Dimmable-light brightness control. Co-exists with `switch` on the
@@ -62727,7 +63326,7 @@ var binaryCapability = {
 */
 var BrightnessStatusSchema = zod.z.object({
 	/** Current level as 0..100 inclusive. Firmware-reported. */
-	percentage: zod.z.number().min(0).max(100),
+	percentage: zod.z.number().min(0).max(100).meta(readingMeta("percentage")),
 	/** Ms epoch of the last operator-driven change. Useful for UI freshness. */
 	lastChangedAt: zod.z.number()
 });
@@ -63278,21 +63877,21 @@ var ClimateControlStatusSchema = zod.z.object({
 	/** Single setpoint in Celsius. Used by single-target modes
 	*  (heat / cool / dry). Null when the device is in a range mode
 	*  (`heat_cool`) or has no setpoint at all (`fan_only`/`off`). */
-	target: zod.z.number().nullable(),
+	target: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Upper bound of the dual setpoint in Celsius. Populated only
 	*  in `heat_cool` mode. */
-	targetHigh: zod.z.number().nullable(),
+	targetHigh: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Lower bound of the dual setpoint in Celsius. Populated only
 	*  in `heat_cool` mode. */
-	targetLow: zod.z.number().nullable(),
+	targetLow: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Target relative humidity (0..100). Null when the device has no
 	*  humidity control. */
-	targetHumidity: zod.z.number().min(0).max(100).nullable(),
+	targetHumidity: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity")),
 	/** Current measured temperature in Celsius. Read-only — pushed by
 	*  the device's internal sensor. */
-	currentTemp: zod.z.number().nullable(),
+	currentTemp: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Current measured relative humidity (0..100). Read-only. */
-	currentHumidity: zod.z.number().min(0).max(100).nullable(),
+	currentHumidity: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity")),
 	/** Vertical louver swing on/off. Null when the device has no vertical
 	*  swing surface (gate with `DeviceFeature.ClimateSwingVertical`). */
 	swingVertical: zod.z.boolean().nullable(),
@@ -63300,11 +63899,11 @@ var ClimateControlStatusSchema = zod.z.object({
 	*  horizontal swing surface (gate with `DeviceFeature.ClimateSwingHorizontal`). */
 	swingHorizontal: zod.z.boolean().nullable(),
 	/** Lowest setpoint the device accepts, Celsius. Absent / null = not reported. */
-	minTemp: zod.z.number().nullable().optional(),
+	minTemp: zod.z.number().nullable().optional().meta(readingMeta("temperature")),
 	/** Highest setpoint the device accepts, Celsius. Absent / null = not reported. */
-	maxTemp: zod.z.number().nullable().optional(),
+	maxTemp: zod.z.number().nullable().optional().meta(readingMeta("temperature")),
 	/** Setpoint granularity, Celsius (0.5, 1). Absent / null = not reported. */
-	tempStep: zod.z.number().positive().nullable().optional(),
+	tempStep: zod.z.number().positive().nullable().optional().meta(readingMeta("temperature")),
 	/** Ms epoch when the slice was last updated (push or command). */
 	lastFetchedAt: zod.z.number()
 });
@@ -63446,17 +64045,17 @@ var climateControlCapability = {
 * modes to expose in the picker without a slice fetch.
 */
 var RgbTripletSchema = zod.z.object({
-	r: zod.z.number().int().min(0).max(255),
-	g: zod.z.number().int().min(0).max(255),
-	b: zod.z.number().int().min(0).max(255)
+	r: zod.z.number().int().min(0).max(255).meta(readingMeta("none")),
+	g: zod.z.number().int().min(0).max(255).meta(readingMeta("none")),
+	b: zod.z.number().int().min(0).max(255).meta(readingMeta("none"))
 });
 var HsvTripletSchema = zod.z.object({
 	/** Hue in degrees, 0..360. */
-	h: zod.z.number().min(0).max(360),
+	h: zod.z.number().min(0).max(360).meta(readingMeta("none")),
 	/** Saturation as 0..100 inclusive. */
-	s: zod.z.number().min(0).max(100),
+	s: zod.z.number().min(0).max(100).meta(readingMeta("none")),
 	/** Value/brightness as 0..100 inclusive. */
-	v: zod.z.number().min(0).max(100)
+	v: zod.z.number().min(0).max(100).meta(readingMeta("none"))
 });
 var ColorInputSchema = zod.z.discriminatedUnion("mode", [
 	zod.z.object({
@@ -63485,7 +64084,7 @@ var ColorStatusSchema = zod.z.object({
 	/** Populated when `mode === 'hsv'`. */
 	hsv: HsvTripletSchema.optional(),
 	/** Populated when `mode === 'mired'`. */
-	mireds: zod.z.number().int().optional(),
+	mireds: zod.z.number().int().optional().meta(readingMeta("colour-temperature")),
 	/** Ms epoch of the last operator-driven change. */
 	lastChangedAt: zod.z.number()
 });
@@ -63688,18 +64287,12 @@ zod.z.enum([
 	"empty",
 	"full"
 ]);
-/** Units a remaining-life counter is reported in. Closed: the panel renders
-*  each. */
-var ConsumableRemainingUnitSchema = zod.z.enum([
-	"days",
-	"hours",
-	"cycles"
-]);
-/** Remaining life as a COUNT, not a percentage (the PetKit desiccant reports
-*  days). `value` null = unknown (D393). */
+/** Whether `remaining.value` is a duration in seconds or a dimensionless count. */
+var ConsumableRemainingKindSchema = zod.z.enum(["duration", "count"]);
+/** Remaining life. `value` null = unknown (D393). Duration is seconds. */
 var ConsumableRemainingSchema = zod.z.object({
-	value: zod.z.number().min(0).nullable(),
-	unit: ConsumableRemainingUnitSchema
+	value: zod.z.number().min(0).nullable().meta(readingMeta("device")),
+	kind: ConsumableRemainingKindSchema
 });
 /** A single consumable item. Either a continuous `level` (remaining
 *  life %, or fill % for a `supply` / `waste` item) or a discrete `status`
@@ -63712,7 +64305,7 @@ var ConsumableItemSchema = zod.z.object({
 	/** Display name. */
 	label: zod.z.string().min(1),
 	/** Remaining life % (`wear`) or fill % (`supply`, `waste`) when known (0..100). */
-	level: zod.z.number().min(0).max(100).nullable(),
+	level: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** The provider's discrete verdict when known (binary mode). */
 	status: ConsumableStatusSchema.nullable(),
 	/** What the item is — decides whether low or full is bad. Absent = `wear`. */
@@ -63794,8 +64387,8 @@ var consumablesCustomize = {
 					transforms: [{ kind: "identity" }]
 				}],
 				literals: [{
-					path: "remaining.unit",
-					values: [...ConsumableRemainingUnitSchema.options]
+					path: "remaining.kind",
+					values: [...ConsumableRemainingKindSchema.options]
 				}]
 			},
 			{
@@ -63924,7 +64517,6 @@ reset: method(zod.z.object({
 				},
 				"remaining.value": {
 					kind: "gauge",
-					unitFrom: "remaining.unit",
 					deadband: 1,
 					displayName: "Remaining"
 				}
@@ -64023,49 +64615,26 @@ var ControlKindSchema = zod.z.enum([
 * (empty array for the other kinds). It lives in the slice because
 * HA `select.*` entities may update their options at runtime.
 *
-* The `unit`/`min`/`max`/`step` fields are meaningful for
-* `kind === 'numeric'` and are absent (undefined) for all other
-* kinds. They are populated live from HA attributes on each state
-* push — consistent with `options` and the sensor-unit approach.
+* Numeric `min` / `max` / `step` live in the slice and share the device
+* quantity (`SourceInfo.quantity`, D944). Display precision is a read-time
+* preference. A datetime control's shape is `SourceInfo.dateTimeShape`.
 */
 var ControlStatusSchema = zod.z.object({
 	kind: ControlKindSchema,
 	/** Current value. Numeric kind → number; select/text/datetime → string.
 	*  Datetime values are ISO 8601 strings (full timestamp, date-only,
 	*  or time-only — HA accepts all three forms). */
-	value: zod.z.union([zod.z.number(), zod.z.string()]),
+	value: zod.z.union([zod.z.number().meta(readingMeta("device")), zod.z.string()]),
 	/** Acceptable values when `kind === 'select'`. Empty for other kinds. */
 	options: zod.z.array(zod.z.string()),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number(),
-	/** Display unit-of-measurement (e.g. '°C', '%', 'lx').
-	*  Populated live from HA `attributes.unit_of_measurement` on each push.
-	*  Meaningful for `kind === 'numeric'`; absent for other kinds. */
-	unit: zod.z.string().optional(),
-	/** Minimum allowed value. Populated live from HA `attributes.min`.
-	*  Meaningful for `kind === 'numeric'`; absent for other kinds. */
-	min: zod.z.number().optional(),
-	/** Maximum allowed value. Populated live from HA `attributes.max`.
-	*  Meaningful for `kind === 'numeric'`; absent for other kinds. */
-	max: zod.z.number().optional(),
-	/** Step increment. Populated live from HA `attributes.step`.
-	*  Meaningful for `kind === 'numeric'`; absent for other kinds. */
-	step: zod.z.number().optional(),
-	/** Suggested decimal places for numeric display. Populated live from HA
-	*  `attributes.suggested_display_precision`, or derived from `step` when the
-	*  HA attribute is absent. Meaningful for `kind === 'numeric'`; absent for
-	*  other kinds. Falls back to auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional(),
-	/** Date-picker granularity for `kind === 'datetime'`. 'date' → date-only,
-	*  'time' → time-only, 'datetime' → full timestamp. Absent for other kinds
-	*  (UI defaults to 'datetime'). Derived live from the device's HA domain
-	*  (date.* / time.* / datetime.*) or, for input_datetime, from the entity's
-	*  `has_date`/`has_time` attributes on each push. */
-	format: zod.z.enum([
-		"date",
-		"time",
-		"datetime"
-	]).optional()
+	/** Minimum allowed value, in the device quantity's base unit. */
+	min: zod.z.number().optional().meta(readingMeta("device")),
+	/** Maximum allowed value, in the device quantity's base unit. */
+	max: zod.z.number().optional().meta(readingMeta("device")),
+	/** Step increment, in the device quantity's base unit. */
+	step: zod.z.number().optional().meta(readingMeta("device"))
 });
 var ControlSetValueInputSchema = zod.z.discriminatedUnion("kind", [
 	zod.z.object({
@@ -64153,9 +64722,9 @@ var CoverStatusSchema = zod.z.object({
 	state: CoverStateSchema,
 	/** 0 = fully closed, 100 = fully open. Null when the device has
 	*  no intermediate position surface. */
-	position: zod.z.number().min(0).max(100).nullable(),
+	position: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** 0 = closed slats, 100 = open slats. Null when no tilt support. */
-	tiltPosition: zod.z.number().min(0).max(100).nullable(),
+	tiltPosition: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -64258,9 +64827,9 @@ var NormalizedRangeSchema$1 = zod.z.object({
 var DayNightStatusSchema = zod.z.object({
 	mode: DayNightModeSchema,
 	/** IR-cut trigger sensitivity, NORMALIZED 0–100 (higher = switches to night sooner). */
-	sensitivity: zod.z.number().optional(),
+	sensitivity: zod.z.number().optional().meta(readingMeta("none")),
 	/** Delay before the IR-cut filter flips, in seconds. */
-	switchDelaySec: zod.z.number().optional(),
+	switchDelaySec: zod.z.number().optional().meta(readingMeta("duration")),
 	lastFetchedAt: zod.z.number()
 });
 /**
@@ -64487,11 +65056,11 @@ var DishwasherStatusSchema = zod.z.object({
 	/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
 	availablePrograms: zod.z.array(zod.z.string()),
 	/** Seconds remaining on the active cycle, or null when not running / not known. */
-	remainingSeconds: zod.z.number().int().nonnegative().nullable(),
+	remainingSeconds: zod.z.number().int().nonnegative().nullable().meta(readingMeta("duration")),
 	/** Seconds the delayed start is set to (time until the cycle starts), or null. */
-	delayedStartSeconds: zod.z.number().int().nonnegative().nullable(),
+	delayedStartSeconds: zod.z.number().int().nonnegative().nullable().meta(readingMeta("duration")),
 	/** Cycle completion 0..100, or null when not applicable. */
-	progressPercent: zod.z.number().min(0).max(100).nullable(),
+	progressPercent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** True when the door is reported open; null when the door state is not known. */
 	doorOpen: zod.z.boolean().nullable(),
 	/** True when the door is latched (locked) during a cycle; null when not reported. */
@@ -64515,7 +65084,7 @@ var DishwasherStatusSchema = zod.z.object({
 	/** True while the machine-care (descaling / cleaning-program) reminder is raised; false when clear; null when not reported. */
 	machineCareDue: zod.z.boolean().nullable(),
 	/** Program runs left before the machine-care reminder is due; null when the appliance does not say. */
-	machineCareRemainingRuns: zod.z.number().int().nonnegative().nullable(),
+	machineCareRemainingRuns: zod.z.number().int().nonnegative().nullable().meta(readingMeta("count")),
 	/** Option states: null when the appliance does not expose the option or has not said. */
 	halfLoad: zod.z.boolean().nullable(),
 	hygienePlus: zod.z.boolean().nullable(),
@@ -64530,7 +65099,7 @@ var DishwasherStatusSchema = zod.z.object({
 	/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
 	activeEvents: zod.z.array(zod.z.string()),
 	/** Numeric error code when the appliance reports one; null otherwise. */
-	errorCode: zod.z.number().nullable(),
+	errorCode: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
 	errorLabel: zod.z.string().nullable(),
 	/** Ms epoch of the last value received from the appliance; 0 = never. */
@@ -64761,7 +65330,7 @@ var DoorbellStatusSchema = zod.z.object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
 	lastPressedAt: zod.z.number().nullable(),
 	/** Counter since provider start. Resets on reboot. Useful for metrics/debug. */
-	pressCountSinceStart: zod.z.number()
+	pressCountSinceStart: zod.z.number().meta(readingMeta("count"))
 });
 var DoorbellPressEventSchema = zod.z.object({
 	deviceId: zod.z.number(),
@@ -64826,17 +65395,7 @@ onPressed: {
 	history: "none",
 	customize: doorbellCustomize
 };
-/**
-* Enum-state sensor — a string value picked from a finite option set.
-* Drives HA `sensor` entries with `state_class: enum` (HVAC action
-* states, weather conditions, contact-source channels, mode strings).
-* The option set is stable across observations; it is persisted in the
-* device config blob (via the control slice at adoption) and is NOT
-* stored in `sourceInfo`.
-*/
-/** Locale-render shape for an ISO `value` carried by a `DateTimeSensor`-role
-*  enum sensor: `date` (date-only), `time` (time-only), `datetime` (both). */
-var EnumSensorDateTimeFormatSchema = zod.z.enum([
+zod.z.enum([
 	"date",
 	"time",
 	"datetime"
@@ -64844,12 +65403,11 @@ var EnumSensorDateTimeFormatSchema = zod.z.enum([
 var EnumSensorStatusSchema = zod.z.object({
 	value: zod.z.string(),
 	/**
-	* Set for `DateTimeSensor`-role sensors so the UI renders the ISO `value`
-	* as a locale date/time/datetime; absent for plain enum sensors. HA
-	* `device_class=timestamp` → `'datetime'`, `device_class=date` → `'date'`,
-	* a time-only sensor → `'time'`.
+	* Set when `value` is a timestamp rather than an enum state, so history
+	* does not learn ISO strings as states. The display shape (date / time /
+	* datetime) lives on `SourceInfo.dateTimeShape`, written once at adopt.
 	*/
-	format: EnumSensorDateTimeFormatSchema.optional(),
+	timestamp: zod.z.boolean().optional(),
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: zod.z.number()
 });
@@ -64876,11 +65434,11 @@ var enumSensorCapability = {
 	* History (D850): the value as an `enum` series (an appliance's program or
 	* operation state, an HVAC action). The option set is per device, so the
 	* value list is LEARNED as values are first seen (bounded). A sensor with a
-	* `format` carries a timestamp, not a state, and is not recorded.
+	* `timestamp` carries a clock, not a state, and is not recorded.
 	*/
 	history: { fields: { value: {
 		kind: "enum",
-		skipWhenSet: "format"
+		skipWhenSet: "timestamp"
 	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
@@ -64900,13 +65458,13 @@ var EventFireSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	eventType: zod.z.string(),
 	data: zod.z.record(zod.z.string(), zod.z.unknown()).nullable(),
-	timestamp: zod.z.number(),
-	seq: zod.z.number()
+	timestamp: zod.z.number().meta(readingMeta("none")),
+	seq: zod.z.number().meta(readingMeta("count"))
 });
 var EventEmitterStatusSchema = zod.z.object({
 	eventTypes: zod.z.array(zod.z.string()),
 	lastEvent: EventFireSchema.nullable(),
-	eventCountSinceStart: zod.z.number()
+	eventCountSinceStart: zod.z.number().meta(readingMeta("count"))
 });
 var eventEmitterCapability = {
 	name: "event-emitter",
@@ -65359,10 +65917,10 @@ var FanDirectionSchema = zod.z.enum(["forward", "reverse"]);
 var FanControlStatusSchema = zod.z.object({
 	/** Active speed as 0..100 inclusive. Null when the device has no
 	*  speed surface (single-speed fan). */
-	percentage: zod.z.number().min(0).max(100).nullable(),
+	percentage: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Speed granularity the device accepts (HA `percentage_step`, e.g. 25 for
 	*  a 4-speed fan). Absent when unknown — the UI then falls back to step 1. */
-	percentageStep: zod.z.number().positive().optional(),
+	percentageStep: zod.z.number().positive().optional().meta(readingMeta("percentage")),
 	/** Active preset mode (`auto` / `quiet` / `turbo` / vendor-specific)
 	*  — empty string when no preset is active or supported. */
 	preset: zod.z.string(),
@@ -65483,7 +66041,7 @@ var FeatureProbeStatusSchema = zod.z.object({
 	/** Camera/firmware model string. `null` when the firmware doesn't expose it. */
 	model: zod.z.string().nullable(),
 	/** Channel count for NVR/Hub devices; `1` for standalone cameras; `null` pre-probe. */
-	channelCount: zod.z.number().nullable(),
+	channelCount: zod.z.number().nullable().meta(readingMeta("count")),
 	/**
 	* Ms epoch of the last SUCCESSFUL probe. `0` before the first probe
 	* completes — drivers' `getAccessoryChildren()` should treat zero as
@@ -65606,9 +66164,54 @@ var gasCapability = {
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
 };
+/**
+* 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],
+	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(),
+	position: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Ms epoch when the slice was last updated (push or poll). */
 	lastFetchedAt: zod.z.number()
 });
@@ -65651,9 +66254,9 @@ var HumidifierStatusSchema = zod.z.object({
 	/** Whether the humidifier is currently on. */
 	on: zod.z.boolean(),
 	/** Current measured relative humidity (0..100). Null when not reported. */
-	currentHumidity: zod.z.number().min(0).max(100).nullable(),
+	currentHumidity: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity")),
 	/** Target relative humidity (0..100). Null when no setpoint surface. */
-	targetHumidity: zod.z.number().min(0).max(100).nullable(),
+	targetHumidity: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity")),
 	/** Active mode (`auto` / `normal` / `baby` / vendor). Null when the
 	*  device has no mode surface. */
 	mode: zod.z.string().nullable(),
@@ -65663,9 +66266,9 @@ var HumidifierStatusSchema = zod.z.object({
 	*  `idle` / `off`). Null when the device doesn't report it. */
 	action: zod.z.string().nullable(),
 	/** HA `min_humidity` attribute. Null → UI uses 0. */
-	minHumidity: zod.z.number().nullable(),
+	minHumidity: zod.z.number().nullable().meta(readingMeta("humidity")),
 	/** HA `max_humidity` attribute. Null → UI uses 100. */
-	maxHumidity: zod.z.number().nullable(),
+	maxHumidity: zod.z.number().nullable().meta(readingMeta("humidity")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -65735,22 +66338,13 @@ var humidifierCapability = {
 * `sourceInfo`.
 */
 var HumiditySensorStatusSchema = zod.z.object({
-	/** Current relative humidity, 0..100. */
-	percent: zod.z.number().min(0).max(100).meta({
-		unit: "%",
+	/** Current relative humidity, 0..100. `null` when the sample was refused (D393). */
+	percent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity", {
+		precision: 0,
 		label: "Humidity"
-	}),
+	})),
 	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit from the upstream source (e.g. HA
-	*  `attributes.unit_of_measurement`). The UI prefers this over the
-	*  role's canonical unit. Absent → fall back to the canonical unit. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var humiditySensorCapability = {
 	name: "humidity-sensor",
@@ -65781,12 +66375,7 @@ var humiditySensorCapability = {
 	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"],
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	volatileStateFields: ["lastFetchedAt"]
 };
 /**
 * Image display cap. Models a single still image exposed by an integration —
@@ -65807,7 +66396,7 @@ var ImageStatusSchema = zod.z.object({
 	*  entity exposes no `entity_picture` (yet). */
 	url: zod.z.string().nullable(),
 	/** Ms epoch of the upstream last-updated timestamp. Null at cold-start. */
-	lastUpdated: zod.z.number().nullable()
+	lastUpdated: zod.z.number().nullable().meta(readingMeta("none"))
 });
 var imageCapability = {
 	name: "image",
@@ -65895,19 +66484,19 @@ var NormalizedRangeSchema = zod.z.object({
 */
 var ImageSettingsStatusSchema = zod.z.object({
 	/** Normalized 0–100. */
-	brightness: zod.z.number().optional(),
+	brightness: zod.z.number().optional().meta(readingMeta("none")),
 	/** Normalized 0–100. */
-	contrast: zod.z.number().optional(),
+	contrast: zod.z.number().optional().meta(readingMeta("none")),
 	/** Normalized 0–100. */
-	saturation: zod.z.number().optional(),
+	saturation: zod.z.number().optional().meta(readingMeta("none")),
 	/** Normalized 0–100. */
-	sharpness: zod.z.number().optional(),
+	sharpness: zod.z.number().optional().meta(readingMeta("none")),
 	mirror: zod.z.boolean().optional(),
 	flip: zod.z.boolean().optional(),
 	rotate: ImageRotateSchema.optional(),
 	whiteBalance: WhiteBalanceModeSchema.optional(),
 	/** Manual white-balance warmth, NORMALIZED 0–100. Meaningful only when `whiteBalance === 'manual'`. */
-	warmth: zod.z.number().optional(),
+	warmth: zod.z.number().optional().meta(readingMeta("none")),
 	exposureMode: ExposureModeSchema.optional(),
 	backlightMode: BacklightModeSchema.optional(),
 	lastFetchedAt: zod.z.number()
@@ -66204,10 +66793,10 @@ var IntercomAbilitySchema = zod.z.object({
 	/** Codecs accepted by firmware, in preference order. Driver-authored strings. */
 	codecs: zod.z.array(zod.z.string()),
 	/** Sample rate (Hz) the firmware expects. Reolink typical: 16000. */
-	sampleRate: zod.z.number(),
+	sampleRate: zod.z.number().meta(readingMeta("none")),
 	duplex: zod.z.enum(["half", "full"]),
 	/** Max in-flight audio backlog before drop (ms). Server uses this to bound latency. */
-	maxBacklogMs: zod.z.number()
+	maxBacklogMs: zod.z.number().meta(readingMeta("duration-ms"))
 });
 var IntercomStatusSchema = zod.z.object({
 	/** True while a talk session is open. */
@@ -66434,13 +67023,13 @@ var LawnMowerControlStatusSchema = zod.z.object({
 	activity: LawnMowerActivitySchema,
 	/** 0..100 battery percentage. Null when the device has no battery
 	*  reading. */
-	batteryLevel: zod.z.number().min(0).max(100).nullable(),
+	batteryLevel: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** 0..100 mowing-completion percentage of the current task, or null when no
 	*  task is active / progress is unavailable. */
-	progressPercent: zod.z.number().min(0).max(100).nullable(),
+	progressPercent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Current device/event code (dynamic — mostly status, sometimes an error),
 	*  or null when unknown. */
-	currentCode: zod.z.number().nullable(),
+	currentCode: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Human label for {@link currentCode}, or null when undecodable. */
 	currentCodeLabel: zod.z.string().nullable(),
 	/** Severity of {@link currentCode}. `error` (and often `warning`) warrants UI
@@ -67164,7 +67753,7 @@ var MediaPlayerStatusSchema = zod.z.object({
 	state: MediaPlayerStateSchema,
 	/** Volume as 0..100 inclusive. Null when the device has no volume
 	*  surface. Pair with `DeviceFeature.MediaPlayerVolume`. */
-	volumeLevel: zod.z.number().min(0).max(100).nullable(),
+	volumeLevel: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Mute toggle distinct from volume=0. Null when no mute surface.
 	*  Pair with `DeviceFeature.MediaPlayerMute`. */
 	isMuted: zod.z.boolean().nullable(),
@@ -67177,10 +67766,10 @@ var MediaPlayerStatusSchema = zod.z.object({
 	currentMedia: MediaInfoSchema.nullable(),
 	/** Current playback position in ms. Null when not seekable or
 	*  nothing is playing. Pair with `DeviceFeature.MediaPlayerSeek`. */
-	positionMs: zod.z.number().int().nonnegative().nullable(),
+	positionMs: zod.z.number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
 	/** Total duration of the current media in ms. Null when unknown
 	*  (live stream) or nothing is playing. */
-	durationMs: zod.z.number().int().nonnegative().nullable(),
+	durationMs: zod.z.number().int().nonnegative().nullable().meta(readingMeta("duration-ms")),
 	/** Shuffle toggle. Null when no shuffle surface.
 	*  Pair with `DeviceFeature.MediaPlayerShuffle`. */
 	shuffle: zod.z.boolean().nullable(),
@@ -67550,7 +68139,7 @@ var motionCustomize = {
 			eventName: "onMotionChanged"
 		},
 		deviceTypes: [DeviceType.Camera],
-		apply: "replace",
+		apply: "add",
 		applyAuthority: {
 			kind: "camera-sensors",
 			timeoutField: "motionCooldownMs"
@@ -67647,7 +68236,7 @@ var MotionStatusSchema = zod.z.object({
 	* it, every provider seeded it at boot, and every session left it
 	* `detected: true` after its detach.
 	*/
-	autoClearAfterMs: zod.z.number().nullable()
+	autoClearAfterMs: zod.z.number().nullable().meta(readingMeta("duration-ms"))
 });
 /**
 * Payload of `motion.onMotionChanged` event + the corresponding bus
@@ -67684,12 +68273,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
@@ -67829,7 +68424,7 @@ var MotionZoneRegionSchema = zod.z.object({
 *  the grid region(s). */
 var MotionZoneStatusSchema = zod.z.object({
 	enabled: zod.z.boolean(),
-	sensitivity: zod.z.number(),
+	sensitivity: zod.z.number().meta(readingMeta("none")),
 	/** Grid region(s). Today exactly one `grid` shape. */
 	regions: zod.z.array(MotionZoneRegionSchema),
 	lastFetchedAt: zod.z.number()
@@ -68201,7 +68796,7 @@ var NavigationStatusSchema = zod.z.object({
 	following: zod.z.boolean(),
 	flash: zod.z.boolean(),
 	lightMode: NavigationLightModeSchema,
-	lightLevel: zod.z.number().min(40).max(100),
+	lightLevel: zod.z.number().min(40).max(100).meta(readingMeta("none")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -68335,13 +68930,13 @@ var NetworkLinkStatusSchema = zod.z.object({
 	* one whose reading has not landed must not be drawn at 0 %. Consumers
 	* SKIP a null rather than coerce it.
 	*/
-	signalPercent: zod.z.number().min(0).max(100).nullable(),
+	signalPercent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Raw received signal strength in dBm, when the firmware reports one. */
-	rssiDbm: zod.z.number().optional(),
+	rssiDbm: zod.z.number().optional().meta(readingMeta("signal-level")),
 	/** Network name of a wireless link, when the firmware reports it. */
 	ssid: zod.z.string().optional(),
 	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
-	lastUpdated: zod.z.number()
+	lastUpdated: zod.z.number().meta(readingMeta("none"))
 });
 var networkLinkCapability = {
 	name: "network-link",
@@ -68791,7 +69386,7 @@ var NotifierStatusSchema = zod.z.object({
 	lastError: zod.z.string().nullable(),
 	/** Number of deliveries currently buffered server-side (rate-limited
 	*  notifiers may queue). 0 when the provider sends synchronously. */
-	queueDepth: zod.z.number().int().nonnegative(),
+	queueDepth: zod.z.number().int().nonnegative().meta(readingMeta("count")),
 	/** Per-feature capability matrix — authoritative source for the
 	*  compose-form field gating. */
 	supports: NotifierSupportsSchema
@@ -68883,11 +69478,9 @@ onSent: { data: zod.z.object({
 * cap fits (HA `sensor` whose `device_class` we don't have a typed cap
 * for: water flow, distance, weight, frequency, signal strength, …).
 *
-* The `unit` and `precision` fields carry the live display metadata that
-* the upstream source provides with each state push (HA
-* `attributes.unit_of_measurement` / `attributes.suggested_display_precision`).
-* The UI reads them directly from the slice — they are the single source
-* of truth for generic numeric rendering and do NOT live on `sourceInfo`.
+* The quantity is not on this slice. It is chosen when the device is
+* adopted and stored once on `SourceInfo.quantity` (D944). `value` is in
+* that quantity's base unit. `null` is a refused sample (D393).
 *
 * Prefer the typed alternatives (`temperature-sensor`, `humidity-sensor`,
 * `ambient-light-sensor`, `pressure-sensor`, `power-meter`,
@@ -68896,15 +69489,8 @@ onSent: { data: zod.z.object({
 * numeric values land here.
 */
 var NumericSensorStatusSchema = zod.z.object({
-	value: zod.z.number(),
-	/** Display unit-of-measurement (e.g. 'dBm', 's', 'rpm', 'steps').
-	*  Populated live from the upstream source on each state push.
-	*  Absent for unitless sensors. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided.
-	*  Falls back to auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional(),
+	/** Reading in the device quantity's base unit. `null` when refused (D393). */
+	value: zod.z.number().nullable().meta(readingMeta("device")),
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: zod.z.number()
 });
@@ -68928,11 +69514,11 @@ var numericSensorCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): recorded series. The unit is per device, read from the sibling `unit` field.
+	* History (D850): recorded series. The unit is the device quantity's base,
+	* resolved when the series is read — the cap has no single unit.
 	*/
 	history: { fields: { value: {
 		kind: "gauge",
-		unitFrom: "unit",
 		minIntervalMs: 3e4
 	} } },
 	/** Clock fields: written, but excluded from the compare that decides
@@ -69333,23 +69919,26 @@ var PetFeederStatusSchema = zod.z.object({
 	/** Food currently in the bowl (grams). Null when the device has not
 	*  reported a reading yet. On dual-hopper models this is the combined
 	*  bowl reading; per-hopper levels live in `food1`/`food2`. */
-	foodLevel: zod.z.number().nullable(),
+	foodLevel: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Hopper-1 food level (grams) on dual-hopper feeders; null on
 	*  single-hopper models. */
-	food1: zod.z.number().nullable(),
+	food1: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Hopper-2 food level (grams) on dual-hopper feeders; null on
 	*  single-hopper models. */
-	food2: zod.z.number().nullable(),
+	food2: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Derived low-food flag — mirrors the HA `food_level` binary_sensor
 	*  (`device_class: problem`, on = low). True when the bowl is empty /
 	*  below the feeder's low threshold. */
 	lowFood: zod.z.boolean(),
 	/** Battery charge 0..100 (%). Null on mains-powered models or when the
 	*  device has no battery reading. */
-	batteryPower: zod.z.number().min(0).max(100).nullable(),
-	/** Days of desiccant life remaining. Null when the model has no
-	*  desiccant sensor. */
-	desiccantLeftDays: zod.z.number().nullable(),
+	batteryPower: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
+	/**
+	* Desiccant life remaining, stored in seconds (duration base, D944).
+	* Providers convert from the days the feeder reports. Null when the
+	* model has no desiccant sensor.
+	*/
+	desiccantLeftDays: zod.z.number().nullable().meta(readingMeta("duration")),
 	/** True while a feed is in progress. */
 	feeding: zod.z.boolean(),
 	/** Decoded connectivity / power status (HA petkit device-status enum).
@@ -69360,7 +69949,7 @@ var PetFeederStatusSchema = zod.z.object({
 	*  with `errorCode` for consumers that want the raw integer. */
 	error: zod.z.string().nullable(),
 	/** Raw device error code (0 / null = no error). */
-	errorCode: zod.z.number().nullable(),
+	errorCode: zod.z.number().nullable().meta(readingMeta("none")),
 	/** True for D4S/D4SH dual-hopper hardware — gates the per-hopper UI. */
 	isDualHopper: zod.z.boolean(),
 	/** Child-lock (manual-lock) setting — buttons on the unit are disabled. */
@@ -69370,7 +69959,7 @@ var PetFeederStatusSchema = zod.z.object({
 	/** Play a chime when dispensing. */
 	feedSound: zod.z.boolean(),
 	/** Speaker / prompt volume level (device-scaled integer). */
-	volume: zod.z.number(),
+	volume: zod.z.number().meta(readingMeta("none")),
 	/** Ms epoch when the slice was last refreshed from the cloud. */
 	lastFetchedAt: zod.z.number()
 });
@@ -69489,7 +70078,7 @@ var petFeederCapability = {
 		},
 		desiccantLeftDays: {
 			kind: "gauge",
-			unit: "days"
+			unit: "s"
 		}
 	} }
 };
@@ -69950,36 +70539,19 @@ var platformProbeCapability = {
 */
 var PowerMeterStatusSchema = zod.z.object({
 	/** Instantaneous power draw in watts. */
-	watts: zod.z.number().optional().meta({
-		unit: "W",
-		label: "Power"
-	}),
+	watts: zod.z.number().optional().meta(readingMeta("power", { label: "Power" })),
 	/** Cumulative energy in kilowatt-hours since the meter was reset. */
-	kwhTotal: zod.z.number().optional().meta({
-		unit: "kWh",
-		label: "Energy"
-	}),
+	kwhTotal: zod.z.number().optional().meta(readingMeta("energy", { label: "Energy" })),
 	/** Voltage in volts. */
-	volts: zod.z.number().optional(),
+	volts: zod.z.number().optional().meta(readingMeta("voltage")),
 	/** Current in amperes. */
-	amps: zod.z.number().optional(),
-	/** Apparent power in volt-amperes (W × power-factor reciprocal). */
-	va: zod.z.number().optional(),
+	amps: zod.z.number().optional().meta(readingMeta("current")),
+	/** Apparent power in volt-amperes. */
+	va: zod.z.number().optional().meta(readingMeta("apparent-power")),
 	/** Power factor (0..1) if reported. */
-	powerFactor: zod.z.number().min(0).max(1).optional(),
+	powerFactor: zod.z.number().min(0).max(1).optional().meta(readingMeta("ratio")),
 	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit of the single metric this slice carries (e.g. HA
-	*  `attributes.unit_of_measurement` → 'V' / 'A' / 'W' / 'kW' / 'kWh').
-	*  Each upstream `sensor.*` entity surfaces ONE device_class, so one
-	*  unit per slice is unambiguous. The UI prefers this over the role's
-	*  canonical unit so a 'kW' / 'Wh' feed renders verbatim. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var powerMeterCapability = {
 	name: "power-meter",
@@ -70043,12 +70615,7 @@ var powerMeterCapability = {
 	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"],
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	volatileStateFields: ["lastFetchedAt"]
 };
 /**
 * Presence cap. Models HA `person.*` and `device_tracker.*` entities
@@ -70068,11 +70635,11 @@ var powerMeterCapability = {
 */
 var GpsLocationSchema = zod.z.object({
 	/** Latitude in decimal degrees, -90..90. */
-	latitude: zod.z.number().min(-90).max(90),
+	latitude: zod.z.number().min(-90).max(90).meta(readingMeta("angle")),
 	/** Longitude in decimal degrees, -180..180. */
-	longitude: zod.z.number().min(-180).max(180),
+	longitude: zod.z.number().min(-180).max(180).meta(readingMeta("angle")),
 	/** Reported accuracy in meters (lower = better). */
-	accuracyMeters: zod.z.number().nonnegative()
+	accuracyMeters: zod.z.number().nonnegative().meta(readingMeta("length"))
 });
 var PresenceStatusSchema = zod.z.object({
 	/** `home` / `not_home` / any user-defined zone name. */
@@ -70084,7 +70651,7 @@ var PresenceStatusSchema = zod.z.object({
 	gps: GpsLocationSchema.nullable(),
 	/** Optional battery level of the tracking device (0..100). Null
 	*  when not reported. */
-	batteryPercent: zod.z.number().min(0).max(100).nullable(),
+	batteryPercent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -70134,19 +70701,10 @@ var presenceCapability = {
 * `sourceInfo`.
 */
 var PressureSensorStatusSchema = zod.z.object({
-	/** Current pressure in hPa. */
-	hpa: zod.z.number(),
+	/** Current pressure in hPa. `null` when the sample was refused (D393). */
+	hpa: zod.z.number().nullable().meta(readingMeta("pressure", { precision: 0 })),
 	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit from the upstream source (e.g. HA
-	*  `attributes.unit_of_measurement`). The UI prefers this over the
-	*  role's canonical unit. Absent → fall back to the canonical unit. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var pressureSensorCapability = {
 	name: "pressure-sensor",
@@ -70687,8 +71245,8 @@ var ptzCapability = {
 var AutotrackTargetTypeSchema = zod.z.string().describe("Vendor target string (people/vehicle/pet); empty = camera default");
 var PtzAutotrackSettingsSchema = zod.z.object({
 	targetType: AutotrackTargetTypeSchema,
-	stopDelaySeconds: zod.z.number().int().min(0).max(300),
-	disappearDelaySeconds: zod.z.number().int().min(0).max(300)
+	stopDelaySeconds: zod.z.number().int().min(0).max(300).meta(readingMeta("duration")),
+	disappearDelaySeconds: zod.z.number().int().min(0).max(300).meta(readingMeta("duration"))
 });
 /**
 * One option the camera advertises as a valid `targetType`. Drivers
@@ -70842,7 +71400,7 @@ var RunningStateStatusSchema = zod.z.object({
 	/** null = unknown — never coerced to false (D393). */
 	running: zod.z.boolean().nullable(),
 	/** Epoch ms the current boolean began; null while `running` is null. */
-	since: zod.z.number().nullable(),
+	since: zod.z.number().nullable().meta(readingMeta("none")),
 	source: RunningStateSourceSchema.meta({ label: "Source" }),
 	phase: zod.z.string().nullable(),
 	/** null until a reading has been published (D393). */
@@ -70857,7 +71415,6 @@ var RUNNING_DEVICE_TYPES = Object.values(DeviceType);
 /** Generic Customize target for the running boolean (D936). */
 var runningCustomize = {
 	version: 1,
-	advanced: "derive",
 	targets: [{
 		id: "running",
 		cardinality: "scalar",
@@ -70877,7 +71434,7 @@ var runningCustomize = {
 			DeviceType.Thermostat,
 			DeviceType.PetFeeder
 		],
-		apply: "add-or-replace",
+		apply: "add",
 		path: "running",
 		sources: [
 			{
@@ -72516,9 +73073,9 @@ var RecordTriggerSchema = zod.z.enum([
 */
 var RecordWindowSchema = zod.z.object({
 	trigger: RecordTriggerSchema,
-	day: zod.z.number().int().min(0).max(6),
-	startMinute: zod.z.number().int().min(0).max(1439),
-	endMinute: zod.z.number().int().min(1).max(1440)
+	day: zod.z.number().int().min(0).max(6).meta(readingMeta("none")),
+	startMinute: zod.z.number().int().min(0).max(1439).meta(readingMeta("none")),
+	endMinute: zod.z.number().int().min(1).max(1440).meta(readingMeta("none"))
 });
 /** Status of one physical volume, as the camera itself describes it. */
 var OnboardStorageVolumeSchema = zod.z.object({
@@ -72617,10 +73174,10 @@ var RecordingOnboardStatusSchema = zod.z.object({
 	/** Master "record to the card at all" switch. */
 	enabled: zod.z.boolean().nullable(),
 	overwriteWhenFull: zod.z.boolean().nullable(),
-	preRecordSec: zod.z.number().nullable(),
-	postRecordSec: zod.z.number().nullable(),
+	preRecordSec: zod.z.number().nullable().meta(readingMeta("duration")),
+	postRecordSec: zod.z.number().nullable().meta(readingMeta("duration")),
 	/** Length of one recorded file, in minutes. */
-	segmentMinutes: zod.z.number().nullable(),
+	segmentMinutes: zod.z.number().nullable().meta(readingMeta("none")),
 	/** The primary track's weekly windows, flattened. */
 	windows: zod.z.array(RecordWindowSchema),
 	/**
@@ -72636,7 +73193,7 @@ var RecordingOnboardStatusSchema = zod.z.object({
 	* provider reporting a non-zero count also reports the schedule as not
 	* writable.
 	*/
-	unreadableWindows: zod.z.number(),
+	unreadableWindows: zod.z.number().meta(readingMeta("count")),
 	/**
 	* The camera is scheduled to record and has NO usable storage.
 	*
@@ -73502,7 +74059,7 @@ var CamStreamDescriptorSchema = zod.z.object({
 	url: zod.z.string().optional(),
 	codec: zod.z.string().optional(),
 	resolution: CamStreamResolutionSchema.optional(),
-	fps: zod.z.number().positive().optional(),
+	fps: zod.z.number().positive().optional().meta(readingMeta("rate")),
 	label: zod.z.string().optional(),
 	/** Device-level features (e.g. `battery-operated`) — drives broker policy. */
 	deviceFeatures: zod.z.array(zod.z.string()).optional(),
@@ -73589,18 +74146,18 @@ var StreamProfileSchema = zod.z.enum([
 ]);
 /** The current encoding config of one stream profile. */
 var StreamProfileConfigSchema = zod.z.object({
-	width: zod.z.number(),
-	height: zod.z.number(),
+	width: zod.z.number().meta(readingMeta("none")),
+	height: zod.z.number().meta(readingMeta("none")),
 	codec: zod.z.enum(["h264", "h265"]),
-	framerate: zod.z.number(),
-	bitrate: zod.z.number(),
+	framerate: zod.z.number().meta(readingMeta("rate")),
+	bitrate: zod.z.number().meta(readingMeta("bitrate")),
 	bitrateMode: zod.z.enum(["vbr", "cbr"]).optional(),
 	encoderProfile: zod.z.enum([
 		"high",
 		"main",
 		"baseline"
 	]).optional(),
-	gop: zod.z.number().optional(),
+	gop: zod.z.number().optional().meta(readingMeta("none")),
 	/**
 	* Whether THIS profile currently carries an audio track. READ-ONLY here.
 	*
@@ -74078,12 +74635,7 @@ var switchCapability = {
 			label: "On",
 			kind: "boolean"
 		}
-	}] },
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	}] }
 };
 /** C0 controls, DEL and the C1 range: none of them belongs in a name. */
 function hasControlCharacter(value) {
@@ -74793,35 +75345,21 @@ var tamperCapability = {
 * entries with `device_class: temperature` and any future native
 * thermometer.
 *
-* Unit normalisation: providers convert to Celsius before storing.
-* The slice value is always Celsius so cross-cap aggregators
-* (climate-control's `currentTemp`, energy analytics) can compose
-* without per-source unit fixups. The canonical display unit (`°C`) is
-* a descriptor constant in the UI (ROLE_DESCRIPTOR), not stored in
-* `sourceInfo`.
+* The number is Celsius (D944). Providers convert on ingest. A failed
+* conversion is `null`, never a guess. Display unit is a read-time preference.
 *
 * Status `lastFetchedAt` lets staleness-aware consumers detect a
 * frozen feed (provider hung) distinct from a "temperature hasn't
 * changed" steady state.
 */
 var TemperatureSensorStatusSchema = zod.z.object({
-	/** Current temperature in Celsius. */
-	celsius: zod.z.number().meta({
-		unit: "°C",
+	/** Current temperature in Celsius. `null` when the sample was refused (D393). */
+	celsius: zod.z.number().nullable().meta(readingMeta("temperature", {
+		precision: 1,
 		label: "Temperature"
-	}),
+	})),
 	/** Ms epoch when the slice was last updated (push or poll). */
-	lastFetchedAt: zod.z.number(),
-	/** Live display unit from the upstream source (e.g. HA
-	*  `attributes.unit_of_measurement`). The UI prefers this over the
-	*  role's canonical unit, so a Fahrenheit feed renders '°F' not '°C'.
-	*  Absent → the UI falls back to the role's canonical unit. */
-	unit: zod.z.string().optional(),
-	/** Suggested decimal places for numeric display.
-	*  Populated live from the upstream source when provided (e.g. HA
-	*  `attributes.suggested_display_precision`). Falls back to
-	*  auto-formatting when absent. */
-	precision: zod.z.number().int().min(0).max(10).optional()
+	lastFetchedAt: zod.z.number()
 });
 var temperatureSensorCapability = {
 	name: "temperature-sensor",
@@ -74852,12 +75390,7 @@ var temperatureSensorCapability = {
 	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastFetchedAt"],
-	customize: {
-		version: 1,
-		advanced: "derive",
-		targets: []
-	}
+	volatileStateFields: ["lastFetchedAt"]
 };
 /**
 * toast — system-scoped singleton capability that streams toast
@@ -75203,16 +75736,16 @@ var VacuumControlStatusSchema = zod.z.object({
 	state: VacuumStateSchema,
 	/** 0..100 battery percentage. Null when the device has no battery
 	*  reading. */
-	batteryLevel: zod.z.number().min(0).max(100).nullable(),
+	batteryLevel: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Current fan-speed token (provider-verbatim). Null when unknown or
 	*  the vacuum has no speed control. */
 	fanSpeed: zod.z.string().nullable(),
 	/** Speed tokens the hardware accepts — drives the UI selector. */
 	availableFanSpeeds: zod.z.array(zod.z.string()),
 	/** 0..100 cleaning-completion percentage of the current task, or null. */
-	progressPercent: zod.z.number().min(0).max(100).nullable(),
+	progressPercent: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Current error code (0 / null = no error). */
-	errorCode: zod.z.number().nullable(),
+	errorCode: zod.z.number().nullable().meta(readingMeta("none")),
 	/** Human label for {@link errorCode}, or null when none / undecodable. */
 	errorLabel: zod.z.string().nullable(),
 	/** Ms epoch when the slice was last updated. */
@@ -75308,7 +75841,7 @@ var ValveStatusSchema = zod.z.object({
 	state: ValveStateSchema,
 	/** 0 = fully closed, 100 = fully open. Null when the device has no
 	*  intermediate position surface. */
-	position: zod.z.number().min(0).max(100).nullable(),
+	position: zod.z.number().min(0).max(100).nullable().meta(readingMeta("percentage")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -75416,9 +75949,9 @@ var vibrationCapability = {
 */
 var WaterHeaterStatusSchema = zod.z.object({
 	/** Current measured temperature. Null when not reported. */
-	currentTemp: zod.z.number().nullable(),
+	currentTemp: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Target temperature setpoint. Null when no setpoint surface. */
-	targetTemp: zod.z.number().nullable(),
+	targetTemp: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Active operation mode = HA `state` (`eco` / `electric` / `gas` /
 	*  `heat_pump` / `high_demand` / `performance` / `off`). Null when the
 	*  device reports an unknown state. */
@@ -75429,9 +75962,9 @@ var WaterHeaterStatusSchema = zod.z.object({
 	*  has no away surface. */
 	away: zod.z.boolean().nullable(),
 	/** HA `min_temp` attribute. Null when not reported. */
-	minTemp: zod.z.number().nullable(),
+	minTemp: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** HA `max_temp` attribute. Null when not reported. */
-	maxTemp: zod.z.number().nullable(),
+	maxTemp: zod.z.number().nullable().meta(readingMeta("temperature")),
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: zod.z.number()
 });
@@ -75516,25 +76049,18 @@ var waterHeaterCapability = {
 * Forecast deferred — current conditions only for v1.
 */
 var WeatherStatusSchema = zod.z.object({
-	/** Verbatim HA condition state (`sunny`, `cloudy`, `rainy`, …). Null
-	*  when no condition has been reported yet. */
+	/** Verbatim condition state (`sunny`, `cloudy`, `rainy`, …). Null when none yet. */
 	condition: zod.z.string().nullable(),
-	/** Current temperature in the reported unit. Null when not provided. */
-	temperature: zod.z.number().nullable(),
-	/** Temperature unit string (e.g. `°C` / `°F`). Null when not provided. */
-	temperatureUnit: zod.z.string().nullable(),
+	/** Current temperature in Celsius. Null when not provided or refused. */
+	temperature: zod.z.number().nullable().meta(readingMeta("temperature", { precision: 1 })),
 	/** Relative humidity (0..100). Null when not provided. */
-	humidity: zod.z.number().min(0).max(100).nullable(),
-	/** Barometric pressure in the reported unit. Null when not provided. */
-	pressure: zod.z.number().nullable(),
-	/** Pressure unit string (e.g. `hPa` / `inHg`). Null when not provided. */
-	pressureUnit: zod.z.string().nullable(),
-	/** Wind speed in the reported unit. Null when not provided. */
-	windSpeed: zod.z.number().nullable(),
-	/** Wind-speed unit string (e.g. `km/h` / `mph`). Null when not provided. */
-	windSpeedUnit: zod.z.string().nullable(),
+	humidity: zod.z.number().min(0).max(100).nullable().meta(readingMeta("humidity")),
+	/** Barometric pressure in hPa. Null when not provided or refused. */
+	pressure: zod.z.number().nullable().meta(readingMeta("pressure")),
+	/** Wind speed in metres per second. Null when not provided or refused. */
+	windSpeed: zod.z.number().nullable().meta(readingMeta("speed")),
 	/** Wind bearing in degrees (0..360, meteorological). Null when not provided. */
-	windBearing: zod.z.number().nullable(),
+	windBearing: zod.z.number().nullable().meta(readingMeta("angle")),
 	/** Ms epoch when the slice was last updated. */
 	lastFetchedAt: zod.z.number()
 });
@@ -75562,12 +76088,12 @@ var weatherCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): recorded series. Units follow the sibling `*Unit` fields.
+	* History (D850): recorded series. Numbers are the quantity base (D944).
 	*/
 	history: { fields: {
 		temperature: {
 			kind: "gauge",
-			unitFrom: "temperatureUnit",
+			unit: "°C",
 			deadband: .2
 		},
 		humidity: {
@@ -75577,12 +76103,12 @@ var weatherCapability = {
 		},
 		pressure: {
 			kind: "gauge",
-			unitFrom: "pressureUnit",
+			unit: "hPa",
 			deadband: .5
 		},
 		windSpeed: {
 			kind: "gauge",
-			unitFrom: "windSpeedUnit",
+			unit: "m/s",
 			deadband: .5
 		}
 	} }
@@ -76666,6 +77192,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` ⇒
@@ -76793,6 +77416,11 @@ var UNIT_TABLE = {
 		factor: 1609.344,
 		offset: 0
 	},
+	"m²": {
+		dimension: "area",
+		factor: 1,
+		offset: 0
+	},
 	lx: {
 		dimension: "illuminance",
 		factor: 1,
@@ -76897,6 +77525,121 @@ var UNIT_TABLE = {
 		dimension: "percentage",
 		factor: 1,
 		offset: 0
+	},
+	L: {
+		dimension: "volume",
+		factor: 1,
+		offset: 0
+	},
+	mL: {
+		dimension: "volume",
+		factor: .001,
+		offset: 0
+	},
+	gal: {
+		dimension: "volume",
+		factor: 3.785411784,
+		offset: 0
+	},
+	s: {
+		dimension: "duration",
+		factor: 1,
+		offset: 0
+	},
+	ms: {
+		dimension: "duration",
+		factor: .001,
+		offset: 0
+	},
+	min: {
+		dimension: "duration",
+		factor: 60,
+		offset: 0
+	},
+	h: {
+		dimension: "duration",
+		factor: 3600,
+		offset: 0
+	},
+	d: {
+		dimension: "duration",
+		factor: 86400,
+		offset: 0
+	},
+	B: {
+		dimension: "information",
+		factor: 1,
+		offset: 0
+	},
+	KiB: {
+		dimension: "information",
+		factor: 1024,
+		offset: 0
+	},
+	MiB: {
+		dimension: "information",
+		factor: 1024 ** 2,
+		offset: 0
+	},
+	GiB: {
+		dimension: "information",
+		factor: 1024 ** 3,
+		offset: 0
+	},
+	TiB: {
+		dimension: "information",
+		factor: 1024 ** 4,
+		offset: 0
+	},
+	kB: {
+		dimension: "information",
+		factor: 1e3,
+		offset: 0
+	},
+	MB: {
+		dimension: "information",
+		factor: 1e6,
+		offset: 0
+	},
+	GB: {
+		dimension: "information",
+		factor: 1e9,
+		offset: 0
+	},
+	"°": {
+		dimension: "angle",
+		factor: 1,
+		offset: 0
+	},
+	dBFS: {
+		dimension: "sound-level",
+		factor: 1,
+		offset: 0
+	},
+	dBm: {
+		dimension: "signal-level",
+		factor: 1,
+		offset: 0
+	},
+	mired: {
+		dimension: "colour-temperature",
+		factor: 1,
+		offset: 0
+	},
+	kbps: {
+		dimension: "bitrate",
+		factor: 1,
+		offset: 0
+	},
+	Mbps: {
+		dimension: "bitrate",
+		factor: 1e3,
+		offset: 0
+	},
+	fps: {
+		dimension: "rate",
+		factor: 1,
+		offset: 0
 	}
 };
 /** Resolve a unit's `UnitSpec`, or `undefined` when the spelling is unknown. */
@@ -77051,11 +77794,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,
@@ -77402,6 +78179,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	featureProbe: featureProbeCapability,
 	flood: floodCapability,
 	gas: gasCapability,
+	groupStatus: groupStatusCapability,
 	heatingValve: heatingValveCapability,
 	humidifier: humidifierCapability,
 	humiditySensor: humiditySensorCapability,
@@ -81664,6 +82442,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "viewer"
 	},
+	"groupStatus.getStatus": {
+		capName: "group-status",
+		capScope: "device",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"heatingValve.getStatus": {
 		capName: "heating-valve",
 		capScope: "device",
@@ -91486,6 +92271,33 @@ var SENSOR_CAP_VOCABULARY = {
 			icon: "flame"
 		}]
 	},
+	"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à"),
@@ -91519,7 +92331,6 @@ var SENSOR_CAP_VOCABULARY = {
 			field: "value",
 			quantity: t("the reading", "il valore"),
 			label: t("Reading", "Valore"),
-			unitField: "unit",
 			icon: "gauge"
 		}]
 	},
@@ -91655,7 +92466,7 @@ var SENSOR_CAP_VOCABULARY = {
 				field: "temperature",
 				quantity: t("the outdoor temperature", "la temperatura esterna"),
 				label: t("Temperature", "Temperatura"),
-				unitField: "temperatureUnit",
+				unit: "°C",
 				icon: "thermometer"
 			},
 			{
@@ -91671,7 +92482,7 @@ var SENSOR_CAP_VOCABULARY = {
 				field: "windSpeed",
 				quantity: t("the wind speed", "la velocità del vento"),
 				label: t("Wind", "Vento"),
-				unitField: "windSpeedUnit",
+				unit: "m/s",
 				icon: "wind"
 			},
 			{
@@ -91679,7 +92490,7 @@ var SENSOR_CAP_VOCABULARY = {
 				field: "pressure",
 				quantity: t("the air pressure", "la pressione atmosferica"),
 				label: t("Pressure", "Pressione"),
-				unitField: "pressureUnit",
+				unit: "hPa",
 				icon: "gauge"
 			}
 		]
@@ -92023,6 +92834,7 @@ var CAP_NAMES_WITH_STATUS = [
 	"feature-probe",
 	"flood",
 	"gas",
+	"group-status",
 	"heating-valve",
 	"humidifier",
 	"humidity-sensor",
@@ -92152,6 +92964,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	filesystemBrowseCapability,
 	floodCapability,
 	gasCapability,
+	groupStatusCapability,
 	heatingValveCapability,
 	humidifierCapability,
 	humiditySensorCapability,
@@ -93226,6 +94039,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"groupStatus.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"heatingValve.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -95035,7 +95853,7 @@ Object.freeze({
 });
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 72 caps: 38 `restored`, 34 `session`.
+* `runtimeState`. 73 caps: 38 `restored`, 35 `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.
@@ -95153,6 +95971,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "restored",
 		volatileFields: ["lastChangedAt"]
 	},
+	"group-status": {
+		durability: "session",
+		volatileFields: []
+	},
 	"heating-valve": {
 		durability: "session",
 		volatileFields: ["lastFetchedAt"]
@@ -95347,7 +96169,7 @@ var SESSION_ONLY_POLICY = {
 };
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 41 caps with series (74 series), 30 caps answered `'none'`.
+* 41 caps with series (75 series), 31 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -95364,12 +96186,12 @@ var HISTORY_CATALOG = {
 		},
 		"pm25": {
 			kind: "gauge",
-			unit: "ug/m3",
+			unit: "µg/m³",
 			deadband: 1
 		},
 		"pm10": {
 			kind: "gauge",
-			unit: "ug/m3",
+			unit: "µg/m³",
 			deadband: 1
 		},
 		"aqi": {
@@ -95399,10 +96221,16 @@ var HISTORY_CATALOG = {
 		deadbandPct: 10,
 		minIntervalMs: 6e4
 	} },
-	"battery": { "percentage": {
-		kind: "gauge",
-		unit: "%"
-	} },
+	"battery": {
+		"percentage": {
+			kind: "gauge",
+			unit: "%"
+		},
+		"volts": {
+			kind: "gauge",
+			unit: "V"
+		}
+	},
 	"binary": { "on": { kind: "boolean" } },
 	"brightness": { "percentage": {
 		kind: "gauge",
@@ -95486,7 +96314,7 @@ var HISTORY_CATALOG = {
 	},
 	"enum-sensor": { "value": {
 		kind: "enum",
-		skipWhenSet: "format"
+		skipWhenSet: "timestamp"
 	} },
 	"fan-control": {
 		"percentage": {
@@ -95559,7 +96387,6 @@ var HISTORY_CATALOG = {
 	},
 	"numeric-sensor": { "value": {
 		kind: "gauge",
-		unitFrom: "unit",
 		minIntervalMs: 3e4
 	} },
 	"pet-feeder": {
@@ -95573,7 +96400,7 @@ var HISTORY_CATALOG = {
 		},
 		"desiccantLeftDays": {
 			kind: "gauge",
-			unit: "days"
+			unit: "s"
 		}
 	},
 	"power-meter": {
@@ -95677,7 +96504,7 @@ var HISTORY_CATALOG = {
 	"weather": {
 		"temperature": {
 			kind: "gauge",
-			unitFrom: "temperatureUnit",
+			unit: "°C",
 			deadband: .2
 		},
 		"humidity": {
@@ -95687,12 +96514,12 @@ var HISTORY_CATALOG = {
 		},
 		"pressure": {
 			kind: "gauge",
-			unitFrom: "pressureUnit",
+			unit: "hPa",
 			deadband: .5
 		},
 		"windSpeed": {
 			kind: "gauge",
-			unitFrom: "windSpeedUnit",
+			unit: "m/s",
 			deadband: .5
 		}
 	}
@@ -95726,7 +96553,6 @@ var HISTORY_ITEM_CATALOG = { "consumables": {
 		},
 		"remaining.value": {
 			kind: "gauge",
-			unitFrom: "remaining.unit",
 			deadband: 1,
 			displayName: "Remaining"
 		}
@@ -98620,6 +99446,12 @@ Object.defineProperty(exports, "historyItemFieldPath", {
 		return historyItemFieldPath;
 	}
 });
+Object.defineProperty(exports, "historyUnitFor", {
+	enumerable: true,
+	get: function() {
+		return historyUnitFor;
+	}
+});
 Object.defineProperty(exports, "hydrateSchema", {
 	enumerable: true,
 	get: function() {
@@ -98704,6 +99536,12 @@ Object.defineProperty(exports, "isObjectInput", {
 		return isObjectInput;
 	}
 });
+Object.defineProperty(exports, "isReadingQuantity", {
+	enumerable: true,
+	get: function() {
+		return isReadingQuantity;
+	}
+});
 Object.defineProperty(exports, "isSecretClear", {
 	enumerable: true,
 	get: function() {