@camstack/addon-model-studio 1.1.321 → 1.1.323

package/dist/model-studio.addon.mjs

@@ -16042,6 +16042,478 @@ object({
 		path: ["expr"]
 	});
 });
+/**
+* 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 = object({
+	/** Live dispatch key — mutable when the source system allows rename. */
+	id: string(),
+	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
+	system: string(),
+	/** Immutable upstream identifier when available (HA `unique_id`, … ).
+	*  Used to detect rename when `id` changes. */
+	uniqueId: string().optional(),
+	/** Quantity of a polymorphic reading, written once at adopt (D944). */
+	quantity: ReadingQuantitySchema.optional(),
+	/** Date / time / datetime shape of a string reading, written once at adopt. */
+	dateTimeShape: _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: record(string(), unknown()).optional()
+});
+/**
+* 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
+	}
+};
+/** 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;
+}
+/** 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;
+}
+/**
+* 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);
+}
+/**
+* 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 = object({
+	value: number(),
+	unit: string().min(1)
+});
+/**
+* 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 = 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
+	};
+}
+object({
+	quantity: ReadingQuantitySchema,
+	unit: string().min(1)
+});
 /** How a leaf compares a device field to a value. Derived from the field's
 *  `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
 var AutomationConditionOperatorSchema = _enum([
@@ -16064,8 +16536,10 @@ var AutomationConditionLeafSchema = object({
 		string(),
 		number(),
 		boolean(),
-		array(union([string(), number()]))
-	])
+		array(union([string(), number()])),
+		QuantityValueSchema
+	]),
+	unit: string().min(1).optional()
 });
 var AutomationConditionStationaryPresentSchema = object({
 	kind: literal("stationary-present"),
@@ -16218,7 +16692,13 @@ var AutomationCapStepSchema = 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: record(string(), unknown()).optional()
+	args: record(string(), 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: record(string(), string().min(1)).optional()
 });
 /**
 * The steps an internal Action may contain: cap and wait, and nothing that can
@@ -16598,6 +17078,16 @@ object({
 	lastRunAt: number().nullable(),
 	lastError: string().nullable()
 });
+/** A bare number accepted as a base unit — the save succeeded, say so. */
+var UnitWarningSchema = object({
+	/** Where in the saved record, e.g. `conditions.children.0` or `steps.2.args.grams`. */
+	path: string(),
+	deviceId: number().int().optional(),
+	field: string(),
+	value: number(),
+	assumedUnit: string(),
+	message: string()
+});
 /**
 * notification-output — canonical, capability-gated notification delivery.
 *
@@ -21970,56 +22460,6 @@ var DeviceAdminLinkSchema = object({
 });
 method(object({ deviceId: number().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" });
 /**
-* 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 = object({
-	/** Live dispatch key — mutable when the source system allows rename. */
-	id: string(),
-	/** Source system tag — e.g. 'homeassistant' | 'reolink' | 'onvif'. */
-	system: string(),
-	/** Immutable upstream identifier when available (HA `unique_id`, … ).
-	*  Used to detect rename when `id` changes. */
-	uniqueId: string().optional(),
-	/** Quantity of a polymorphic reading, written once at adopt (D944). */
-	quantity: ReadingQuantitySchema.optional(),
-	/** Date / time / datetime shape of a string reading, written once at adopt. */
-	dateTimeShape: _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: record(string(), unknown()).optional()
-});
-/**
 * device-discovery — device-scoped capability for parents that host /
 * enumerate child devices (Reolink Hub / NVR, ONVIF gateway, future
 * integrations). The parent advertises a list of discoverable children,
@@ -54772,11 +55212,13 @@ var ImageContractSchema = 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 = object({
 	kind: _enum([
@@ -54824,6 +55266,49 @@ var ServerRollbackInfoSchema = object({
 	reason: 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 = object({
+	/** The Electron app's own version (not the node closure's). */
+	version: string(),
+	update: object({
+		available: boolean(),
+		/** The new build is downloaded and `installDesktopUpdate` can apply it. */
+		downloaded: boolean(),
+		version: string().nullable(),
+		checking: boolean(),
+		/** Why the app's last update check produced no answer; `null` when it did. */
+		error: string().nullable()
+	}),
+	stateAtMs: number(),
+	stale: 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 = _enum([
+	"not-electron",
+	"no-app-state",
+	"app-state-stale",
+	"not-downloaded"
+]);
+var InstallDesktopUpdateResultSchema = object({
+	accepted: 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
@@ -54927,7 +55412,12 @@ var ServerPackageStatusSchema = 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 = object({
 	packageName: string(),
@@ -55032,6 +55522,9 @@ method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), S
 	kind: "mutation",
 	auth: "admin",
 	timeoutMs: 16 * 6e4
+}), method(_void(), InstallDesktopUpdateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(_void(), ServerUpdateActionResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -57979,13 +58472,19 @@ method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
 }), method(ActionIdInput, _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(ActionIdInput, object({ traces: array(AutomationRunTraceSchema) }), { auth: "admin" }), method(object({ action: ActionInputSchema }), object({ action: ActionEntrySchema }), {
+}), method(ActionIdInput, object({ traces: array(AutomationRunTraceSchema) }), { auth: "admin" }), method(object({ action: ActionInputSchema }), object({
+	action: ActionEntrySchema,
+	warnings: array(UnitWarningSchema).optional()
+}), {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
 	actionId: string().min(1),
 	action: ActionInputSchema.partial()
-}), object({ action: ActionEntrySchema }), {
+}), object({
+	action: ActionEntrySchema,
+	warnings: array(UnitWarningSchema).optional()
+}), {
 	kind: "mutation",
 	auth: "admin"
 }), method(ActionIdInput, _void(), {
@@ -62632,6 +63131,14 @@ var PetFeederDeviceStatusSchema = _enum([
 	"on_batteries"
 ]);
 var gramsPortion = 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"
+}));
 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
@@ -62706,9 +63213,9 @@ object({
 });
 DeviceType.PetFeeder, method(object({
 	deviceId: number().int().nonnegative(),
-	grams: gramsPortion.optional(),
-	hopper1: gramsPortion.optional(),
-	hopper2: gramsPortion.optional()
+	grams: gramsParam.optional(),
+	hopper1: gramsParam.optional(),
+	hopper2: gramsParam.optional()
 }), _void(), {
 	kind: "mutation",
 	auth: "protected"
@@ -75488,6 +75995,13 @@ 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",
@@ -79398,7 +79912,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}]
@@ -79417,7 +79932,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}, {
@@ -79428,7 +79944,8 @@ var APPLIANCE_CAP_VOCABULARY = {
 						min: 4,
 						max: 200,
 						step: 1,
-						unit: "g"
+						unit: "g",
+						quantity: "mass"
 					},
 					optional: true
 				}]