@camstack/addon-post-analysis 1.2.623 → 1.2.625

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-KKT83z9U.js");
+const require_clip_model_registry = require("../clip-model-registry-Bz5VWLtO.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -26036,6 +26036,83 @@ function deriveConsumableBand(input) {
 	return value <= input.thresholdPercent ? "low" : "normal";
 }
 //#endregion
+//#region src/notification-center/alerts/tank-band.ts
+/**
+* A TANK reduced to the only thing worth storing: its band (D642).
+*
+* A tank is a `supply` or `waste` item of a device's `consumables` slice
+* (D915 — before it, the four vacuum tanks lived on `vacuum-control`): a
+* vacuum's clean water, dirty water, detergent and dust bin, a dishwasher's
+* salt and rinse aid. `consumable-routing.ts` narrows the item's status to the
+* band vocabulary below. The operator asked for them to notify like
+* consumables: a supply running low, a waste tank full.
+*
+* ## The verdict is the provider's
+*
+* A tank's `status` is the device's own sensor (`ok` | `low` | `full`),
+* and it is the ONLY thing judged. The hub has no threshold for a tank level:
+* the rule for thresholds is that they belong to whoever generates the event,
+* and a tank that says `low` has already decided. A tank that reports only a
+* `level` is therefore not judged at all (`null`) rather than judged against a
+* number the hub would have to invent.
+*
+* ## `null` is the third answer, and it is not `normal`
+*
+* An unknown status says nothing — it neither opens nor closes an episode, for
+* the reason `battery-band.ts` gives: a reading nobody took is not evidence
+* that anything changed.
+*
+* Pure. No clock, no I/O.
+*/
+/**
+* The tanks with a sentence of their own (`system.device-tank-*.body.<key>`),
+* by their item key — the four a vacuum reports. Any other tank (salt, rinse
+* aid, …) is worded by its label (`body.item`).
+*/
+var NC_TANK_KEYS = [
+	"cleanWater",
+	"dirtyWater",
+	"detergent",
+	"dustBin"
+];
+function isNamedTankKey(key) {
+	return NC_TANK_KEYS.some((k) => k === key);
+}
+/**
+* How long a tank change must HOLD before it counts (D642 review M2).
+*
+* A float switch sloshing at the edge of `low` / `full` flips its status back
+* and forth while the robot moves; each flip is a durable transition, and
+* without a hold each one is a raise and a recovery on the operator's phone.
+* One minute is two reload ticks: long enough to outlast a slosh, short enough
+* that a genuinely full dust bin is said within a minute and a half.
+*/
+var NC_TANK_HOLD_MS = 6e4;
+function deriveTankBand(reading) {
+	switch (reading.status) {
+		case "low": return "low";
+		case "full": return "full";
+		case "ok": return "normal";
+		case null: return null;
+	}
+}
+/** `tank:<deviceId>:<key>` — the subject of one tank's episode. */
+function tankSubject(deviceId, key) {
+	return `tank:${String(deviceId)}:${key}`;
+}
+/** The parts of a tank subject, or `null` when it is not one. */
+function parseTankSubject(subject) {
+	const match = /^tank:(\d+):(.+)$/.exec(subject);
+	if (match === null) return null;
+	const deviceId = Number(match[1]);
+	const key = match[2];
+	if (!Number.isSafeInteger(deviceId) || key === void 0) return null;
+	return {
+		deviceId,
+		key
+	};
+}
+//#endregion
 //#region src/notification-center/device-directory.ts
 /**
 * WHO a device id is — the mirrored directory the system-event intake reads.
@@ -28398,26 +28475,28 @@ function incomingFromConsumableBand(input) {
 	});
 }
 /**
-* A vacuum TANK band, as a system-event subject (D642).
+* A TANK band, as a system-event subject (D642, D915).
 *
 * Built like {@link incomingFromConsumableBand}: `tank:<deviceId>:<tank>` is
 * one subject per tank (the dust bin's alert must not cancel the clean water's),
-* and the recovery keeps it. The BODY VARIANT names the tank in the reader's
-* language — the params are frozen before the language is known, so the tank's
-* name cannot be a param; `tank` carries the stable token for a custom
-* template.
+* and the recovery keeps it. For the four named vacuum tanks the BODY VARIANT
+* names the tank in the reader's language — the params are frozen before the
+* language is known, so the tank's name cannot be a param; `tank` carries the
+* stable token for a custom template. Any other tank (a dishwasher's salt, …)
+* is worded by the provider's label through `body.item`.
 */
 function incomingFromTankBand(input) {
 	const kind = input.band === "low" ? "device-tank-low" : input.band === "full" ? "device-tank-full" : "device-tank-normal";
 	return systemSubject({
 		facts: input.facts,
 		kind,
-		subject: `tank:${String(input.deviceId)}:${input.tank}`,
+		subject: tankSubject(input.deviceId, input.tank),
 		titleKey: `system.${kind}.title`,
-		bodyKey: `system.${kind}.body.${input.tank}`,
+		bodyKey: isNamedTankKey(input.tank) ? `system.${kind}.body.${input.tank}` : `system.${kind}.body.item`,
 		textParams: {
 			...deviceTextParams(input.deviceId, input.identity),
-			tank: input.tank
+			tank: input.tank,
+			item: input.label ?? input.tank
 		},
 		deviceId: input.deviceId,
 		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
@@ -29302,91 +29381,6 @@ function deliveryForKind(kind) {
 	return kind;
 }
 //#endregion
-//#region src/notification-center/alerts/tank-band.ts
-/**
-* A vacuum TANK reduced to the only thing worth storing: its band (D642).
-*
-* The `vacuum-control` slice carries four tanks — clean water, dirty water,
-* detergent, dust bin — each `null` when the hardware has none, else
-* `{ level, status }`. The operator asked for them to notify like consumables:
-* clean water / detergent running low, dirty water / dust bin full.
-*
-* ## The verdict is the provider's
-*
-* A tank's `status` is the device's own float switch (`ok` | `low` | `full`),
-* and it is the ONLY thing judged. The hub has no threshold for a tank level:
-* the rule for thresholds is that they belong to whoever generates the event,
-* and a tank that says `low` has already decided. A tank that reports only a
-* `level` is therefore not judged at all (`null`) rather than judged against a
-* number the hub would have to invent.
-*
-* ## `null` is the third answer, and it is not `normal`
-*
-* An unknown status says nothing — it neither opens nor closes an episode, for
-* the reason `battery-band.ts` gives: a reading nobody took is not evidence
-* that anything changed.
-*
-* Pure. No clock, no I/O.
-*/
-/** The four tanks `vacuum-control` names, by their slice field. */
-var NC_TANK_KEYS = [
-	"cleanWater",
-	"dirtyWater",
-	"detergent",
-	"dustBin"
-];
-/**
-* How long a tank change must HOLD before it counts (D642 review M2).
-*
-* A float switch sloshing at the edge of `low` / `full` flips its status back
-* and forth while the robot moves; each flip is a durable transition, and
-* without a hold each one is a raise and a recovery on the operator's phone.
-* One minute is two reload ticks: long enough to outlast a slosh, short enough
-* that a genuinely full dust bin is said within a minute and a half.
-*/
-var NC_TANK_HOLD_MS = 6e4;
-function deriveTankBand(reading) {
-	switch (reading.status) {
-		case "low": return "low";
-		case "full": return "full";
-		case "ok": return "normal";
-		case null: return null;
-	}
-}
-function isRecord$2(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function tankStatusOf(value) {
-	return value === "ok" || value === "low" || value === "full" ? value : null;
-}
-/**
-* A `device.state-changed` payload carrying a `vacuum-control` slice, reduced
-* to its tanks. `null` for any other cap. A tank the hardware does not have
-* (`null`) is skipped; a malformed field reads as unknown, never as a
-* fabricated verdict (D393: absent is not zero).
-*/
-function vacuumTanksOf(data) {
-	if (data["capName"] !== "vacuum-control") return null;
-	const deviceId = data["deviceId"];
-	const slice = data["slice"];
-	if (typeof deviceId !== "number" || !isRecord$2(slice)) return null;
-	const tanks = [];
-	for (const key of NC_TANK_KEYS) {
-		const raw = slice[key];
-		if (!isRecord$2(raw)) continue;
-		const level = raw["level"];
-		tanks.push({
-			key,
-			level: typeof level === "number" && Number.isFinite(level) ? level : null,
-			status: tankStatusOf(raw["status"])
-		});
-	}
-	return tanks.length === 0 ? null : {
-		deviceId,
-		tanks
-	};
-}
-//#endregion
 //#region src/notification-center/alerts/open-alert.ts
 /**
 * The raise of an episode whose reading has not arrived since the restart —
@@ -29424,13 +29418,13 @@ function unmeasuredEpisode(input) {
 		thresholdPercent: parts.thresholdPercent,
 		identity
 	});
-	const tank = NC_TANK_KEYS.find((key) => input.subject === `tank:${String(deviceId)}:${key}`);
-	if (tank === void 0) return null;
+	const tank = parseTankSubject(input.subject);
+	if (tank === null || tank.deviceId !== deviceId) return null;
 	return incomingFromTankBand({
 		facts,
 		deviceId,
 		band: input.detail === "full" ? "full" : "low",
-		tank,
+		tank: tank.key,
 		identity
 	});
 }
@@ -29507,7 +29501,7 @@ function deriveBatteryBand(input) {
 *    slice that already arrives on `device.state-changed`;
 *  - **consumable band** — `consumable@<threshold>:<deviceId>:<key>`, one
 *    episode per item per threshold a RULE asks for (D642);
-*  - **tank band** — `tank:<deviceId>:<tank>`, a vacuum's tanks, judged on the
+*  - **tank band** — `tank:<deviceId>:<tank>`, a supply / waste item (a vacuum's tanks, a dishwasher's salt), judged on the
 *    provider's own verdict (D642);
 *  - **the reminder tick** — the operator's "how often do you say it again".
 *
@@ -29658,7 +29652,8 @@ var NcDeviceAlerts = class {
 		for (const thresholdPercent of thresholds) this.judgeConsumable(deviceId, item, thresholdPercent, settings);
 	}
 	/**
-	* ONE vacuum tank, from a device's `vacuum-control` slice (D642).
+	* ONE tank — a `supply` / `waste` item of a device's `consumables` slice
+	* (D642; read from `consumables` since D915, `consumable-routing.ts`).
 	*
 	* The provider's verdict is the band (`tank-band.ts`); an unknown status
 	* leaves everything untouched, an open episode included.
@@ -29666,7 +29661,7 @@ var NcDeviceAlerts = class {
 	observeTank(deviceId, tank) {
 		const band = deriveTankBand(tank);
 		if (band === null) return;
-		const subject = `tank:${String(deviceId)}:${tank.key}`;
+		const subject = tankSubject(deviceId, tank.key);
 		this.lastTank.set(subject, {
 			deviceId,
 			tank
@@ -29677,6 +29672,7 @@ var NcDeviceAlerts = class {
 			deviceId,
 			band: alerting ? band : "normal",
 			tank: tank.key,
+			...tank.label !== void 0 ? { label: tank.label } : {},
 			identity: this.deps.lookup(deviceId)
 		}), band === "normal" ? void 0 : band);
 	}
@@ -29949,6 +29945,7 @@ var NcDeviceAlerts = class {
 			deviceId: tank.deviceId,
 			band: tankBand,
 			tank: tank.tank.key,
+			...tank.tank.label !== void 0 ? { label: tank.tank.label } : {},
 			identity: this.deps.lookup(tank.deviceId)
 		});
 		const battery = this.lastReading.get(subject);
@@ -30084,6 +30081,107 @@ function tagsOf(subject) {
 	return deviceId !== void 0 ? { tags: { deviceId } } : {};
 }
 //#endregion
+//#region src/notification-center/alerts/consumable-routing.ts
+function wearStatus(status) {
+	switch (status) {
+		case "replace":
+		case "low":
+		case "empty": return "replace";
+		case "ok": return "ok";
+		default: return null;
+	}
+}
+function supplyStatus(status) {
+	switch (status) {
+		case "low":
+		case "empty":
+		case "replace": return "low";
+		case "ok":
+		case "full": return "ok";
+		default: return null;
+	}
+}
+function wasteStatus(status) {
+	switch (status) {
+		case "full":
+		case "replace": return "full";
+		case "ok":
+		case "low":
+		case "empty": return "ok";
+		default: return null;
+	}
+}
+/** Which family judges this item, and the reading that family reads. */
+function routeConsumableItem(raw) {
+	const { key, label, level } = raw;
+	if (raw.kind === "supply" || raw.kind === "waste") return {
+		family: "tank",
+		tank: {
+			key,
+			label,
+			level,
+			status: raw.kind === "supply" ? supplyStatus(raw.status) : wasteStatus(raw.status)
+		}
+	};
+	return {
+		family: "consumable",
+		item: {
+			key,
+			label,
+			level,
+			status: wearStatus(raw.status)
+		}
+	};
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A `device.state-changed` carrying a `consumables` slice, routed by family;
+* `null` for any other event, a malformed slice or an empty list.
+*
+* An item is kept only when it carries a usable `key` — the subject is built
+* from it. `level` and `status` are each optional; an item with NEITHER is
+* still returned, because deciding that it has told us nothing belongs to the
+* band derivation and not to a parser (D393: absent is not zero).
+*/
+function consumablesSliceOf(event) {
+	if (event.category !== "device.state-changed") return null;
+	const data = event.data;
+	if (data["capName"] !== "consumables") return null;
+	const deviceId = data["deviceId"];
+	const slice = data["slice"];
+	if (typeof deviceId !== "number" || !isRecord$2(slice)) return null;
+	const rawItems = slice["items"];
+	if (!Array.isArray(rawItems)) return null;
+	const consumables = [];
+	const tanks = [];
+	for (const entry of rawItems) {
+		if (!isRecord$2(entry)) continue;
+		const key = entry["key"];
+		if (typeof key !== "string" || key.length === 0) continue;
+		const label = entry["label"];
+		const level = entry["level"];
+		const status = entry["status"];
+		const kind = entry["kind"];
+		const routed = routeConsumableItem({
+			key,
+			label: typeof label === "string" && label.length > 0 ? label : key,
+			level: typeof level === "number" && Number.isFinite(level) ? level : null,
+			status: typeof status === "string" ? status : null,
+			kind: typeof kind === "string" ? kind : void 0
+		});
+		if (routed.family === "tank") tanks.push(routed.tank);
+		else consumables.push(routed.item);
+	}
+	if (consumables.length === 0 && tanks.length === 0) return null;
+	return {
+		deviceId,
+		consumables,
+		tanks
+	};
+}
+//#endregion
 //#region src/notification-center/device-removal.ts
 /** The kinds whose rows can be about a device. */
 var NC_DEVICE_ROW_KINDS = [
@@ -30874,6 +30972,9 @@ var en_default = {
 	"system.device-tank-low.body.dustBin": "The dust bin on {{deviceName}} is running low",
 	"system.device-tank-full.body.dustBin": "The dust bin on {{deviceName}} is full",
 	"system.device-tank-normal.body.dustBin": "The dust bin on {{deviceName}} is OK again",
+	"system.device-tank-low.body.item": "{{item}} on {{deviceName}} is running low",
+	"system.device-tank-full.body.item": "{{item}} on {{deviceName}} is full",
+	"system.device-tank-normal.body.item": "{{item}} on {{deviceName}} is OK again",
 	"system.camera-online.title": "Device online",
 	"system.camera-online.body": "Device {{deviceName}} is online",
 	"system.camera-offline.title": "Device offline",
@@ -31275,6 +31376,9 @@ var it_default = {
 	"system.device-tank-low.body.dustBin": "Il contenitore della polvere di {{deviceName}} è quasi vuoto",
 	"system.device-tank-full.body.dustBin": "Il contenitore della polvere di {{deviceName}} è pieno",
 	"system.device-tank-normal.body.dustBin": "Il contenitore della polvere di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.item": "{{item}} di {{deviceName}} sta finendo",
+	"system.device-tank-full.body.item": "{{item}} di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.item": "{{item}} di {{deviceName}} è di nuovo a posto",
 	"system.camera-online.title": "Dispositivo online",
 	"system.camera-online.body": "Il dispositivo {{deviceName}} è online",
 	"system.camera-offline.title": "Dispositivo offline",
@@ -54223,52 +54327,6 @@ function batterySliceOf(event) {
 	};
 }
 /**
-* A `device.state-changed` carrying a CONSUMABLES slice, reduced to the items
-* the band derivation reads.
-*
-* Same tap as the battery's: `DeviceStateChanged` is already subscribed, so
-* every `consumables` write already arrives here and was simply dropped. No
-* new bus category and no producer change.
-*
-* An item is kept only when it carries a usable `key` — the subject is built
-* from it, and an item with no key could not be told apart from its sibling.
-* `level` and `status` are each optional; an item with NEITHER is still
-* returned, because deciding that it has told us nothing belongs to
-* `deriveConsumableBand` and not to a parser (D393: absent is not zero, and
-* the parser is not the place that judges).
-*/
-function consumablesSliceOf(event) {
-	if (event.category !== "device.state-changed") return null;
-	const data = event.data;
-	if (data["capName"] !== "consumables") return null;
-	const deviceId = data["deviceId"];
-	const slice = data["slice"];
-	if (typeof deviceId !== "number") return null;
-	if (typeof slice !== "object" || slice === null || Array.isArray(slice)) return null;
-	const rawItems = slice["items"];
-	if (!Array.isArray(rawItems)) return null;
-	const items = [];
-	for (const entry of rawItems) {
-		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
-		const row = entry;
-		const key = row["key"];
-		if (typeof key !== "string" || key.length === 0) continue;
-		const level = row["level"];
-		const status = row["status"];
-		const label = row["label"];
-		items.push({
-			key,
-			label: typeof label === "string" && label.length > 0 ? label : key,
-			level: typeof level === "number" ? level : null,
-			status: status === "ok" || status === "replace" ? status : null
-		});
-	}
-	return items.length === 0 ? null : {
-		deviceId,
-		items
-	};
-}
-/**
 * What `getAlarmConfig` answers on a node with no panel.
 *
 * The DEFAULTS, not zeroes: paired with `deviceId: null` this tells a client
@@ -57194,12 +57252,8 @@ var NotificationCenter = class {
 		}
 		const consumables = consumablesSliceOf(event);
 		if (consumables !== null) {
-			for (const item of consumables.items) this.deviceAlerts.observeConsumable(consumables.deviceId, item);
-			return;
-		}
-		const tanks = event.category === "device.state-changed" ? vacuumTanksOf(event.data) : null;
-		if (tanks !== null) {
-			for (const tank of tanks.tanks) this.deviceAlerts.observeTank(tanks.deviceId, tank);
+			for (const item of consumables.consumables) this.deviceAlerts.observeConsumable(consumables.deviceId, item);
+			for (const tank of consumables.tanks) this.deviceAlerts.observeTank(consumables.deviceId, tank);
 			return;
 		}
 		const lookup = this.deviceDirectory.lookup();
@@ -107226,24 +107280,6 @@ Object.freeze({
 			"path": "powerState",
 			"valueType": "string"
 		},
-		{
-			"path": "saltLevel",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"empty"
-			]
-		},
-		{
-			"path": "rinseAidLevel",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"empty"
-			]
-		},
 		{
 			"path": "filterCleaningDue",
 			"valueType": "boolean"
@@ -108269,58 +108305,6 @@ Object.freeze({
 			"path": "fanSpeed",
 			"valueType": "string"
 		},
-		{
-			"path": "cleanWater.level",
-			"valueType": "number"
-		},
-		{
-			"path": "cleanWater.status",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"full"
-			]
-		},
-		{
-			"path": "dirtyWater.level",
-			"valueType": "number"
-		},
-		{
-			"path": "dirtyWater.status",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"full"
-			]
-		},
-		{
-			"path": "detergent.level",
-			"valueType": "number"
-		},
-		{
-			"path": "detergent.status",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"full"
-			]
-		},
-		{
-			"path": "dustBin.level",
-			"valueType": "number"
-		},
-		{
-			"path": "dustBin.status",
-			"valueType": "enum",
-			"enumValues": [
-				"ok",
-				"low",
-				"full"
-			]
-		},
 		{
 			"path": "progressPercent",
 			"valueType": "number"