@camstack/addon-post-analysis 1.2.233 → 1.2.235

package/dist/pipeline-analytics/{hostInit-Dg-LBlut.mjs → hostInit-B5V7K95U.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.187",
+				version: "1.2.189",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -45,7 +45,7 @@ async function r() {
 				}
 			},
 			"@camstack/sdk": {
-				version: "1.2.103",
+				version: "1.2.105",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.152",
+				version: "1.2.154",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Dbf6ceXh.js");
+const require_dist = require("../dist-IoI_ufBo.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -7445,6 +7445,16 @@ var NcAlertStore = class {
 		};
 	}
 };
+function deriveConsumableBand(input) {
+	const { level, status } = input.reading;
+	const measured = level !== null && Number.isFinite(level);
+	if (!measured && status === null) return null;
+	if (status === "replace") return "low";
+	if (!measured) return "normal";
+	const value = level;
+	if (input.previous === "low") return value >= input.thresholdPercent + 5 ? "normal" : "low";
+	return value <= input.thresholdPercent ? "low" : "normal";
+}
 //#endregion
 //#region src/notification-center/device-directory.ts
 /**
@@ -9845,6 +9855,40 @@ function incomingFromBatteryBand(input) {
 	});
 }
 /**
+* A consumable BAND, as a system-event subject.
+*
+* Built exactly like {@link incomingFromBatteryBand} — the operator asked for
+* these to be treated as the battery notifications are — with two differences
+* that come from the subject and not from taste:
+*
+*  - **the subject carries the ITEM.** `consumable:<deviceId>:<key>`, because a
+*    vacuum has a brush AND a filter AND a mop pad, and one subject for all
+*    three would let the brush's alert cancel the filter's.
+*  - **the body variant follows what is KNOWN.** An item with no percentage
+*    gets a finished sentence rather than a template with a stand-in number in
+*    it, for the same reason a binary battery does.
+*
+* The recovery keeps the SAME subject: it is the same episode ending.
+*/
+function incomingFromConsumableBand(input) {
+	const kind = input.band === "low" ? "device-consumable-low" : "device-consumable-normal";
+	const measured = input.item.level !== null && Number.isFinite(input.item.level);
+	return systemSubject({
+		facts: input.facts,
+		kind,
+		subject: `consumable:${input.deviceId}:${input.item.key}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: measured ? `system.${kind}.body` : `system.${kind}.body.unmeasured`,
+		textParams: {
+			...deviceTextParams(input.deviceId, input.identity),
+			item: input.item.label,
+			...measured ? { percentage: String(Math.round(input.item.level)) } : {}
+		},
+		deviceId: input.deviceId,
+		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
+	});
+}
+/**
 * Normalize the infrastructure categories consumed by Notification Center.
 * Malformed payloads are rejected instead of guessing an identity.
 *
@@ -9996,6 +10040,7 @@ function incomingFromSystemEvent(event, lookup) {
 		}
 		case "system.restart-completed": return incomingFromServerUpdated(facts, data);
 		case "recording.export.completed": return incomingFromExportCompleted(facts, data);
+		case "backup.run-completed": return incomingFromBackupCompleted(facts, data);
 		default: return null;
 	}
 }
@@ -10159,6 +10204,37 @@ function incomingFromServerUpdated(facts, data) {
 		nodeIds: [nodeId]
 	});
 }
+/**
+* A finished backup RUN.
+*
+* Subject is the run, not the destination: `backup.completed` fires once per
+* destination and an operator with three of them would be told three times.
+* The counts travel in the text because a PARTIAL run must not read as a clean
+* one — two destinations of three is news, and a bare "backup completed" would
+* hide it.
+*/
+function incomingFromBackupCompleted(facts, data) {
+	const ok = numberField(data, "destinationsOk");
+	const total = numberField(data, "destinationsTotal");
+	if (ok === void 0 || total === void 0) return null;
+	const failed = numberField(data, "destinationsFailed") ?? Math.max(0, total - ok);
+	const sizeMB = numberField(data, "sizeMB");
+	const backupId = stringField(data, "backupId");
+	return systemSubject({
+		facts,
+		kind: "backup-completed",
+		subject: `backup:${backupId ?? facts.timestamp}`,
+		titleKey: "system.backup-completed.title",
+		bodyKey: failed > 0 ? "system.backup-completed.body.partial" : "system.backup-completed.body",
+		textParams: {
+			destinationsOk: String(ok),
+			destinationsTotal: String(total),
+			destinationsFailed: String(failed),
+			...sizeMB !== void 0 ? { sizeMB: String(sizeMB) } : {},
+			...backupId !== void 0 ? { backupId } : {}
+		}
+	});
+}
 function incomingFromExportCompleted(facts, data) {
 	const exportId = stringField(data, "exportId");
 	if (exportId === void 0) return null;
@@ -10496,6 +10572,8 @@ var NcDeviceAlerts = class {
 	* durable.
 	*/
 	lastReading = /* @__PURE__ */ new Map();
+	/** The last reading per consumable SUBJECT, for the reminder sweep. */
+	lastConsumable = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 		this.now = deps.now ?? Date.now;
@@ -10533,6 +10611,44 @@ var NcDeviceAlerts = class {
 		}));
 	}
 	/**
+	* ONE consumable item, from a device's `consumables` slice.
+	*
+	* Per ITEM, never per device: a vacuum has a brush, a filter and a mop pad,
+	* and folding them into one subject would make the brush's alert cancel the
+	* filter's — the same collision D141 split `device-switch:<id>` off liveness
+	* to avoid. Each item is its own episode, its own cooldown, its own recovery.
+	*
+	* An item that has told us nothing leaves EVERYTHING untouched, for the
+	* reason `observeBattery` does: seeding it healthy is a claim, and the first
+	* genuine `replace` would then read as a transition out of a state nobody
+	* observed.
+	*/
+	observeConsumable(deviceId, item) {
+		const subject = `consumable:${deviceId}:${item.key}`;
+		const previous = this.deps.rows.get(subject);
+		const settings = this.deps.settings();
+		const band = deriveConsumableBand({
+			reading: {
+				level: item.level,
+				status: item.status
+			},
+			thresholdPercent: settings.consumableLowPercent,
+			previous: previous?.alerting === true ? "low" : previous === void 0 ? void 0 : "normal"
+		});
+		if (band === null) return;
+		this.lastConsumable.set(subject, {
+			deviceId,
+			item
+		});
+		this.apply(subject, band === "low", settings, (facts, alerting) => incomingFromConsumableBand({
+			facts,
+			deviceId,
+			band: alerting ? "low" : "normal",
+			item,
+			identity: this.deps.lookup(deviceId)
+		}));
+	}
+	/**
 	* The reminder sweep. Called from an existing periodic tick; it allocates
 	* nothing on the healthy path.
 	*
@@ -10546,6 +10662,17 @@ var NcDeviceAlerts = class {
 		if (settings.renotifyMinutes <= 0) return;
 		for (const row of this.deps.rows.all()) {
 			if (!row.alerting) continue;
+			const consumable = this.lastConsumable.get(row.subject);
+			if (consumable !== void 0) {
+				this.apply(row.subject, true, settings, (facts) => incomingFromConsumableBand({
+					facts,
+					deviceId: consumable.deviceId,
+					band: "low",
+					item: consumable.item,
+					identity: this.deps.lookup(consumable.deviceId)
+				}));
+				continue;
+			}
 			const restatement = this.lastReading.get(row.subject);
 			if (restatement === void 0) continue;
 			this.apply(row.subject, true, settings, (facts) => incomingFromBatteryBand({
@@ -11654,6 +11781,15 @@ var en_default = {
 	"system.export-completed.title": "Export ready",
 	"system.export-completed.body": "The footage export is ready",
 	"system.export-completed.body.titled": "{{title}} is ready",
+	"system.backup-completed.title": "Backup completed",
+	"system.backup-completed.body": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations ({{sizeMB}} MB)",
+	"system.backup-completed.body.partial": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations — {{destinationsFailed}} failed",
+	"system.device-consumable-low.title": "Consumable low",
+	"system.device-consumable-low.body": "{{item}} on {{deviceName}} is at {{percentage}}%",
+	"system.device-consumable-low.body.unmeasured": "{{item}} on {{deviceName}} needs replacing",
+	"system.device-consumable-normal.title": "Consumable replaced",
+	"system.device-consumable-normal.body": "{{item}} on {{deviceName}} is back to {{percentage}}%",
+	"system.device-consumable-normal.body.unmeasured": "{{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",
@@ -11914,6 +12050,15 @@ var it_default = {
 	"system.export-completed.title": "Export pronto",
 	"system.export-completed.body": "L'export del filmato è pronto",
 	"system.export-completed.body.titled": "{{title}} è pronto",
+	"system.backup-completed.title": "Backup completato",
+	"system.backup-completed.body": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} ({{sizeMB}} MB)",
+	"system.backup-completed.body.partial": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} — {{destinationsFailed}} fallite",
+	"system.device-consumable-low.title": "Consumabile quasi esaurito",
+	"system.device-consumable-low.body": "{{item}} su {{deviceName}} è al {{percentage}}%",
+	"system.device-consumable-low.body.unmeasured": "{{item}} su {{deviceName}} va sostituito",
+	"system.device-consumable-normal.title": "Consumabile sostituito",
+	"system.device-consumable-normal.body": "{{item}} su {{deviceName}} è tornato al {{percentage}}%",
+	"system.device-consumable-normal.body.unmeasured": "{{item}} su {{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",
@@ -22237,6 +22382,7 @@ function alarmButtonKind(kind) {
 */
 var NC_DEVICE_ALERT_FALLBACK = {
 	batteryLowPercent: 20,
+	consumableLowPercent: 15,
 	renotifyMinutes: 720,
 	notifyRecovery: true
 };
@@ -22269,6 +22415,52 @@ 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
@@ -24317,6 +24509,11 @@ var NotificationCenter = class NotificationCenter {
 			this.deviceAlerts.observeBattery(battery.deviceId, battery.reading);
 			return;
 		}
+		const consumables = consumablesSliceOf(event);
+		if (consumables !== null) {
+			for (const item of consumables.items) this.deviceAlerts.observeConsumable(consumables.deviceId, item);
+			return;
+		}
 		const lookup = this.deviceDirectory.lookup();
 		const incoming = incomingFromSystemEvent(event, lookup);
 		if (incoming === null) {
@@ -25929,6 +26126,7 @@ var NotificationCenter = class NotificationCenter {
 	deviceAlertSettings() {
 		return this.deps.readDeviceAlertSettings?.() ?? {
 			batteryLowPercent: NC_DEVICE_ALERT_FALLBACK.batteryLowPercent,
+			consumableLowPercent: NC_DEVICE_ALERT_FALLBACK.consumableLowPercent,
 			renotifyMinutes: NC_DEVICE_ALERT_FALLBACK.renotifyMinutes,
 			notifyRecovery: NC_DEVICE_ALERT_FALLBACK.notifyRecovery
 		};
@@ -26544,6 +26742,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "addon-updated") return `packages:addon-updated:${scope.packageName ?? "pkg"}`;
 	if (kind === "server-updated") return `server-updated:${scope.nodeId ?? "hub"}`;
 	if (kind === "export-completed") return `export:${scope.deviceId ?? 0}`;
+	if (kind === "backup-completed") return "backup:test";
 	return `alarm:${scope.deviceId ?? 0}`;
 }
 /**
@@ -49947,6 +50146,19 @@ var DeviceAlertSettingsSchema = require_dist.object({
 	*/
 	batteryLowPercent: require_dist.number().int().min(1).max(99).default(20),
 	/**
+	* What counts as a nearly-exhausted CONSUMABLE — a filter, a brush, a mop pad.
+	*
+	* Its own number and not the battery's, because the two are different chores
+	* on different clocks: a battery at 20 % is hours from flat, a brush at 20 %
+	* is weeks from worn, and an operator who wants to be told early about one
+	* does not necessarily want to be told early about the other.
+	*
+	* Applies to the MEASURED side only. An item whose provider states a
+	* `replace` verdict is low whatever this says — the provider decided, and a
+	* threshold cannot talk it out of it (`alerts/consumable-band.ts`).
+	*/
+	consumableLowPercent: require_dist.number().int().min(1).max(99).default(15),
+	/**
 	* How long a still-true alert waits before it says itself again.
 	*
 	* **0 = say it once.** That is the behaviour of every other notification this
@@ -58592,7 +58804,9 @@ function stationaryEvidenceKey(deviceId, className, anchorId) {
 * refused is the FIRST thing it failed, not the last.
 */
 function evaluateStationaryEvidence(row, policy, classEnabled) {
-	const ratio = row.seen > 0 ? row.agreed / row.seen : 0;
+	const windowSeen = row.windowSeen + row.prevWindowSeen;
+	const windowAgreed = row.windowAgreed + row.prevWindowAgreed;
+	const ratio = windowSeen > 0 ? windowAgreed / windowSeen : 0;
 	const spanMs = row.lastAgreedAt - row.firstAgreedAt;
 	const base = {
 		agreed: row.agreed,
@@ -58626,6 +58840,36 @@ function evaluateStationaryEvidence(row, policy, classEnabled) {
 	};
 }
 /**
+* Slide the window forward to `now`.
+*
+* One bucket width past: the current bucket becomes the previous one and a
+* fresh one opens. TWO or more past: the candidate was not observed for the
+* whole window, so both buckets are empty — and an empty window answers `0`,
+* which is an honest "nothing recent to judge by" rather than a stale verdict.
+* The lifetime counters are untouched, so nothing a candidate has earned is
+* lost — only its claim about the present expires.
+*/
+function rotateWindow(row, now) {
+	const elapsed = now - row.windowStartedAt;
+	if (elapsed < 9e5) return row;
+	if (elapsed < 2 * 9e5) return {
+		...row,
+		prevWindowAgreed: row.windowAgreed,
+		prevWindowSeen: row.windowSeen,
+		windowAgreed: 0,
+		windowSeen: 0,
+		windowStartedAt: now
+	};
+	return {
+		...row,
+		prevWindowAgreed: 0,
+		prevWindowSeen: 0,
+		windowAgreed: 0,
+		windowSeen: 0,
+		windowStartedAt: now
+	};
+}
+/**
 * The candidate this observation belongs to: the same-class row whose anchor it
 * overlaps most, provided the overlap reaches `agreeIou`. Overlap is the ONLY
 * notion of sameness here, and it is the same {@link iou} the suppression gate
@@ -58659,15 +58903,19 @@ function matchEvidenceCandidate(rows, className, bbox, agreeIou) {
 */
 function foldObservation(row, observation, agrees, overlap) {
 	const seen = row.seen + 1;
+	const rotated = rotateWindow(row, observation.timestamp);
 	if (!agrees) return {
-		...row,
+		...rotated,
 		seen,
+		windowSeen: rotated.windowSeen + 1,
 		updatedAt: observation.timestamp
 	};
 	const improves = overlap >= iou(row.anchor, row.bestBbox);
 	return {
-		...row,
+		...rotated,
 		seen,
+		windowSeen: rotated.windowSeen + 1,
+		windowAgreed: rotated.windowAgreed + 1,
 		agreed: row.agreed + 1,
 		firstAgreedAt: Math.min(row.firstAgreedAt, observation.timestamp),
 		lastAgreedAt: Math.max(row.lastAgreedAt, observation.timestamp),
@@ -58691,6 +58939,11 @@ function newEvidenceRow(observation, anchorId) {
 		anchor: { ...observation.bbox },
 		agreed: 1,
 		seen: 1,
+		windowAgreed: 1,
+		windowSeen: 1,
+		prevWindowAgreed: 0,
+		prevWindowSeen: 0,
+		windowStartedAt: observation.timestamp,
 		firstAgreedAt: observation.timestamp,
 		lastAgreedAt: observation.timestamp,
 		bestBbox: { ...observation.bbox },
@@ -58829,6 +59082,11 @@ var StationaryEvidenceLedger = class {
 				anchor: { ...row.anchor },
 				agreed: row.agreed,
 				seen: row.seen,
+				windowAgreed: row.windowAgreed,
+				windowSeen: row.windowSeen,
+				prevWindowAgreed: row.prevWindowAgreed,
+				prevWindowSeen: row.prevWindowSeen,
+				windowStartedAt: row.windowStartedAt,
 				firstAgreedAt: row.firstAgreedAt,
 				lastAgreedAt: row.lastAgreedAt,
 				bestBbox: { ...row.bestBbox },
@@ -58857,6 +59115,11 @@ var StationaryEvidenceLedger = class {
 					anchor,
 					agreed: numberOr(data.agreed, 0),
 					seen: numberOr(data.seen, 0),
+					windowAgreed: numberOr(data.windowAgreed, 0),
+					windowSeen: numberOr(data.windowSeen, 0),
+					prevWindowAgreed: numberOr(data.prevWindowAgreed, 0),
+					prevWindowSeen: numberOr(data.prevWindowSeen, 0),
+					windowStartedAt: numberOr(data.windowStartedAt, updatedAt),
 					firstAgreedAt: numberOr(data.firstAgreedAt, updatedAt),
 					lastAgreedAt: numberOr(data.lastAgreedAt, updatedAt),
 					bestBbox,
@@ -67561,7 +67824,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_dist.EventCategory.UpdateAvailable,
 	require_dist.EventCategory.AddonUpdated,
 	require_dist.EventCategory.SystemRestartCompleted,
-	require_dist.EventCategory.RecordingExportCompleted
+	require_dist.EventCategory.RecordingExportCompleted,
+	require_dist.EventCategory.BackupRunCompleted
 ];
 /**
 * Install the addon's bus subscriptions. Identical set + relative order to the
@@ -70644,6 +70908,17 @@ function buildGlobalSettingsSchema(cap) {
 					default: DEVICE_ALERT_DEFAULTS.batteryLowPercent,
 					unit: "%"
 				},
+				{
+					type: "number",
+					key: "consumableLowPercent",
+					label: "Low consumable at",
+					description: "At or below this, a measured consumable — a filter, a brush, a mop pad — is nearly exhausted. Its own number rather than the battery’s: a battery at 20% is hours from flat, a brush at 20% is weeks from worn. An item whose device reports “replace” outright is announced whatever this says.",
+					min: 1,
+					max: 99,
+					step: 1,
+					default: DEVICE_ALERT_DEFAULTS.consumableLowPercent,
+					unit: "%"
+				},
 				{
 					type: "number",
 					key: "alertRenotifyMinutes",
@@ -76237,6 +76512,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			readDeviceAlertSettings: () => ({
 				batteryLowPercent: this.deviceAlertSettingsMirror.batteryLowPercent,
+				consumableLowPercent: this.deviceAlertSettingsMirror.consumableLowPercent,
 				renotifyMinutes: this.deviceAlertSettingsMirror.alertRenotifyMinutes,
 				notifyRecovery: this.deviceAlertSettingsMirror.alertNotifyRecovery
 			}),