@camstack/types 1.2.445 → 1.2.447

package/dist/index.js

@@ -8060,6 +8060,791 @@ var ExpressionSourceSchema = zod.z.object({
 	});
 });
 //#endregion
+//#region src/device/schema-fields.ts
+/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
+*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
+function unwrapSchema(schema) {
+	let s = 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) && require_sleep.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 {
+		kind: "enum",
+		enumValues: s.options
+	};
+	if (s instanceof zod.z.ZodNumber) return { kind: "number" };
+	if (s instanceof zod.z.ZodString) return { kind: "string" };
+	if (s instanceof zod.z.ZodBoolean) return { kind: "boolean" };
+	return null;
+}
+/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
+*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
+*  so fields with null live values are still offered. Arrays / unknown shapes
+*  are skipped — never throws. */
+function enumerateSchemaFields(schema, prefix = "") {
+	const root = unwrapSchema(schema);
+	if (!(root instanceof zod.z.ZodObject)) return [];
+	const out = [];
+	const shape = root.shape;
+	for (const [key, field] of Object.entries(shape)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		const inner = unwrapSchema(field);
+		if (inner instanceof zod.z.ZodObject) {
+			out.push(...enumerateSchemaFields(inner, path));
+			continue;
+		}
+		const leaf = leafKind(field);
+		if (leaf) {
+			const quantity = quantityOfField(field);
+			out.push({
+				path,
+				kind: leaf.kind,
+				...leaf.enumValues ? { enumValues: leaf.enumValues } : {},
+				...quantity !== void 0 ? { quantity } : {}
+			});
+		}
+	}
+	return out;
+}
+/** Enumerate the per-item wireable fields of an item-array cap (see
+*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
+*  `keyField` (the key comes from the link's `itemKey`, never from a wired
+*  source), each tagged `item: true` so the authoring UI collects an
+*  `itemKey` alongside the field. Never throws. */
+function enumerateItemArrayFields(itemArray) {
+	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
+		...f,
+		item: true
+	}));
+}
+//#endregion
+//#region src/device/source-info.ts
+/**
+* Identity envelope for a device's upstream-system metadata.
+*
+* Two jobs:
+*
+*   1. **Dispatch key.** `id` is the natural identifier the SOURCE system
+*      uses to address this device (HA `entity_id`, Reolink MAC, ONVIF
+*      WS-Discovery endpoint UUID, …). Provider code keeps a
+*      `Map<sourceInfo.id, IDevice>` to route inbound push events in O(1)
+*      without round-tripping through `stableId` / `id` mappings.
+*
+*   2. **Stability bridge.** `uniqueId` is the *immutable* upstream id when
+*      one exists (HA `entity.unique_id`, Reolink MAC again — same as `id`
+*      for vendors where MAC is the natural key). For systems where the
+*      live dispatch key can be renamed (HA `entity_id` can be edited),
+*      providers detect renames by matching `uniqueId` and patch `id`
+*      in-place so dispatch keeps working.
+*
+* **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`
+* details, …). Providers control what lands here.
+*/
+var SourceInfoSchema = zod.z.object({
+	/** Live dispatch key — mutable when the source system allows rename. */
+	id: zod.z.string(),
+	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
+	system: zod.z.string(),
+	/** 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: require_sleep.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). */
+	raw: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+/**
+* Build the synthetic SourceInfo every existing provider falls back to
+* when no upstream value has been persisted. Keeps non-migrated providers
+* (Reolink / Hikvision / ONVIF / RTSP) functional without code
+* changes — `id` reuses the CamStack stableId, `system` reuses the addon
+* id. Real upstream identity replaces this once a provider migrates and
+* calls `updateSourceInfo()` with concrete values.
+*/
+function synthesizeSourceInfo(input) {
+	return {
+		id: input.stableId,
+		system: input.addonId
+	};
+}
+/**
+* Shallow-merge a partial patch over a prior SourceInfo. `undefined`
+* patch values are ignored (no field clobber); to clear a field
+* explicitly, providers omit it from the patch and rebuild from scratch
+* via `updateSourceInfo({})` cycles — uncommon enough that we don't
+* bother with a `null`-means-delete sentinel.
+*
+* The `raw` field is also shallow-merged: passing `raw: { foo: 1 }`
+* merges over existing `raw` keys instead of replacing the whole bag.
+*/
+function mergeSourceInfo(prev, patch) {
+	const next = { ...prev };
+	for (const [k, v] of Object.entries(patch)) {
+		if (v === void 0) continue;
+		if (k === "raw" && typeof v === "object" && v !== null) {
+			next.raw = {
+				...prev.raw,
+				...v
+			};
+			continue;
+		}
+		next[k] = v;
+	}
+	return next;
+}
+/**
+* Coerce common unit-of-measurement string variants to a canonical form
+* so the UI's display templates can rely on stable strings. Pure
+* passthrough for unknown units — kept conservative on purpose, the goal
+* is to normalise the long tail of HA `unit_of_measurement` values that
+* have multiple historical spellings (`'°C'` vs `'C'` vs `'celsius'`).
+*
+* Extend the map as we encounter real-world data. Returning the raw
+* input for unknown values is intentional: providers should never
+* lose information silently here.
+*/
+function normalizeUnit(raw) {
+	if (raw == null) return void 0;
+	const trimmed = raw.trim();
+	if (trimmed === "") return void 0;
+	const lower = trimmed.toLowerCase();
+	if (lower === "°c" || lower === "c" || lower === "celsius") return "°C";
+	if (lower === "°f" || lower === "f" || lower === "fahrenheit") return "°F";
+	if (lower === "k" || lower === "kelvin") return "K";
+	if (lower === "%" || lower === "percent" || lower === "percentage") return "%";
+	if (lower === "lx" || lower === "lux") return "lx";
+	if (lower === "hpa" || lower === "hectopascal") return "hPa";
+	if (lower === "kpa") return "kPa";
+	if (lower === "pa") return "Pa";
+	if (lower === "mbar" || lower === "millibar") return "mbar";
+	if (lower === "w" || lower === "watt") return "W";
+	if (lower === "kw" || lower === "kilowatt") return "kW";
+	if (lower === "wh" || lower === "watt-hour") return "Wh";
+	if (lower === "kwh" || lower === "kilowatt-hour") return "kWh";
+	if (lower === "v" || lower === "volt") return "V";
+	if (lower === "a" || lower === "amp" || lower === "ampere") return "A";
+	if (lower === "ma" || lower === "milliampere") return "mA";
+	if (lower === "va") return "VA";
+	if (lower === "ppm") return "ppm";
+	if (lower === "ppb") return "ppb";
+	if (lower === "µg/m³" || lower === "ug/m3" || lower === "µg/m3") return "µg/m³";
+	if (lower === "km/h" || lower === "kph") return "km/h";
+	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;
+}
+/**
+* Key under which `SourceInfo` lives inside `DeviceMeta.metadata`. The
+* blob is a free-form `Record<string, unknown>` shared with hardware-
+* identity fields (`manufacturer`, `model`, `firmware`, …); SourceInfo
+* lives under a single nested key to keep it composable with those.
+*/
+var SOURCE_INFO_METADATA_KEY = "sourceInfo";
+/**
+* Extract a SourceInfo from a `DeviceMeta.metadata` blob, validating
+* with Zod. Returns `null` when the blob is missing or the nested
+* `sourceInfo` key fails validation — callers fall back to the
+* synthetic default in that case (see `synthesizeSourceInfo`).
+*/
+function extractSourceInfoFromMetadata(metadata) {
+	if (!metadata) return null;
+	const raw = metadata[SOURCE_INFO_METADATA_KEY];
+	if (!raw) return null;
+	const parsed = SourceInfoSchema.safeParse(raw);
+	if (!parsed.success) return null;
+	return parsed.data;
+}
+//#endregion
+//#region src/units/unit-table.ts
+/**
+* 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` ⇒
+* `factor = 5/9`, `offset = -160/9` (kept as exact expressions, not rounded
+* decimals). K derives from `°C = K − 273.15`.
+*/
+var UNIT_TABLE = {
+	"°C": {
+		dimension: "temperature",
+		factor: 1,
+		offset: 0
+	},
+	"°F": {
+		dimension: "temperature",
+		factor: 5 / 9,
+		offset: -160 / 9
+	},
+	K: {
+		dimension: "temperature",
+		factor: 1,
+		offset: -273.15
+	},
+	hPa: {
+		dimension: "pressure",
+		factor: 1,
+		offset: 0
+	},
+	kPa: {
+		dimension: "pressure",
+		factor: 10,
+		offset: 0
+	},
+	Pa: {
+		dimension: "pressure",
+		factor: .01,
+		offset: 0
+	},
+	mbar: {
+		dimension: "pressure",
+		factor: 1,
+		offset: 0
+	},
+	bar: {
+		dimension: "pressure",
+		factor: 1e3,
+		offset: 0
+	},
+	inHg: {
+		dimension: "pressure",
+		factor: 33.8639,
+		offset: 0
+	},
+	mmHg: {
+		dimension: "pressure",
+		factor: 1.33322,
+		offset: 0
+	},
+	psi: {
+		dimension: "pressure",
+		factor: 68.9476,
+		offset: 0
+	},
+	"m/s": {
+		dimension: "speed",
+		factor: 1,
+		offset: 0
+	},
+	"km/h": {
+		dimension: "speed",
+		factor: 1 / 3.6,
+		offset: 0
+	},
+	mph: {
+		dimension: "speed",
+		factor: .44704,
+		offset: 0
+	},
+	kn: {
+		dimension: "speed",
+		factor: .514444,
+		offset: 0
+	},
+	"mm/h": {
+		dimension: "precipitation-rate",
+		factor: 1,
+		offset: 0
+	},
+	"in/h": {
+		dimension: "precipitation-rate",
+		factor: 25.4,
+		offset: 0
+	},
+	m: {
+		dimension: "length",
+		factor: 1,
+		offset: 0
+	},
+	mm: {
+		dimension: "length",
+		factor: .001,
+		offset: 0
+	},
+	cm: {
+		dimension: "length",
+		factor: .01,
+		offset: 0
+	},
+	km: {
+		dimension: "length",
+		factor: 1e3,
+		offset: 0
+	},
+	in: {
+		dimension: "length",
+		factor: .0254,
+		offset: 0
+	},
+	ft: {
+		dimension: "length",
+		factor: .3048,
+		offset: 0
+	},
+	mi: {
+		dimension: "length",
+		factor: 1609.344,
+		offset: 0
+	},
+	"m²": {
+		dimension: "area",
+		factor: 1,
+		offset: 0
+	},
+	lx: {
+		dimension: "illuminance",
+		factor: 1,
+		offset: 0
+	},
+	"W/m²": {
+		dimension: "irradiance",
+		factor: 1,
+		offset: 0
+	},
+	W: {
+		dimension: "power",
+		factor: 1,
+		offset: 0
+	},
+	kW: {
+		dimension: "power",
+		factor: 1e3,
+		offset: 0
+	},
+	VA: {
+		dimension: "apparent-power",
+		factor: 1,
+		offset: 0
+	},
+	Wh: {
+		dimension: "energy",
+		factor: 1,
+		offset: 0
+	},
+	kWh: {
+		dimension: "energy",
+		factor: 1e3,
+		offset: 0
+	},
+	MWh: {
+		dimension: "energy",
+		factor: 1e6,
+		offset: 0
+	},
+	V: {
+		dimension: "voltage",
+		factor: 1,
+		offset: 0
+	},
+	mV: {
+		dimension: "voltage",
+		factor: .001,
+		offset: 0
+	},
+	A: {
+		dimension: "current",
+		factor: 1,
+		offset: 0
+	},
+	mA: {
+		dimension: "current",
+		factor: .001,
+		offset: 0
+	},
+	ppm: {
+		dimension: "concentration-volume",
+		factor: 1,
+		offset: 0
+	},
+	ppb: {
+		dimension: "concentration-volume",
+		factor: .001,
+		offset: 0
+	},
+	"µg/m³": {
+		dimension: "concentration-mass",
+		factor: 1,
+		offset: 0
+	},
+	"mg/m³": {
+		dimension: "concentration-mass",
+		factor: 1e3,
+		offset: 0
+	},
+	kg: {
+		dimension: "mass",
+		factor: 1,
+		offset: 0
+	},
+	g: {
+		dimension: "mass",
+		factor: .001,
+		offset: 0
+	},
+	lb: {
+		dimension: "mass",
+		factor: .453592,
+		offset: 0
+	},
+	oz: {
+		dimension: "mass",
+		factor: .0283495,
+		offset: 0
+	},
+	"%": {
+		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
+	}
+};
+//#endregion
+//#region src/units/convert.ts
+/**
+* Pure unit-conversion API over `UNIT_TABLE`. No dependencies, no side effects.
+*
+* Conversion is refused (throws `UnitConversionError`, or returns `undefined`
+* from the `try*` variant) whenever a unit is unknown or the two units belong
+* to different dimensions — cross-dimension conversion is deliberately
+* impossible so a render override can never make the value and its unit label
+* disagree.
+*
+* Callers pass units through `normalizeUnit` (`../device/source-info.ts`) BEFORE
+* calling here — the table keys only canonical spellings.
+*/
+/** Thrown by `convertUnit` when a conversion is refused. Carries the offending
+*  units + a machine-readable `reason` for callers that branch on the cause. */
+var UnitConversionError = class extends Error {
+	from;
+	to;
+	reason;
+	constructor(from, to, reason) {
+		super(`[units] cannot convert '${from}' → '${to}': ${reason}`);
+		this.name = "UnitConversionError";
+		this.from = from;
+		this.to = to;
+		this.reason = reason;
+	}
+};
+/** Resolve a unit's `UnitSpec`, or `undefined` when the spelling is unknown. */
+function specFor(unit) {
+	return Object.hasOwn(UNIT_TABLE, unit) ? UNIT_TABLE[unit] : void 0;
+}
+/** The dimension a unit belongs to, or `undefined` for an unknown unit. */
+function unitDimension(unit) {
+	return specFor(unit)?.dimension;
+}
+/** Value in `spec`'s unit → its dimension's canonical unit. */
+function toCanonical(value, spec) {
+	return value * spec.factor + spec.offset;
+}
+/** Canonical-unit value → the unit described by `spec`. */
+function fromCanonical(canonical, spec) {
+	return (canonical - spec.offset) / spec.factor;
+}
+/**
+* Convert `value` from unit `from` to unit `to`. Identity when `from === to`.
+* Throws `UnitConversionError` when either unit is unknown or the units belong
+* to different dimensions.
+*/
+function convertUnit(value, from, to) {
+	if (from === to) return value;
+	const fromSpec = specFor(from);
+	if (!fromSpec) throw new UnitConversionError(from, to, "unknown-from");
+	const toSpec = specFor(to);
+	if (!toSpec) throw new UnitConversionError(from, to, "unknown-to");
+	if (fromSpec.dimension !== toSpec.dimension) throw new UnitConversionError(from, to, "cross-dimension");
+	return fromCanonical(toCanonical(value, fromSpec), toSpec);
+}
+/**
+* Graceful variant for the render path: returns the converted value, or
+* `undefined` when the conversion is refused (unknown unit / cross-dimension).
+* Never throws — a render caller falls back to the raw value + source unit.
+*/
+function tryConvertUnit(value, from, to) {
+	if (from === to) return value;
+	const fromSpec = specFor(from);
+	if (!fromSpec) return void 0;
+	const toSpec = specFor(to);
+	if (!toSpec) return void 0;
+	if (fromSpec.dimension !== toSpec.dimension) return void 0;
+	return fromCanonical(toCanonical(value, fromSpec), toSpec);
+}
+/**
+* Whether `value` can be converted between `from` and `to` (same dimension,
+* both known). Cheap boolean probe for the UI's same-dimension unit picker and
+* the resolver's convertibility branch — compute ONCE so a unit label and its
+* value math can never disagree.
+*/
+function canConvertUnit(from, to) {
+	if (from === to) return true;
+	const fromDim = unitDimension(from);
+	if (fromDim === void 0) return false;
+	return fromDim === unitDimension(to);
+}
+/**
+* Every known unit spelling in a dimension (table insertion order — canonical
+* unit first). Powers the UI's same-dimension unit picker.
+*/
+/**
+* Convert a difference, not a reading. Affine units (°F) shift an absolute
+* value by their offset; a step of 1°F is 5/9°C, so the offset is cancelled.
+*/
+function tryConvertDelta(value, from, to) {
+	if (from === to) return value;
+	const origin = tryConvertUnit(0, from, to);
+	const shifted = tryConvertUnit(value, from, to);
+	if (origin === void 0 || shifted === void 0) return void 0;
+	return shifted - origin;
+}
+function unitsForDimension(dimension) {
+	const out = [];
+	for (const [unit, spec] of Object.entries(UNIT_TABLE)) if (spec.dimension === dimension) out.push(unit);
+	return out;
+}
+//#endregion
+//#region src/units/quantity-input.ts
+/**
+* A number a person types for a physical quantity — the input side of the
+* value + unit contract (D972).
+*
+* Readings are stored in the base unit of their quantity (D944); a cap method
+* param is stored in the unit its input schema DECLARES (`paramMeta`). The
+* wire pair {@link QuantityValue} says "this number is expressed in this
+* unit"; {@link convertQuantityInput} brings it to the stored unit and refuses,
+* with a typed {@link QuantityUnitError}, a unit that cannot be that quantity.
+*/
+/** A unit that cannot be applied to the number it was given with. */
+var QuantityUnitError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(`[${code}] ${message}`);
+		this.name = "QuantityUnitError";
+		this.code = code;
+	}
+};
+/** The wire pair: `value` is expressed in `unit`. */
+var QuantityValueSchema = zod.z.object({
+	value: zod.z.number(),
+	unit: zod.z.string().min(1)
+});
+function isQuantityValue(candidate) {
+	return QuantityValueSchema.safeParse(candidate).success;
+}
+/**
+* `value` expressed in `unit`, brought to `target`. Throws
+* {@link QuantityUnitError} for a non-finite value, an unknown unit or a unit
+* of another dimension — never guesses.
+*/
+function convertQuantityInput(input) {
+	if (!Number.isFinite(input.value)) throw new QuantityUnitError("non-finite", `${String(input.value)} is not a finite number`);
+	const unit = normalizeUnit(input.unit);
+	if (unit === void 0 || unitDimension(unit) === void 0) throw new QuantityUnitError("unknown-unit", `unknown unit "${input.unit}"`);
+	const converted = tryConvertUnit(input.value, unit, input.target);
+	if (converted === void 0) throw new QuantityUnitError("cross-dimension", `"${input.unit}" is not a unit of ${input.target}'s quantity`);
+	return Number(converted.toPrecision(12));
+}
+/**
+* Zod `.meta()` bag for a cap METHOD param that is a physical quantity — the
+* input-side twin of `readingMeta`. The value is carried in `unit` (a gram
+* portion stays in grams); the unit must belong to the quantity, checked once
+* when the cap is declared.
+*/
+function paramMeta(declared) {
+	const base = require_sleep.baseUnitOf(declared.quantity);
+	if (base === void 0) throw new QuantityUnitError("unknown-unit", `quantity "${declared.quantity}" has no unit`);
+	if (tryConvertUnit(1, declared.unit, base) === void 0) throw new QuantityUnitError("cross-dimension", `"${declared.unit}" is not a unit of ${declared.quantity}`);
+	return {
+		quantity: declared.quantity,
+		unit: declared.unit
+	};
+}
+var ParamMetaBagSchema = zod.z.object({
+	quantity: require_sleep.ReadingQuantitySchema,
+	unit: zod.z.string().min(1)
+});
+function metaOf(schema) {
+	const parsed = ParamMetaBagSchema.safeParse(zod.z.globalRegistry.get(schema));
+	return parsed.success ? parsed.data : void 0;
+}
+/** The `paramMeta` on a method input field (or its unwrapped leaf), if any. */
+function paramMetaOf(field) {
+	return metaOf(field) ?? metaOf(unwrapSchema(field));
+}
+//#endregion
 //#region src/automation/recipe.ts
 /**
 * The automation RECIPE — what a visually-authored automation is, before it
@@ -8121,8 +8906,10 @@ var AutomationConditionLeafSchema = zod.z.object({
 		zod.z.string(),
 		zod.z.number(),
 		zod.z.boolean(),
-		zod.z.array(zod.z.union([zod.z.string(), zod.z.number()]))
-	])
+		zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
+		QuantityValueSchema
+	]),
+	unit: zod.z.string().min(1).optional()
 });
 var AutomationConditionStationaryPresentSchema = zod.z.object({
 	kind: zod.z.literal("stationary-present"),
@@ -8275,7 +9062,13 @@ var AutomationCapStepSchema = zod.z.object({
 	/** Values may carry `{{vars.x}}` slots, or be exactly `{ $var: 'name' }`, which
 	*  SUBSTITUTE and do not evaluate (§3.2.3). Anything beyond substitution is
 	*  the expression leaf. */
