@camstack/addon-provider-homeassistant 1.2.625 → 1.2.627

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dist = require("./dist-oNUlRdur.js");
+const require_dist = require("./dist-CRwUHjY7.js");
 let node_crypto = require("node:crypto");
 let node_zlib = require("node:zlib");
 //#region src/ha-admin-link.ts
@@ -766,6 +766,30 @@ var HaSwitchDevice = class extends HaBaseChildDevice {
 	}
 };
 //#endregion
+//#region src/ha-reading.ts
+/**
+* Convert one sample into the quantity's base unit. A refusal publishes
+* nothing (the caller stores null) and is logged with the device id —
+* an unknown unit is never guessed (D393, D944).
+*/
+function takeReading(logger, deviceId, value, rawUnit, quantity) {
+	const result = require_dist.ingestReading({
+		value,
+		rawUnit,
+		quantity
+	});
+	if (result.ok) return result.value;
+	logger.warn("numeric reading refused", {
+		tags: { deviceId },
+		meta: {
+			quantity,
+			unit: rawUnit ?? "",
+			reason: result.reason
+		}
+	});
+	return null;
+}
+//#endregion
 //#region src/devices/ha-numeric-sensor-device.ts
 var SUPPORTED_CAP_NAMES$1 = [
 	"temperature-sensor",
@@ -782,6 +806,13 @@ var VALUE_FIELD = {
 	"pressure-sensor": "hpa",
 	"numeric-sensor": "value"
 };
+/** Typed sensors already name their quantity. The generic sensor learns it. */
+var FIXED_QUANTITY = {
+	"temperature-sensor": "temperature",
+	"humidity-sensor": "humidity",
+	"ambient-light-sensor": "illuminance",
+	"pressure-sensor": "pressure"
+};
 /**
 * Generic HA numeric-sensor child device. One class hosts every
 * single-metric numeric sensor cap (Phase B B2 + the B3 fallback)
@@ -819,15 +850,14 @@ var HaNumericSensorDevice = class extends HaBaseChildDevice {
 		this.hasStringFallback = capName === "numeric-sensor";
 		this.registerCap(capName);
 		if (this.hasStringFallback) this.registerStringFallbackCap();
-		this.runtimeState.setCapState(this.capName, this.buildSlice(0, 0, void 0, void 0));
+		this.runtimeState.setCapState(this.capName, this.buildSlice(0, 0, void 0));
 	}
 	handleStatePush(state) {
 		const value = Number(state.state);
 		const lastFetchedAt = Date.parse(state.last_updated) || Date.now();
 		if (Number.isFinite(value)) {
 			const unitRaw = typeof state.attributes["unit_of_measurement"] === "string" ? state.attributes["unit_of_measurement"] : void 0;
-			const precisionRaw = typeof state.attributes["suggested_display_precision"] === "number" ? state.attributes["suggested_display_precision"] : void 0;
-			this.runtimeState.setCapState(this.capName, this.buildSlice(value, lastFetchedAt, unitRaw, precisionRaw));
+			this.runtimeState.setCapState(this.capName, this.buildSlice(value, lastFetchedAt, unitRaw));
 			return;
 		}
 		const rawState = state.state;
@@ -839,24 +869,43 @@ var HaNumericSensorDevice = class extends HaBaseChildDevice {
 			this.runtimeState.setCapState("enum-sensor", enumSlice);
 		}
 	}
-	buildSlice(value, lastFetchedAt, unitRaw, precisionRaw) {
-		if (this.capName === "numeric-sensor") {
-			const unit = require_dist.normalizeUnit(unitRaw);
-			return {
-				value,
-				lastFetchedAt,
-				...unit !== void 0 ? { unit } : {},
-				...precisionRaw !== void 0 ? { precision: precisionRaw } : {}
-			};
-		}
-		const baseSlice = {
-			[this.valueKey]: value,
+	buildSlice(value, lastFetchedAt, unitRaw) {
+		const quantity = this.resolveQuantity(unitRaw);
+		const stored = quantity === null ? null : takeReading(this.deviceLogger, this.id, value, unitRaw, quantity);
+		if (this.capName === "numeric-sensor") return {
+			value: stored,
 			lastFetchedAt
 		};
-		const unit = require_dist.normalizeUnit(unitRaw);
-		if (unit !== void 0) baseSlice["unit"] = unit;
-		if (precisionRaw !== void 0) baseSlice["precision"] = precisionRaw;
-		return baseSlice;
+		return {
+			[this.valueKey]: stored,
+			lastFetchedAt
+		};
+	}
+	/**
+	* Typed sensors already name their quantity. A generic numeric sensor
+	* learns it once from the unit and stores it on the device, so later
+	* samples convert against the same quantity.
+	*/
+	resolveQuantity(unitRaw) {
+		const fixed = FIXED_QUANTITY[this.capName];
+		if (fixed !== void 0) return fixed;
+		const stored = this.sourceInfo.quantity;
+		if (stored !== void 0 && stored !== "device") return stored;
+		if (unitRaw === void 0) return "none";
+		const learned = require_dist.quantityFromUnit(unitRaw);
+		if (learned === void 0 || learned === "device") {
+			this.deviceLogger.warn("numeric reading refused", {
+				tags: { deviceId: this.id },
+				meta: {
+					quantity: "device",
+					unit: unitRaw,
+					reason: "unknown-unit"
+				}
+			});
+			return null;
+		}
+		this.updateSourceInfo({ quantity: learned });
+		return learned;
 	}
 	/**
 	* Register an `enum-sensor` cap backed by the same `runtimeState` so that
@@ -1615,6 +1664,22 @@ var HaClimateDevice = class extends HaBaseChildDevice {
 		if (state.state === "unavailable" || state.state === "unknown") return;
 		this.swingModes = readStringArray$4(state.attributes, "swing_modes");
 		this.swingHorizontalModes = readStringArray$4(state.attributes, "swing_horizontal_modes");
+		const unit = readStringAttr$6(state.attributes, "temperature_unit");
+		if (unit !== null) {
+			const probe = require_dist.ingestReading({
+				value: 0,
+				rawUnit: unit,
+				quantity: "temperature"
+			});
+			if (!probe.ok) this.deviceLogger.warn("numeric reading refused", {
+				tags: { deviceId: this.id },
+				meta: {
+					quantity: "temperature",
+					unit,
+					reason: probe.reason
+				}
+			});
+		}
 		this.runtimeState.setCapState("climate-control", climateSliceFromState(state));
 	}
 	registerClimateCap() {
@@ -1673,6 +1738,16 @@ function climateSliceFromState(state) {
 	const lastFetchedAt = Date.parse(state.last_updated) || Date.now();
 	const attrs = state.attributes;
 	const mode = sanitizeHvacMode(state.state);
+	const tempUnit = readStringAttr$6(attrs, "temperature_unit") ?? void 0;
+	const celsius = (raw) => {
+		if (raw === null) return null;
+		const result = require_dist.ingestReading({
+			value: raw,
+			rawUnit: tempUnit,
+			quantity: "temperature"
+		});
+		return result.ok ? result.value : null;
+	};
 	const availableModes = readStringArray$4(attrs, "hvac_modes").map(sanitizeHvacMode).filter((m) => m !== null);
 	const fanMode = readStringAttr$6(attrs, "fan_mode") ?? "";
 	const availableFanModes = readStringArray$4(attrs, "fan_modes");
@@ -1685,16 +1760,16 @@ function climateSliceFromState(state) {
 		availableFanModes,
 		preset,
 		availablePresets,
-		target: readNumberAttr$5(attrs, "temperature"),
-		targetHigh: readNumberAttr$5(attrs, "target_temp_high"),
-		targetLow: readNumberAttr$5(attrs, "target_temp_low"),
+		target: celsius(readNumberAttr$5(attrs, "temperature")),
+		targetHigh: celsius(readNumberAttr$5(attrs, "target_temp_high")),
+		targetLow: celsius(readNumberAttr$5(attrs, "target_temp_low")),
 		targetHumidity: readNumberAttr$5(attrs, "target_humidity"),
-		currentTemp: readNumberAttr$5(attrs, "current_temperature"),
+		currentTemp: celsius(readNumberAttr$5(attrs, "current_temperature")),
 		currentHumidity: readNumberAttr$5(attrs, "current_humidity"),
 		...readSwing(attrs),
-		minTemp: readNumberAttr$5(attrs, "min_temp"),
-		maxTemp: readNumberAttr$5(attrs, "max_temp"),
-		tempStep: readNumberAttr$5(attrs, "target_temp_step"),
+		minTemp: celsius(readNumberAttr$5(attrs, "min_temp")),
+		maxTemp: celsius(readNumberAttr$5(attrs, "max_temp")),
+		tempStep: celsius(readNumberAttr$5(attrs, "target_temp_step")),
 		lastFetchedAt
 	};
 }
@@ -2517,10 +2592,10 @@ function readNumberAttr$1(attrs, key) {
 *   - number / input_number   → kind='numeric',  service set_value({value})
 *   - select / input_select   → kind='select',   service select_option({option})
 *   - text / input_text       → kind='text',     service set_value({value})
-*   - date                    → kind='datetime', format='date',     set_value({date})
-*   - time                    → kind='datetime', format='time',     set_value({time})
-*   - datetime                → kind='datetime', format='datetime', set_value({datetime})
-*   - input_datetime          → kind='datetime', format derived from
+*   - date                    → kind='datetime', shape date,     set_value({date})
+*   - time                    → kind='datetime', shape time,     set_value({time})
+*   - datetime                → kind='datetime', shape datetime, set_value({datetime})
+*   - input_datetime          → kind='datetime', shape derived from
 *                               has_date/has_time, service set_datetime({datetime})
 *
 * The datetime `value` is kept as the HA-native string (date.* → 'YYYY-MM-DD',
@@ -2531,6 +2606,8 @@ function readNumberAttr$1(attrs, key) {
 var HaControlDevice = class extends HaBaseChildDevice {
 	kind;
 	haDomain;
+	/** Unit the upstream entity speaks. Writes convert the base value back to it. */
+	upstreamUnit;
 	constructor(ctx) {
 		const persisted = ctx.persistedConfig ?? {};
 		super(ctx, persisted.role !== void 0 ? { role: persisted.role } : {});
@@ -2538,18 +2615,30 @@ var HaControlDevice = class extends HaBaseChildDevice {
 		this.kind = roleToKind(persisted.role);
 		const seedOptions = Array.isArray(persisted.options) ? persisted.options.filter((x) => typeof x === "string") : [];
 		this.registerControlCap();
+		if (this.kind === "datetime") this.updateSourceInfo({ dateTimeShape: this.datetimeFormat(void 0) });
 		this.runtimeState.setCapState("control", {
 			kind: this.kind,
 			value: this.kind === "numeric" ? 0 : "",
 			options: seedOptions,
-			lastChangedAt: 0,
-			...this.kind === "datetime" ? { format: this.datetimeFormat(void 0) } : {}
+			lastChangedAt: 0
 		});
 	}
 	handleStatePush(state) {
 		if (state.state === "unavailable" || state.state === "unknown") return;
 		const lastChangedAt = Date.parse(state.last_changed) || Date.now();
-		const slice = decodeControlSlice(this.kind, state, lastChangedAt, () => this.datetimeFormat(state.attributes));
+		const slice = decodeControlSlice(this.kind, state, lastChangedAt, {
+			logger: this.deviceLogger,
+			deviceId: this.id,
+			quantity: this.sourceInfo.quantity,
+			note: (quantity, unit) => {
+				this.upstreamUnit = unit;
+				if (this.sourceInfo.quantity !== quantity) this.updateSourceInfo({ quantity });
+			},
+			noteShape: (shape) => {
+				if (this.sourceInfo.dateTimeShape !== shape) this.updateSourceInfo({ dateTimeShape: shape });
+			},
+			shape: () => this.datetimeFormat(state.attributes)
+		});
 		if (slice !== null) this.runtimeState.setCapState("control", slice);
 	}
 	registerControlCap() {
@@ -2559,8 +2648,7 @@ var HaControlDevice = class extends HaBaseChildDevice {
 					kind: this.kind,
 					value: this.kind === "numeric" ? 0 : "",
 					options: [],
-					lastChangedAt: 0,
-					...this.kind === "datetime" ? { format: this.datetimeFormat(void 0) } : {}
+					lastChangedAt: 0
 				};
 			},
 			setValue: async ({ control }) => {
@@ -2590,11 +2678,32 @@ var HaControlDevice = class extends HaBaseChildDevice {
 			default: return "datetime";
 		}
 	}
+	/** Base-unit value → the unit the upstream entity still speaks. */
+	toUpstream(value) {
+		const quantity = this.sourceInfo.quantity;
+		const base = quantity === void 0 ? void 0 : require_dist.baseUnitOf(quantity);
+		const upstream = this.upstreamUnit;
+		if (base === void 0 || upstream === void 0 || upstream === base) return value;
+		const converted = require_dist.tryConvertUnit(value, base, upstream);
+		if (converted !== void 0) return converted;
+		this.deviceLogger.warn("numeric reading refused", {
+			tags: { deviceId: this.id },
+			meta: {
+				quantity: quantity ?? "device",
+				unit: upstream,
+				reason: "unknown-unit"
+			}
+		});
+		return null;
+	}
 	async dispatchSet(control) {
 		switch (control.kind) {
-			case "numeric":
-				await this.callHaService(this.haDomain, "set_value", { value: control.value });
+			case "numeric": {
+				const outbound = this.toUpstream(control.value);
+				if (outbound === null) return;
+				await this.callHaService(this.haDomain, "set_value", { value: outbound });
 				return;
+			}
 			case "select":
 				await this.callHaService(this.haDomain, "select_option", { option: control.value });
 				return;
@@ -2643,47 +2752,9 @@ function roleToKind(role) {
 		default: return "text";
 	}
 }
-/**
-* Derive display precision from a numeric step value when HA does not provide
-* `suggested_display_precision` explicitly. Returns the number of decimal
-* places implied by the step granularity (e.g. 0.5 → 1, 0.01 → 2, 1 → 0).
-* Returns `undefined` when step is absent or is a whole number (let the UI
-* apply its own auto-formatting for integer steps).
-*/
-function precisionFromStep(step) {
-	if (step === void 0 || step <= 0) return void 0;
-	if (Number.isInteger(step)) return 0;
-	const str = step.toString();
-	const dotIndex = str.indexOf(".");
-	if (dotIndex === -1) return 0;
-	return str.length - dotIndex - 1;
-}
-function decodeControlSlice(kind, state, lastChangedAt, resolveFormat) {
+function decodeControlSlice(kind, state, lastChangedAt, decode) {
 	switch (kind) {
-		case "numeric": {
-			const v = Number(state.state);
-			if (!Number.isFinite(v)) return null;
-			const rawUnit = state.attributes["unit_of_measurement"];
-			const rawMin = state.attributes["min"];
-			const rawMax = state.attributes["max"];
-			const rawStep = state.attributes["step"];
-			const rawPrecision = state.attributes["suggested_display_precision"];
-			const unit = typeof rawUnit === "string" && rawUnit.length > 0 ? rawUnit : void 0;
-			const min = typeof rawMin === "number" && Number.isFinite(rawMin) ? rawMin : void 0;
-			const max = typeof rawMax === "number" && Number.isFinite(rawMax) ? rawMax : void 0;
-			const step = typeof rawStep === "number" && Number.isFinite(rawStep) && rawStep > 0 ? rawStep : void 0;
-			return {
-				kind: "numeric",
-				value: v,
-				options: [],
-				lastChangedAt,
-				unit,
-				min,
-				max,
-				step,
-				precision: typeof rawPrecision === "number" && Number.isFinite(rawPrecision) ? rawPrecision : precisionFromStep(step)
-			};
-		}
+		case "numeric": return decodeNumeric(state, lastChangedAt, decode);
 		case "select": {
 			const options = Array.isArray(state.attributes["options"]) ? state.attributes["options"].filter((x) => typeof x === "string") : [];
 			return {
@@ -2699,14 +2770,72 @@ function decodeControlSlice(kind, state, lastChangedAt, resolveFormat) {
 			options: [],
 			lastChangedAt
 		};
-		case "datetime": return {
-			kind: "datetime",
-			value: state.state,
-			options: [],
-			lastChangedAt,
-			format: resolveFormat()
-		};
+		case "datetime":
+			decode.noteShape(decode.shape());
+			return {
+				kind: "datetime",
+				value: state.state,
+				options: [],
+				lastChangedAt
+			};
+	}
+}
+function decodeNumeric(state, lastChangedAt, decode) {
+	const v = Number(state.state);
+	if (!Number.isFinite(v)) return null;
+	const rawUnit = state.attributes["unit_of_measurement"];
+	const unit = typeof rawUnit === "string" && rawUnit.length > 0 ? rawUnit : void 0;
+	const incoming = unit === void 0 ? void 0 : require_dist.quantityFromUnit(unit);
+	if (unit !== void 0 && (incoming === void 0 || incoming === "device")) {
+		decode.logger.warn("numeric reading refused", {
+			tags: { deviceId: decode.deviceId },
+			meta: {
+				quantity: "device",
+				unit,
+				reason: "unknown-unit"
+			}
+		});
+		return null;
 	}
+	const stored = decode.quantity;
+	const quantity = stored !== void 0 && stored !== "device" ? stored : incoming ?? "none";
+	if (incoming !== void 0 && incoming !== "device" && incoming !== quantity) {
+		decode.logger.warn("numeric reading refused", {
+			tags: { deviceId: decode.deviceId },
+			meta: {
+				quantity,
+				unit: unit ?? "",
+				reason: "cross-dimension"
+			}
+		});
+		return null;
+	}
+	const value = takeReading(decode.logger, decode.deviceId, v, unit, quantity);
+	if (value === null) return null;
+	decode.note(quantity, unit === void 0 ? void 0 : require_dist.normalizeUnit(unit));
+	const rawMin = state.attributes["min"];
+	const rawMax = state.attributes["max"];
+	const rawStep = state.attributes["step"];
+	const min = typeof rawMin === "number" ? takeReading(decode.logger, decode.deviceId, rawMin, unit, quantity) : void 0;
+	const max = typeof rawMax === "number" ? takeReading(decode.logger, decode.deviceId, rawMax, unit, quantity) : void 0;
+	const step = convertStep(typeof rawStep === "number" && rawStep > 0 ? rawStep : void 0, unit, quantity);
+	return {
+		kind: "numeric",
+		value,
+		options: [],
+		lastChangedAt,
+		...min !== void 0 && min !== null ? { min } : {},
+		...max !== void 0 && max !== null ? { max } : {},
+		...step !== void 0 ? { step } : {}
+	};
+}
+/** A step is a difference: °F's offset must not move it. */
+function convertStep(step, unit, quantity) {
+	if (step === void 0) return void 0;
+	const base = require_dist.baseUnitOf(quantity);
+	const from = unit === void 0 ? void 0 : require_dist.normalizeUnit(unit);
+	if (base === void 0 || from === void 0 || from === base) return step;
+	return require_dist.tryConvertDelta(step, from, base);
 }
 //#endregion
 //#region src/devices/ha-script-device.ts
@@ -2952,15 +3081,15 @@ var HaPowerMeterDevice = class extends HaBaseChildDevice {
 		const value = Number(state.state);
 		if (!Number.isFinite(value)) return;
 		const lastFetchedAt = Date.parse(state.last_updated) || Date.now();
-		const deviceClass = typeof state.attributes["device_class"] === "string" ? state.attributes["device_class"] : this.haDeviceClass;
-		const unit = require_dist.normalizeUnit(typeof state.attributes["unit_of_measurement"] === "string" ? state.attributes["unit_of_measurement"] : void 0);
-		const precision = typeof state.attributes["suggested_display_precision"] === "number" ? state.attributes["suggested_display_precision"] : void 0;
-		const update = applyDeviceClass$1(this.runtimeState.getCapState("power-meter") ?? COLD_START$4, deviceClass, value, lastFetchedAt);
-		if (update !== null) this.runtimeState.setCapState("power-meter", {
-			...update,
-			...unit !== void 0 ? { unit } : {},
-			...precision !== void 0 ? { precision } : {}
-		});
+		const deviceClassRaw = state.attributes["device_class"];
+		const deviceClass = typeof deviceClassRaw === "string" ? deviceClassRaw : this.haDeviceClass;
+		const quantity = powerQuantity(deviceClass);
+		if (quantity === void 0) return;
+		const unitRaw = state.attributes["unit_of_measurement"];
+		const stored = takeReading(this.deviceLogger, this.id, value, typeof unitRaw === "string" ? unitRaw : void 0, quantity);
+		if (stored === null) return;
+		const update = applyDeviceClass$1(this.runtimeState.getCapState("power-meter") ?? COLD_START$4, deviceClass, stored, lastFetchedAt);
+		if (update !== null) this.runtimeState.setCapState("power-meter", update);
 	}
 	registerPowerMeterCap() {
 		this.ctx.registerNativeCap(require_dist.powerMeterCapability, { getStatus: async () => {
@@ -2968,6 +3097,15 @@ var HaPowerMeterDevice = class extends HaBaseChildDevice {
 		} });
 	}
 };
+function powerQuantity(deviceClass) {
+	switch (deviceClass) {
+		case "power": return "power";
+		case "energy": return "energy";
+		case "voltage": return "voltage";
+		case "current": return "current";
+		default: return;
+	}
+}
 function applyDeviceClass$1(prev, deviceClass, value, lastFetchedAt) {
 	switch (deviceClass) {
 		case "power": return {
@@ -3022,15 +3160,15 @@ var HaAirQualityDevice = class extends HaBaseChildDevice {
 		const value = Number(state.state);
 		if (!Number.isFinite(value)) return;
 		const lastFetchedAt = Date.parse(state.last_updated) || Date.now();
-		const deviceClass = typeof state.attributes["device_class"] === "string" ? state.attributes["device_class"] : null;
-		const unit = require_dist.normalizeUnit(typeof state.attributes["unit_of_measurement"] === "string" ? state.attributes["unit_of_measurement"] : void 0);
-		const precision = typeof state.attributes["suggested_display_precision"] === "number" ? state.attributes["suggested_display_precision"] : void 0;
-		const update = applyDeviceClass(this.runtimeState.getCapState("air-quality-sensor") ?? COLD_START$3, deviceClass, value, lastFetchedAt);
-		if (update !== null) this.runtimeState.setCapState("air-quality-sensor", {
-			...update,
-			...unit !== void 0 ? { unit } : {},
-			...precision !== void 0 ? { precision } : {}
-		});
+		const deviceClassRaw = state.attributes["device_class"];
+		const deviceClass = typeof deviceClassRaw === "string" ? deviceClassRaw : null;
+		const quantity = airQuantity(deviceClass);
+		if (quantity === void 0) return;
+		const unitRaw = state.attributes["unit_of_measurement"];
+		const stored = takeReading(this.deviceLogger, this.id, value, typeof unitRaw === "string" ? unitRaw : void 0, quantity);
+		if (stored === null) return;
+		const update = applyDeviceClass(this.runtimeState.getCapState("air-quality-sensor") ?? COLD_START$3, deviceClass, stored, lastFetchedAt);
+		if (update !== null) this.runtimeState.setCapState("air-quality-sensor", update);
 	}
 	registerCap() {
 		this.ctx.registerNativeCap(require_dist.airQualitySensorCapability, { getStatus: async () => {
@@ -3038,6 +3176,17 @@ var HaAirQualityDevice = class extends HaBaseChildDevice {
 		} });
 	}
 };
+function airQuantity(deviceClass) {
+	switch (deviceClass) {
+		case "co2": return "concentration-volume";
+		case "volatile_organic_compounds": return "concentration-ppb";
+		case "pm25":
+		case "pm2_5":
+		case "pm10": return "concentration-mass";
+		case "aqi": return "index";
+		default: return;
+	}
+}
 function applyDeviceClass(prev, deviceClass, value, lastFetchedAt) {
 	switch (deviceClass) {
 		case "co2": return {
@@ -3089,9 +3238,9 @@ var HaEnumSensorDevice = class extends HaBaseChildDevice {
 	/**
 	* Locale-render shape for a `DateTimeSensor`-role sensor (HA
 	* `device_class=timestamp` → `'datetime'`, `date` → `'date'`). Read from the
-	* persisted child config (threaded by the HA mapping) and seeded into the cap
-	* slice alongside `value` so the UI renders the ISO string locale-formatted.
-	* `undefined` for a plain enum sensor — the slice then omits `format`.
+	* persisted child config (threaded by the HA mapping) and stored once on the
+	* device. A timestamp sensor marks the slice so history does not learn the
+	* ISO string as an enum state.
 	*/
 	dateTimeFormat;
 	constructor(ctx) {
@@ -3099,15 +3248,14 @@ var HaEnumSensorDevice = class extends HaBaseChildDevice {
 		super(ctx, persisted.role !== void 0 ? { role: persisted.role } : {});
 		const parsedFormat = require_dist.EnumSensorDateTimeFormatSchema.safeParse(persisted.dateTimeFormat);
 		this.dateTimeFormat = parsedFormat.success ? parsedFormat.data : void 0;
+		if (this.dateTimeFormat !== void 0) this.updateSourceInfo({ dateTimeShape: this.dateTimeFormat });
 		this.registerCap();
 		this.runtimeState.setCapState("enum-sensor", this.coldStart());
 	}
-	/** Cold-start slice — carries the format up-front so the UI can render the
-	*  correct shape the instant a value lands, with no slice churn. */
 	coldStart() {
 		return {
 			...COLD_START$2,
-			...this.dateTimeFormat !== void 0 ? { format: this.dateTimeFormat } : {}
+			...this.dateTimeFormat !== void 0 ? { timestamp: true } : {}
 		};
 	}
 	handleStatePush(state) {
@@ -3115,7 +3263,7 @@ var HaEnumSensorDevice = class extends HaBaseChildDevice {
 		const lastFetchedAt = Date.parse(state.last_updated) || Date.now();
 		this.runtimeState.setCapState("enum-sensor", {
 			value: state.state,
-			...this.dateTimeFormat !== void 0 ? { format: this.dateTimeFormat } : {},
+			...this.dateTimeFormat !== void 0 ? { timestamp: true } : {},
 			lastFetchedAt
 		});
 	}
@@ -3272,12 +3420,9 @@ function readEventTypesFromAttributes(attributes) {
 var COLD_START$1 = {
 	condition: null,
 	temperature: null,
-	temperatureUnit: null,
 	humidity: null,
 	pressure: null,
-	pressureUnit: null,
 	windSpeed: null,
-	windSpeedUnit: null,
 	windBearing: null,
 	lastFetchedAt: 0
 };
@@ -3309,13 +3454,10 @@ var HaWeatherDevice = class extends HaBaseChildDevice {
 		const attrs = state.attributes;
 		const slice = {
 			condition: state.state,
-			temperature: readNumberAttr(attrs, "temperature"),
-			temperatureUnit: readStringAttr$1(attrs, "temperature_unit"),
+			temperature: this.readBase(attrs, "temperature", "temperature_unit", "temperature"),
 			humidity: clampOrNull(readNumberAttr(attrs, "humidity"), 0, 100),
-			pressure: readNumberAttr(attrs, "pressure"),
-			pressureUnit: readStringAttr$1(attrs, "pressure_unit"),
-			windSpeed: readNumberAttr(attrs, "wind_speed"),
-			windSpeedUnit: readStringAttr$1(attrs, "wind_speed_unit"),
+			pressure: this.readBase(attrs, "pressure", "pressure_unit", "pressure"),
+			windSpeed: this.readBase(attrs, "wind_speed", "wind_speed_unit", "speed"),
 			windBearing: readNumberAttr(attrs, "wind_bearing"),
 			lastFetchedAt
 		};
@@ -3326,6 +3468,13 @@ var HaWeatherDevice = class extends HaBaseChildDevice {
 			return this.runtimeState.getCapState("weather") ?? COLD_START$1;
 		} });
 	}
+	/** One weather attribute, converted into the quantity's base unit. */
+	readBase(attrs, valueKey, unitKey, quantity) {
+		const raw = readNumberAttr(attrs, valueKey);
+		if (raw === null) return null;
+		const unit = readStringAttr$1(attrs, unitKey);
+		return takeReading(this.deviceLogger, this.id, raw, unit ?? void 0, quantity);
+	}
 };
 function readNumberAttr(attrs, key) {
 	const v = attrs[key];