-	args: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+	args: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+	/**
+	* The unit the person picked per arg (display only). `args` always hold the
+	* value in the unit the method's input DECLARES (`paramMeta`); on a write an
+	* arg may be a {@link QuantityValue}, which the save boundary converts.
+	*/
+	argUnits: zod.z.record(zod.z.string(), zod.z.string().min(1)).optional()
 });
 /**
 * The steps an internal Action may contain: cap and wait, and nothing that can
@@ -9855,6 +10648,14 @@ function evalNode(cond, path, reader, now, out) {
 				expected: toTraceValue(cond.value),
 				observed: toTraceValue(observed)
 			};
+			if (isQuantityValue(cond.value)) {
+				out.push({
+					...base,
+					outcome: "fail",
+					reason: `${cond.fieldPath} expected value's unit was never converted → fail`
+				});
+				return false;
+			}
 			if (observed === void 0) {
 				out.push({
 					...base,
@@ -10705,6 +11506,242 @@ function buildActionSteps(steps, vars, deps) {
 	});
 }
 //#endregion
+//#region src/units/quantity-units.ts
+/**
+* Which units a person may pick for a number of a given quantity. The
+* quantity's stored base unit comes first (D944), then every other unit of the
+* same dimension in table order. A quantity with no unit (`none`, `count`,
+* `index`, `ratio`, `device`) offers nothing: the number is just a number.
+*/
+/** The unit a reading of `quantity` is stored in, or `undefined` when it has none. */
+function baseUnitForQuantity(quantity) {
+	return require_sleep.baseUnitOf(quantity);
+}
+/**
+* The units a person can enter a number of `quantity` in — base unit first.
+* Empty when the quantity carries no unit.
+*/
+function unitsForQuantity(quantity) {
+	const base = baseUnitForQuantity(quantity);
+	if (base === void 0) return [];
+	const dimension = unitDimension(base);
+	if (dimension === void 0) return [base];
+	return [base, ...unitsForDimension(dimension).filter((unit) => unit !== base)];
+}
+//#endregion
+//#region src/automation/normalize-units.ts
+/** A bare number accepted as a base unit — the save succeeded, say so. */
+var UnitWarningSchema = zod.z.object({
+	/** Where in the saved record, e.g. `conditions.children.0` or `steps.2.args.grams`. */
+	path: zod.z.string(),
+	deviceId: zod.z.number().int().optional(),
+	field: zod.z.string(),
+	value: zod.z.number(),
+	assumedUnit: zod.z.string(),
+	message: zod.z.string()
+});
+function objectInput(schema) {
+	const inner = unwrapSchema(schema);
+	return inner instanceof zod.z.ZodObject ? inner : void 0;
+}
+/** A resolver over capability definitions (the generated registry, or a fake). */
+function capUnitResolver(defs) {
+	const byName = new Map(defs.map((def) => [def.name, def]));
+	return {
+		fieldQuantity(cap, fieldPath) {
+			const status = byName.get(cap)?.status;
+			if (status === void 0) return void 0;
+			return [...enumerateSchemaFields(status.schema), ...status.itemArray === void 0 ? [] : enumerateItemArrayFields(status.itemArray)].find((f) => f.path === fieldPath)?.quantity;
+		},
+		paramMeta(cap, method, arg) {
+			const input = byName.get(cap)?.methods[method]?.input;
+			if (input === void 0) return void 0;
+			const field = objectInput(input)?.shape[arg];
+			return field === void 0 ? void 0 : paramMetaOf(field);
+		}
+	};
+}
+function pickedUnit(raw) {
+	return normalizeUnit(raw) ?? raw;
+}
+function hasUnitChoice(quantity) {
+	return unitsForQuantity(quantity).length > 1;
+}
+function bareWarning(input) {
+	return {
+		...input,
+		message: `${input.field}: the bare number ${input.value} was taken as ${input.assumedUnit} — send { value, unit } to state the unit`
+	};
+}
+function checkPickedUnit(unit, target) {
+	convertQuantityInput({
+		value: 1,
+		unit,
+		target
+	});
+}
+function normalizeLeaf(leaf, resolver, path) {
+	const quantity = resolver.fieldQuantity(leaf.cap, leaf.fieldPath);
+	const base = quantity === void 0 ? void 0 : baseUnitForQuantity(quantity);
+	const wantsUnit = isQuantityValue(leaf.value) || leaf.unit !== void 0;
+	if (base === void 0 || quantity === void 0) {
+		if (wantsUnit) throw new QuantityUnitError("no-quantity", `${leaf.cap}.${leaf.fieldPath} is not a quantity — it takes no unit`);
+		return {
+			leaf,
+			warnings: []
+		};
+	}
+	if (isQuantityValue(leaf.value)) {
+		const converted = convertQuantityInput({
+			value: leaf.value.value,
+			unit: leaf.value.unit,
+			target: base
+		});
+		return {
+			leaf: {
+				...leaf,
+				value: converted,
+				unit: pickedUnit(leaf.value.unit)
+			},
+			warnings: []
+		};
+	}
+	if (typeof leaf.value !== "number") return {
+		leaf,
+		warnings: []
+	};
+	if (leaf.unit !== void 0) {
+		checkPickedUnit(leaf.unit, base);
+		return {
+			leaf,
+			warnings: []
+		};
+	}
+	if (!hasUnitChoice(quantity)) return {
+		leaf,
+		warnings: []
+	};
+	return {
+		leaf,
+		warnings: [bareWarning({
+			path,
+			deviceId: leaf.deviceId,
+			field: leaf.fieldPath,
+			value: leaf.value,
+			assumedUnit: base
+		})]
+	};
+}
+/** Normalise every leaf of a condition tree. Throws {@link QuantityUnitError}. */
+function normalizeConditionUnits(condition, resolver, path = "conditions") {
+	switch (condition.kind) {
+		case "condition": {
+			const { leaf, warnings } = normalizeLeaf(condition, resolver, path);
+			return {
+				value: leaf,
+				warnings
+			};
+		}
+		case "not": {
+			const inner = normalizeConditionUnits(condition.child, resolver, `${path}.child`);
+			return {
+				value: {
+					...condition,
+					child: inner.value
+				},
+				warnings: inner.warnings
+			};
+		}
+		case "all":
+		case "any": {
+			const children = condition.children.map((child, i) => normalizeConditionUnits(child, resolver, `${path}.children.${i}`));
+			return {
+				value: {
+					...condition,
+					children: children.map((c) => c.value)
+				},
+				warnings: children.flatMap((c) => c.warnings)
+			};
+		}
+		default: return {
+			value: condition,
+			warnings: []
+		};
+	}
+}
+function normalizeCapStep(step, resolver, path) {
+	const deviceId = typeof step.deviceId === "number" ? step.deviceId : void 0;
+	const args = { ...step.args };
+	const argUnits = { ...step.argUnits };
+	const warnings = [];
+	for (const [arg, picked] of Object.entries(step.argUnits ?? {})) {
+		const meta = resolver.paramMeta(step.cap, step.method, arg);
+		if (meta === void 0) throw new QuantityUnitError("no-quantity", `${step.cap}.${step.method}(${arg}) is not a quantity — it takes no unit`);
+		checkPickedUnit(picked, meta.unit);
+	}
+	for (const [arg, given] of Object.entries(step.args ?? {})) {
+		const meta = resolver.paramMeta(step.cap, step.method, arg);
+		if (meta === void 0) continue;
+		if (isQuantityValue(given)) {
+			args[arg] = convertQuantityInput({
+				value: given.value,
+				unit: given.unit,
+				target: meta.unit
+			});
+			argUnits[arg] = pickedUnit(given.unit);
+		} else if (typeof given === "number" && argUnits[arg] === void 0 && hasUnitChoice(meta.quantity)) warnings.push(bareWarning({
+			path: `${path}.args.${arg}`,
+			...deviceId === void 0 ? {} : { deviceId },
+			field: arg,
+			value: given,
+			assumedUnit: meta.unit
+		}));
+	}
+	const { argUnits: _dropped, ...rest } = step;
+	return {
+		value: {
+			...rest,
+			...step.args === void 0 ? {} : { args },
+			...Object.keys(argUnits).length > 0 ? { argUnits } : {}
+		},
+		warnings
+	};
+}
+/**
+* Normalise the cap steps of an action list (an internal Action's steps, or a
+* recipe's actions). Other step kinds pass through. Throws {@link QuantityUnitError}.
+*/
+function normalizeActionUnits(actions, resolver, path = "steps") {
+	const out = [];
+	const warnings = [];
+	actions.forEach((action, i) => {
+		if (action.kind !== "cap") {
+			out.push(action);
+			return;
+		}
+		const normalized = normalizeCapStep(action, resolver, `${path}.${i}`);
+		out.push(normalized.value);
+		warnings.push(...normalized.warnings);
+	});
+	return {
+		value: out,
+		warnings
+	};
+}
+/** Normalise a whole recipe: its condition tree and its actions. */
+function normalizeRecipeUnits(recipe, resolver) {
+	const conditions = recipe.conditions === void 0 ? void 0 : normalizeConditionUnits(recipe.conditions, resolver, "conditions");
+	const actions = normalizeActionUnits(recipe.actions, resolver, "actions");
+	return {
+		value: {
+			...recipe,
+			...conditions === void 0 ? {} : { conditions: conditions.value },
+			actions: actions.value
+		},
+		warnings: [...conditions?.warnings ?? [], ...actions.warnings]
+	};
+}
+//#endregion
 //#region src/capabilities/notification-output.cap.ts
 /**
 * notification-output — canonical, capability-gated notification delivery.
@@ -15199,77 +16236,6 @@ function kebabToCamel(s) {
 	return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 //#endregion
-//#region src/device/schema-fields.ts
-/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner type.
-*  Zod v4 exposes `.unwrap()` on all three wrapper classes. */
-function unwrapSchema(schema) {
-	let s = 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) && require_sleep.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 {
-		kind: "enum",
-		enumValues: s.options
-	};
-	if (s instanceof zod.z.ZodNumber) return { kind: "number" };
-	if (s instanceof zod.z.ZodString) return { kind: "string" };
-	if (s instanceof zod.z.ZodBoolean) return { kind: "boolean" };
-	return null;
-}
-/** Walk a cap status schema into flat wireable leaf fields (dotted paths).
-*  Recurses into nested ZodObject (unwrapping nullable/optional/default first),
-*  so fields with null live values are still offered. Arrays / unknown shapes
-*  are skipped — never throws. */
-function enumerateSchemaFields(schema, prefix = "") {
-	const root = unwrapSchema(schema);
-	if (!(root instanceof zod.z.ZodObject)) return [];
-	const out = [];
-	const shape = root.shape;
-	for (const [key, field] of Object.entries(shape)) {
-		const path = prefix ? `${prefix}.${key}` : key;
-		const inner = unwrapSchema(field);
-		if (inner instanceof zod.z.ZodObject) {
-			out.push(...enumerateSchemaFields(inner, path));
-			continue;
-		}
-		const leaf = leafKind(field);
-		if (leaf) {
-			const quantity = quantityOfField(field);
-			out.push({
-				path,
-				kind: leaf.kind,
-				...leaf.enumValues ? { enumValues: leaf.enumValues } : {},
-				...quantity !== void 0 ? { quantity } : {}
-			});
-		}
-	}
-	return out;
-}
-/** Enumerate the per-item wireable fields of an item-array cap (see
-*  `CapabilityStatusItemArray`): the item schema's leaf fields, minus the
-*  `keyField` (the key comes from the link's `itemKey`, never from a wired
-*  source), each tagged `item: true` so the authoring UI collects an
-*  `itemKey` alongside the field. Never throws. */
-function enumerateItemArrayFields(itemArray) {
-	return enumerateSchemaFields(itemArray.itemSchema).filter((f) => f.path !== itemArray.keyField).map((f) => ({
-		...f,
-		item: true
-	}));
-}
-//#endregion
 //#region src/composition/state-fields.ts
 /**
 * What a capability's state field IS: kind, nullability, whether required. The
@@ -21163,192 +22129,6 @@ function parseAdminBase(baseUrl) {
 	};
 }
 //#endregion
-//#region src/device/source-info.ts
-/**
-* Identity envelope for a device's upstream-system metadata.
-*
-* Two jobs:
-*
-*   1. **Dispatch key.** `id` is the natural identifier the SOURCE system
-*      uses to address this device (HA `entity_id`, Reolink MAC, ONVIF
-*      WS-Discovery endpoint UUID, …). Provider code keeps a
-*      `Map<sourceInfo.id, IDevice>` to route inbound push events in O(1)
-*      without round-tripping through `stableId` / `id` mappings.
-*
-*   2. **Stability bridge.** `uniqueId` is the *immutable* upstream id when
-*      one exists (HA `entity.unique_id`, Reolink MAC again — same as `id`
-*      for vendors where MAC is the natural key). For systems where the
-*      live dispatch key can be renamed (HA `entity_id` can be edited),
-*      providers detect renames by matching `uniqueId` and patch `id`
-*      in-place so dispatch keeps working.
-*
-* **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`
-* details, …). Providers control what lands here.
-*/
-var SourceInfoSchema = zod.z.object({
-	/** Live dispatch key — mutable when the source system allows rename. */
-	id: zod.z.string(),
-	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
-	system: zod.z.string(),
-	/** 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: require_sleep.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). */
-	raw: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-/**
-* Build the synthetic SourceInfo every existing provider falls back to
-* when no upstream value has been persisted. Keeps non-migrated providers
-* (Reolink / Hikvision / ONVIF / RTSP) functional without code
-* changes — `id` reuses the CamStack stableId, `system` reuses the addon
-* id. Real upstream identity replaces this once a provider migrates and
-* calls `updateSourceInfo()` with concrete values.
-*/
-function synthesizeSourceInfo(input) {
-	return {
-		id: input.stableId,
-		system: input.addonId
-	};
-}
-/**
-* Shallow-merge a partial patch over a prior SourceInfo. `undefined`
-* patch values are ignored (no field clobber); to clear a field
-* explicitly, providers omit it from the patch and rebuild from scratch
-* via `updateSourceInfo({})` cycles — uncommon enough that we don't
-* bother with a `null`-means-delete sentinel.
-*
-* The `raw` field is also shallow-merged: passing `raw: { foo: 1 }`
-* merges over existing `raw` keys instead of replacing the whole bag.
-*/
-function mergeSourceInfo(prev, patch) {
-	const next = { ...prev };
-	for (const [k, v] of Object.entries(patch)) {
-		if (v === void 0) continue;
-		if (k === "raw" && typeof v === "object" && v !== null) {
-			next.raw = {
-				...prev.raw,
-				...v
-			};
-			continue;
-		}
-		next[k] = v;
-	}
-	return next;
-}
-/**
-* Coerce common unit-of-measurement string variants to a canonical form
-* so the UI's display templates can rely on stable strings. Pure
-* passthrough for unknown units — kept conservative on purpose, the goal
-* is to normalise the long tail of HA `unit_of_measurement` values that
-* have multiple historical spellings (`'°C'` vs `'C'` vs `'celsius'`).
-*
-* Extend the map as we encounter real-world data. Returning the raw
-* input for unknown values is intentional: providers should never
-* lose information silently here.
-*/
-function normalizeUnit(raw) {
-	if (raw == null) return void 0;
-	const trimmed = raw.trim();
-	if (trimmed === "") return void 0;
-	const lower = trimmed.toLowerCase();
-	if (lower === "°c" || lower === "c" || lower === "celsius") return "°C";
-	if (lower === "°f" || lower === "f" || lower === "fahrenheit") return "°F";
-	if (lower === "k" || lower === "kelvin") return "K";
-	if (lower === "%" || lower === "percent" || lower === "percentage") return "%";
-	if (lower === "lx" || lower === "lux") return "lx";
-	if (lower === "hpa" || lower === "hectopascal") return "hPa";
-	if (lower === "kpa") return "kPa";
-	if (lower === "pa") return "Pa";
-	if (lower === "mbar" || lower === "millibar") return "mbar";
-	if (lower === "w" || lower === "watt") return "W";
-	if (lower === "kw" || lower === "kilowatt") return "kW";
-	if (lower === "wh" || lower === "watt-hour") return "Wh";
-	if (lower === "kwh" || lower === "kilowatt-hour") return "kWh";
-	if (lower === "v" || lower === "volt") return "V";
-	if (lower === "a" || lower === "amp" || lower === "ampere") return "A";
-	if (lower === "ma" || lower === "milliampere") return "mA";
-	if (lower === "va") return "VA";
-	if (lower === "ppm") return "ppm";
-	if (lower === "ppb") return "ppb";
-	if (lower === "µg/m³" || lower === "ug/m3" || lower === "µg/m3") return "µg/m³";
-	if (lower === "km/h" || lower === "kph") return "km/h";
-	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;
-}
-/**
-* Key under which `SourceInfo` lives inside `DeviceMeta.metadata`. The
-* blob is a free-form `Record<string, unknown>` shared with hardware-
-* identity fields (`manufacturer`, `model`, `firmware`, …); SourceInfo
-* lives under a single nested key to keep it composable with those.
-*/
-var SOURCE_INFO_METADATA_KEY = "sourceInfo";
-/**
-* Extract a SourceInfo from a `DeviceMeta.metadata` blob, validating
-* with Zod. Returns `null` when the blob is missing or the nested
-* `sourceInfo` key fails validation — callers fall back to the
-* synthetic default in that case (see `synthesizeSourceInfo`).
-*/
-function extractSourceInfoFromMetadata(metadata) {
-	if (!metadata) return null;
-	const raw = metadata[SOURCE_INFO_METADATA_KEY];
-	if (!raw) return null;
-	const parsed = SourceInfoSchema.safeParse(raw);
-	if (!parsed.success) return null;
-	return parsed.data;
-}
-//#endregion
 //#region src/capabilities/device-discovery.cap.ts
 /**
 * device-discovery — device-scoped capability for parents that host /
@@ -60184,11 +60964,13 @@ var WrapperEvidenceSchema = zod.z.object({
 * The shell verdict (see {@link WrapperKindSchema}) with the proofs that
 * produced it.
 *
-* There is deliberately NO `canSelfUpdate` and no apply action: a wrapper
-* update is an ANNOUNCEMENT. The notification body carries the exact command
-* for a `docker` shell and says the app restarts into the new build for
-* `electron`, and that sentence is chosen from `kind` alone — a boolean
-* nothing reads is the defect this repo keeps paying for.
+* There is deliberately NO `canSelfUpdate` boolean: a wrapper update is an
+* ANNOUNCEMENT. The notification body carries the exact command for a `docker`
+* shell and says the app restarts into the new build for `electron`, and that
+* sentence is chosen from `kind` alone — a boolean nothing reads is the defect
+* this repo keeps paying for. The one shell that CAN be acted on is the
+* Electron app, and only through `installDesktopUpdate` (see
+* {@link DesktopAppStatusSchema} for what the node reads from the app first).
 */
 var WrapperIdentitySchema = zod.z.object({
 	kind: WrapperKindSchema,
@@ -60212,6 +60994,49 @@ var ServerRollbackInfoSchema = zod.z.object({
 	reason: zod.z.string()
 });
 /**
+* What the native desktop app (Electron) that hosts this node says about
+* itself, read from `<dataDir>/server-root/desktop-app-state.json` (ADR-0971).
+* Absent on the status = no desktop app, or it never wrote the file.
+*
+* `stale` is the honest answer to an app that stopped writing (closed, hung,
+* crashed): the update facts are then the LAST ones known, not current ones,
+* and a consumer must not read `update.available: false` from a stale record
+* as "no update". `stateAtMs` is when the app last wrote.
+*/
+var DesktopAppStatusSchema = zod.z.object({
+	/** The Electron app's own version (not the node closure's). */
+	version: zod.z.string(),
+	update: zod.z.object({
+		available: zod.z.boolean(),
+		/** The new build is downloaded and `installDesktopUpdate` can apply it. */
+		downloaded: zod.z.boolean(),
+		version: zod.z.string().nullable(),
+		checking: zod.z.boolean(),
+		/** Why the app's last update check produced no answer; `null` when it did. */
+		error: zod.z.string().nullable()
+	}),
+	stateAtMs: zod.z.number(),
+	stale: zod.z.boolean()
+});
+/**
+* Why `installDesktopUpdate` did nothing. Stable names a UI maps to a sentence:
+*  - `not-electron`   — this node does not run inside the desktop app.
+*  - `no-app-state`   — the app never published its state (or the file is unreadable).
+*  - `app-state-stale` — the app stopped writing; it is probably not running.
+*  - `not-downloaded` — no update is downloaded yet; nothing to install.
+*/
+var InstallDesktopUpdateReasonSchema = zod.z.enum([
+	"not-electron",
+	"no-app-state",
+	"app-state-stale",
+	"not-downloaded"
+]);
+var InstallDesktopUpdateResultSchema = zod.z.object({
+	accepted: zod.z.boolean(),
+	/** Non-null exactly when `accepted` is false. */
+	reason: InstallDesktopUpdateReasonSchema.nullable()
+});
+/**
 * The runner boot check (D877): the runners this node PLANNED (hub: one per
 * `resolveRunnerId` over its forked addons; agent: the runners its process
 * service holds, because only the hub plans) against the states the process
@@ -60315,7 +61140,12 @@ var ServerPackageStatusSchema = zod.z.object({
 	* on a provider that predates it. Absent is "not checked yet", never "all
 	* well": a consumer that needs the answer treats it as pending.
 	*/
-	runners: RunnerBootCheckSchema.optional()
+	runners: RunnerBootCheckSchema.optional(),
+	/**
+	* The desktop app hosting this node (see {@link DesktopAppStatusSchema}).
+	* Optional for version skew AND because most nodes have no desktop app.
+	*/
+	desktopApp: DesktopAppStatusSchema.optional()
 });
 var ServerUpdateCheckResultSchema = zod.z.object({
 	packageName: zod.z.string(),
@@ -60428,6 +61258,19 @@ var serverManagementCapability = {
 			auth: "admin",
 			timeoutMs: 16 * 6e4
 		}),
+		/**
+		* Ask the desktop app hosting this node to install its DOWNLOADED update
+		* and restart. The request is a file in the node's data dir (the node may
+		* be a Windows service, not Electron's child); the app consumes it once.
+		* `accepted: true` means the request was WRITTEN — the app restarting is
+		* observed afterwards on `desktopApp.version`, not promised here. Refused
+		* with a named `reason` when not an electron shell, the app's state is
+		* absent or stale, or nothing is downloaded.
+		*/
+		installDesktopUpdate: require_sleep.method(zod.z.void(), InstallDesktopUpdateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		rollbackServerUpdate: require_sleep.method(zod.z.void(), ServerUpdateActionResultSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -65095,15 +65938,29 @@ var actionsCapability = {
 			auth: "admin"
 		}),
 		getTraces: require_sleep.method(ActionIdInput, zod.z.object({ traces: zod.z.array(AutomationRunTraceSchema) }), { auth: "admin" }),
-		/** Internal actions only. A read-only (addon) entry is refused with `[read-only]`. */
-		create: require_sleep.method(zod.z.object({ action: ActionInputSchema }), zod.z.object({ action: ActionEntrySchema }), {
+		/**
+		* Internal actions only; a read-only (addon) entry is refused with `[read-only]`.
+		* Create an internal action. A cap step arg that is a physical quantity may
+		* be sent as `{ value, unit }` ("value expressed in unit"); the server
+		* converts it to the unit the method's input declares, stores the bare
+		* number plus the picked unit in `argUnits`, and refuses a unit of another
+		* dimension (`[invalid-steps]`). A bare number is taken as the declared
+		* unit and answered as a `warnings` entry (D972).
+		*/
+		create: require_sleep.method(zod.z.object({ action: ActionInputSchema }), zod.z.object({
+			action: ActionEntrySchema,
+			warnings: zod.z.array(UnitWarningSchema).optional()
+		}), {
 			kind: "mutation",
 			auth: "admin"
 		}),
 		update: require_sleep.method(zod.z.object({
 			actionId: zod.z.string().min(1),
 			action: ActionInputSchema.partial()
-		}), zod.z.object({ action: ActionEntrySchema }), {
+		}), zod.z.object({
+			action: ActionEntrySchema,
+			warnings: zod.z.array(UnitWarningSchema).optional()
+		}), {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -73280,6 +74137,14 @@ var PetFeederDeviceStatusSchema = zod.z.enum([
 	"on_batteries"
 ]);
 var gramsPortion = zod.z.number().int().min(4).max(200);
+/** A portion REQUESTED of the feeder is a mass the method takes in GRAMS (the
+*  hardware's own unit). The bounds are grams; a caller entering another unit
+*  converts to grams first (`paramMeta`, D972). The STATUS fields above stay
+*  plain grams — they are not readings in the kilogram base. */
+var gramsParam = gramsPortion.meta(paramMeta({
+	quantity: "mass",
+	unit: "g"
+}));
 var PetFeederStatusSchema = zod.z.object({
 	/** Food in the TANK (hopper), as the feeder's own sensor reports it
 	*  (`state.food`). A coarse level code, not grams — `0` is empty. The
@@ -73368,9 +74233,9 @@ var petFeederCapability = {
 		*/
 		feed: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number().int().nonnegative(),
-			grams: gramsPortion.optional(),
-			hopper1: gramsPortion.optional(),
-			hopper2: gramsPortion.optional()
+			grams: gramsParam.optional(),
+			hopper1: gramsParam.optional(),
+			hopper2: gramsParam.optional()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
@@ -82828,465 +83693,6 @@ function numericAccept() {
 	return historyAccept("statistic").filter((field) => field.valueKind === "number");
 }
 //#endregion
-//#region src/units/unit-table.ts
-/**
-* 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` ⇒
-* `factor = 5/9`, `offset = -160/9` (kept as exact expressions, not rounded
-* decimals). K derives from `°C = K − 273.15`.
-*/
-var UNIT_TABLE = {
-	"°C": {
-		dimension: "temperature",
-		factor: 1,
-		offset: 0
-	},
-	"°F": {
-		dimension: "temperature",
-		factor: 5 / 9,
-		offset: -160 / 9
-	},
-	K: {
-		dimension: "temperature",
-		factor: 1,
-		offset: -273.15
-	},
-	hPa: {
-		dimension: "pressure",
-		factor: 1,
-		offset: 0
-	},
-	kPa: {
-		dimension: "pressure",
-		factor: 10,
-		offset: 0
-	},
-	Pa: {
-		dimension: "pressure",
-		factor: .01,
-		offset: 0
-	},
-	mbar: {
-		dimension: "pressure",
-		factor: 1,
-		offset: 0
-	},
-	bar: {
-		dimension: "pressure",
-		factor: 1e3,
-		offset: 0
-	},
-	inHg: {
-		dimension: "pressure",
-		factor: 33.8639,
-		offset: 0
-	},
-	mmHg: {
-		dimension: "pressure",
-		factor: 1.33322,
-		offset: 0
-	},
-	psi: {
-		dimension: "pressure",
-		factor: 68.9476,
-		offset: 0
-	},
-	"m/s": {
-		dimension: "speed",
-		factor: 1,
-		offset: 0
-	},
-	"km/h": {
-		dimension: "speed",
-		factor: 1 / 3.6,
-		offset: 0
-	},
-	mph: {
-		dimension: "speed",
-		factor: .44704,
-		offset: 0
-	},
-	kn: {
-		dimension: "speed",
-		factor: .514444,
-		offset: 0
-	},
-	"mm/h": {
-		dimension: "precipitation-rate",
-		factor: 1,
-		offset: 0
-	},
-	"in/h": {
-		dimension: "precipitation-rate",
-		factor: 25.4,
-		offset: 0
-	},
-	m: {
-		dimension: "length",
-		factor: 1,
-		offset: 0
-	},
-	mm: {
-		dimension: "length",
-		factor: .001,
-		offset: 0
-	},
-	cm: {
-		dimension: "length",
-		factor: .01,
-		offset: 0
-	},
-	km: {
-		dimension: "length",
-		factor: 1e3,
-		offset: 0
-	},
-	in: {
-		dimension: "length",
-		factor: .0254,
-		offset: 0
-	},
-	ft: {
-		dimension: "length",
-		factor: .3048,
-		offset: 0
-	},
-	mi: {
-		dimension: "length",
-		factor: 1609.344,
-		offset: 0
-	},
-	"m²": {
-		dimension: "area",
-		factor: 1,
-		offset: 0
-	},
-	lx: {
-		dimension: "illuminance",
-		factor: 1,
-		offset: 0
-	},
-	"W/m²": {
-		dimension: "irradiance",
-		factor: 1,
-		offset: 0
-	},
-	W: {
-		dimension: "power",
-		factor: 1,
-		offset: 0
-	},
-	kW: {
-		dimension: "power",
-		factor: 1e3,
-		offset: 0
-	},
-	VA: {
-		dimension: "apparent-power",
-		factor: 1,
-		offset: 0
-	},
-	Wh: {
-		dimension: "energy",
-		factor: 1,
-		offset: 0
-	},
-	kWh: {
-		dimension: "energy",
-		factor: 1e3,
-		offset: 0
-	},
-	MWh: {
-		dimension: "energy",
-		factor: 1e6,
-		offset: 0
-	},
-	V: {
-		dimension: "voltage",
-		factor: 1,
-		offset: 0
-	},
-	mV: {
-		dimension: "voltage",
-		factor: .001,
-		offset: 0
-	},
-	A: {
-		dimension: "current",
-		factor: 1,
-		offset: 0
-	},
-	mA: {
-		dimension: "current",
-		factor: .001,
-		offset: 0
-	},
-	ppm: {
-		dimension: "concentration-volume",
-		factor: 1,
-		offset: 0
-	},
-	ppb: {
-		dimension: "concentration-volume",
-		factor: .001,
-		offset: 0
-	},
-	"µg/m³": {
-		dimension: "concentration-mass",
-		factor: 1,
-		offset: 0
-	},
-	"mg/m³": {
-		dimension: "concentration-mass",
-		factor: 1e3,
-		offset: 0
-	},
-	kg: {
-		dimension: "mass",
-		factor: 1,
-		offset: 0
-	},
-	g: {
-		dimension: "mass",
-		factor: .001,
-		offset: 0
-	},
-	lb: {
-		dimension: "mass",
-		factor: .453592,
-		offset: 0
-	},
-	oz: {
-		dimension: "mass",
-		factor: .0283495,
-		offset: 0
-	},
-	"%": {
-		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
-	}
-};
-//#endregion
-//#region src/units/convert.ts
-/**
-* Pure unit-conversion API over `UNIT_TABLE`. No dependencies, no side effects.
-*
-* Conversion is refused (throws `UnitConversionError`, or returns `undefined`
-* from the `try*` variant) whenever a unit is unknown or the two units belong
-* to different dimensions — cross-dimension conversion is deliberately
-* impossible so a render override can never make the value and its unit label
-* disagree.
-*
-* Callers pass units through `normalizeUnit` (`../device/source-info.ts`) BEFORE
-* calling here — the table keys only canonical spellings.
-*/
-/** Thrown by `convertUnit` when a conversion is refused. Carries the offending
-*  units + a machine-readable `reason` for callers that branch on the cause. */
-var UnitConversionError = class extends Error {
-	from;
-	to;
-	reason;
-	constructor(from, to, reason) {
-		super(`[units] cannot convert '${from}' → '${to}': ${reason}`);
-		this.name = "UnitConversionError";
-		this.from = from;
-		this.to = to;
-		this.reason = reason;
-	}
-};
-/** Resolve a unit's `UnitSpec`, or `undefined` when the spelling is unknown. */
-function specFor(unit) {
-	return Object.hasOwn(UNIT_TABLE, unit) ? UNIT_TABLE[unit] : void 0;
-}
-/** The dimension a unit belongs to, or `undefined` for an unknown unit. */
-function unitDimension(unit) {
-	return specFor(unit)?.dimension;
-}
-/** Value in `spec`'s unit → its dimension's canonical unit. */
-function toCanonical(value, spec) {
-	return value * spec.factor + spec.offset;
-}
-/** Canonical-unit value → the unit described by `spec`. */
-function fromCanonical(canonical, spec) {
-	return (canonical - spec.offset) / spec.factor;
-}
-/**
-* Convert `value` from unit `from` to unit `to`. Identity when `from === to`.
-* Throws `UnitConversionError` when either unit is unknown or the units belong
-* to different dimensions.
-*/
-function convertUnit(value, from, to) {
-	if (from === to) return value;
-	const fromSpec = specFor(from);
-	if (!fromSpec) throw new UnitConversionError(from, to, "unknown-from");
-	const toSpec = specFor(to);
-	if (!toSpec) throw new UnitConversionError(from, to, "unknown-to");
-	if (fromSpec.dimension !== toSpec.dimension) throw new UnitConversionError(from, to, "cross-dimension");
-	return fromCanonical(toCanonical(value, fromSpec), toSpec);
-}
-/**
-* Graceful variant for the render path: returns the converted value, or
-* `undefined` when the conversion is refused (unknown unit / cross-dimension).
-* Never throws — a render caller falls back to the raw value + source unit.
-*/
-function tryConvertUnit(value, from, to) {
-	if (from === to) return value;
-	const fromSpec = specFor(from);
-	if (!fromSpec) return void 0;
-	const toSpec = specFor(to);
-	if (!toSpec) return void 0;
-	if (fromSpec.dimension !== toSpec.dimension) return void 0;
-	return fromCanonical(toCanonical(value, fromSpec), toSpec);
-}
-/**
-* Whether `value` can be converted between `from` and `to` (same dimension,
-* both known). Cheap boolean probe for the UI's same-dimension unit picker and
-* the resolver's convertibility branch — compute ONCE so a unit label and its
-* value math can never disagree.
-*/
-function canConvertUnit(from, to) {
-	if (from === to) return true;
-	const fromDim = unitDimension(from);
-	if (fromDim === void 0) return false;
-	return fromDim === unitDimension(to);
-}
-/**
-* Every known unit spelling in a dimension (table insertion order — canonical
-* unit first). Powers the UI's same-dimension unit picker.
-*/
-/**
-* Convert a difference, not a reading. Affine units (°F) shift an absolute
-* value by their offset; a step of 1°F is 5/9°C, so the offset is cancelled.
-*/
-function tryConvertDelta(value, from, to) {
-	if (from === to) return value;
-	const origin = tryConvertUnit(0, from, to);
-	const shifted = tryConvertUnit(value, from, to);
-	if (origin === void 0 || shifted === void 0) return void 0;
-	return shifted - origin;
-}
-function unitsForDimension(dimension) {
-	const out = [];
-	for (const [unit, spec] of Object.entries(UNIT_TABLE)) if (spec.dimension === dimension) out.push(unit);
-	return out;
-}
-//#endregion
 //#region src/composition/evaluate-field.ts
 /**
 * One composed field, evaluated from what its sources say NOW (D659).
@@ -96679,6 +97085,13 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		access: "view",
 		role: "admin"
 	},
+	"serverManagement.installDesktopUpdate": {
+		capName: "server-management",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"serverManagement.restartServer": {
 		capName: "server-management",
 		capScope: "system",
@@ -100988,7 +101401,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}]
@@ -101007,7 +101421,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}, {
@@ -101018,7 +101433,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}]
@@ -110879,6 +111295,7 @@ function createSystemProxy(api) {
 			getServerPackageStatus: (input) => dispatch("serverManagement", "getServerPackageStatus", "query", input),
 			checkServerUpdate: (input) => dispatch("serverManagement", "checkServerUpdate", "mutation", input),
 			applyServerUpdate: (input) => dispatch("serverManagement", "applyServerUpdate", "mutation", input),
+			installDesktopUpdate: (input) => dispatch("serverManagement", "installDesktopUpdate", "mutation", input),
 			rollbackServerUpdate: (input) => dispatch("serverManagement", "rollbackServerUpdate", "mutation", input),
 			restartServer: (input) => dispatch("serverManagement", "restartServer", "mutation", input),
 			getLaunchOverrides: (input) => dispatch("serverManagement", "getLaunchOverrides", "query", input),
@@ -122354,6 +122771,7 @@ exports.DeleteIntegrationResultSchema = DeleteIntegrationResultSchema;
 exports.DeliveryParamSchema = DeliveryParamSchema;
 exports.DeliveryParamValueSchema = DeliveryParamValueSchema;
 exports.DerivativeHelperSpecSchema = require_composition.DerivativeHelperSpecSchema;
+exports.DesktopAppStatusSchema = DesktopAppStatusSchema;
 exports.DetailCropConventionSchema = DetailCropConventionSchema;
 exports.DetectionCatalogClassMapSchema = DetectionCatalogClassMapSchema;
 exports.DetectionSourceSchema = DetectionSourceSchema;
@@ -122641,6 +123059,8 @@ exports.ImportModelBundleInputSchema = ImportModelBundleInputSchema;
 exports.ImportModelBundleResultSchema = ImportModelBundleResultSchema;
 exports.InferenceDeviceExclusionReasonSchema = InferenceDeviceExclusionReasonSchema;
 exports.IngestOwnerSchema = IngestOwnerSchema;
+exports.InstallDesktopUpdateReasonSchema = InstallDesktopUpdateReasonSchema;
+exports.InstallDesktopUpdateResultSchema = InstallDesktopUpdateResultSchema;
 exports.InstalledPackageSchema = InstalledPackageSchema;
 exports.IntegralHelperSpecSchema = require_composition.IntegralHelperSpecSchema;
 exports.IntegrationLiteSchema = IntegrationLiteSchema;
@@ -123321,6 +123741,8 @@ exports.PtzPresetFunctionSchema = PtzPresetFunctionSchema;
 exports.PtzPresetSchema = PtzPresetSchema;
 exports.PtzStatusSchema = PtzStatusSchema;
 exports.QUANTITY_BASE = require_sleep.QUANTITY_BASE;
+exports.QuantityUnitError = QuantityUnitError;
+exports.QuantityValueSchema = QuantityValueSchema;
 exports.QueryFilterSchema = QueryFilterSchema;
 exports.RATE_CONTROL_RELAXED = RATE_CONTROL_RELAXED;
 exports.RATE_CONTROL_TIGHT = RATE_CONTROL_TIGHT;
@@ -123863,6 +124285,7 @@ exports.UninstallNodeOutcomeSchema = UninstallNodeOutcomeSchema;
 exports.UninstallNodeResultSchema = UninstallNodeResultSchema;
 exports.UninstallPackageResultSchema = UninstallPackageResultSchema;
 exports.UnitConversionError = UnitConversionError;
+exports.UnitWarningSchema = UnitWarningSchema;
 exports.UnknownRecordKindError = require_sleep.UnknownRecordKindError;
 exports.UnreleasedClaimSchema = UnreleasedClaimSchema;
 exports.UnstampedEventMediaCountSchema = UnstampedEventMediaCountSchema;
@@ -124026,6 +124449,7 @@ exports.autoAssignProfiles = autoAssignProfiles;
 exports.automationControlCapability = automationControlCapability;
 exports.backupCapability = backupCapability;
 exports.bareAddonId = bareAddonId;
+exports.baseUnitForQuantity = baseUnitForQuantity;
 exports.baseUnitOf = require_sleep.baseUnitOf;
 exports.batteryCapability = batteryCapability;
 exports.bestLocationMatch = bestLocationMatch;
@@ -124074,6 +124498,7 @@ exports.canConvertUnit = canConvertUnit;
 exports.canonicalEgressPlan = canonicalEgressPlan;
 exports.canonicalIconKey = canonicalIconKey;
 exports.canonicalizeAppCallback = canonicalizeAppCallback;
+exports.capUnitResolver = capUnitResolver;
 exports.capabilityScopesOf = capabilityScopesOf;
 exports.capacityForModel = capacityForModel;
 exports.capacitySessionsOf = capacitySessionsOf;
@@ -124156,6 +124581,7 @@ exports.contactCapability = contactCapability;
 exports.containingParentIndex = containingParentIndex;
 exports.controlCapability = controlCapability;
 exports.convertPresetFeature = convertPresetFeature;
+exports.convertQuantityInput = convertQuantityInput;
 exports.convertUnit = convertUnit;
 exports.convertUnitTargets = convertUnitTargets;
 exports.coralUsableUnits = coralUsableUnits;
@@ -124471,6 +124897,7 @@ exports.isObjectInput = isObjectInput;
 exports.isOccupancyRule = isOccupancyRule;
 exports.isOwnerOnlyEventCategory = require_event_category.isOwnerOnlyEventCategory;
 exports.isPlugApplianceType = isPlugApplianceType;
+exports.isQuantityValue = isQuantityValue;
 exports.isReadingQuantity = require_sleep.isReadingQuantity;
 exports.isRemoteCustomKey = isRemoteCustomKey;
 exports.isRemoteKnownRole = isRemoteKnownRole;
@@ -124601,12 +125028,15 @@ exports.nodePickerItems = nodePickerItems;
 exports.nodePin = require_sleep.nodePin;
 exports.nodeRemovalHookCapability = nodeRemovalHookCapability;
 exports.nodesCapability = nodesCapability;
+exports.normalizeActionUnits = normalizeActionUnits;
 exports.normalizeAddonInitResult = require_sleep.normalizeAddonInitResult;
 exports.normalizeAudioLabel = normalizeAudioLabel;
+exports.normalizeConditionUnits = normalizeConditionUnits;
 exports.normalizeCoreBlockWrite = normalizeCoreBlockWrite;
 exports.normalizeNcMediaPolicy = normalizeNcMediaPolicy;
 exports.normalizeNodeId = require_sleep.normalizeNodeId;
 exports.normalizeOrigin = normalizeOrigin;
+exports.normalizeRecipeUnits = normalizeRecipeUnits;
 exports.normalizeSecretOwner = require_sleep.normalizeSecretOwner;
 exports.normalizeTokenScopes = normalizeTokenScopes;
 exports.normalizeUnit = normalizeUnit;
@@ -124638,6 +125068,8 @@ exports.paletteFromStored = paletteFromStored;
 exports.paletteLegend = paletteLegend;
 exports.paletteResultSchema = paletteResultSchema;
 exports.paletteSwatchSchema = paletteSwatchSchema;
+exports.paramMeta = paramMeta;
+exports.paramMetaOf = paramMetaOf;
 exports.parseAcceleratorFactsJson = parseAcceleratorFactsJson;
 exports.parseAdminBase = parseAdminBase;
 exports.parseAlertEpisodePayload = parseAlertEpisodePayload;
@@ -125023,6 +125455,7 @@ exports.turnProviderCapability = turnProviderCapability;
 exports.unitCompanionField = unitCompanionField;
 exports.unitDimension = unitDimension;
 exports.unitsForDimension = unitsForDimension;
+exports.unitsForQuantity = unitsForQuantity;
 exports.unreachableExtensionSlotRow = unreachableExtensionSlotRow;
 exports.unwrapSchema = unwrapSchema;
 exports.updateCapability = updateCapability;