@camstack/addon-post-analysis 1.2.234 → 1.2.237

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-DTRcLvW5.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}`;
 }
 /**
@@ -31654,7 +31853,8 @@ function analyseDebugTrack(inventory) {
 		}
 	}
 	if (closed && facts.bestEventId === void 0) out.push(finding("NO_BEST_EVENT", "info", "No representative event was chosen for this track."));
-	if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
+	if (facts.labelStepId === "detector:raw-class") out.push(finding("UNSCORED_LABEL", "info", `The label is the detector's raw class (${facts.label ?? facts.className}) — no scored classifier answered for this track.`));
+	else if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
 	if (thumbnailProvenance === "standin") out.push(finding("BEST_SHOT_STANDIN", "warn", "Best shot is a stand-in: a face/plate detail crop copied in because no frame of the subject was captured."));
 	if (thumbnailProvenance === "raster") out.push(finding("BEST_SHOT_RASTER", "info", "Best shot is a sub-native raster crop of the subject, not a native capture."));
 	return out;
@@ -31712,6 +31912,7 @@ function toFacts(track) {
 		className: track.className,
 		...track.label === void 0 ? {} : { label: track.label },
 		...track.labelScore === void 0 ? {} : { labelScore: track.labelScore },
+		...track.labelMeta?.stepId === void 0 ? {} : { labelStepId: track.labelMeta.stepId },
 		firstSeen: track.firstSeen,
 		lastSeen: track.lastSeen,
 		active: track.active,
@@ -47382,31 +47583,54 @@ var EventMediaService = class {
 //#endregion
 //#region src/shared/frame/crop-extractor.ts
 /**
-* Extracts a JPEG-encoded crop from a raw frame buffer using a normalized bounding box.
-* Coordinates are clamped to frame bounds to avoid out-of-range errors.
+* The ONE reading of a normalized box against a frame: round, then clamp so
+* the rectangle is inside the frame and never empty. Both extractors below
+* share it, so the JPEG half and the raw half can never disagree about WHICH
+* pixels the crop is — only about how they are encoded.
+*/
+function clampNormalizedBox(frameWidth, frameHeight, bbox) {
+	const left = Math.max(0, Math.min(Math.round(bbox.x * frameWidth), frameWidth - 1));
+	const top = Math.max(0, Math.min(Math.round(bbox.y * frameHeight), frameHeight - 1));
+	return {
+		left,
+		top,
+		width: Math.max(1, Math.min(Math.round(bbox.w * frameWidth), frameWidth - left)),
+		height: Math.max(1, Math.min(Math.round(bbox.h * frameHeight), frameHeight - top))
+	};
+}
+/**
+* Extracts a **JPEG-encoded** crop from a raw frame buffer using a normalized
+* bounding box. The name does not say JPEG; the return type is what you must
+* read. A caller whose surrounding frame is raw wants {@link extractCropRaw} —
+* handing this output on as raw pixels is what produced 717 `VipsImage: memory
+* area too small` failures and cost the fleet a day of group shots.
 */
 async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
-	const rawLeft = Math.round(bbox.x * frameWidth);
-	const rawTop = Math.round(bbox.y * frameHeight);
-	const rawWidth = Math.round(bbox.w * frameWidth);
-	const rawHeight = Math.round(bbox.h * frameHeight);
-	const left = Math.max(0, Math.min(rawLeft, frameWidth - 1));
-	const top = Math.max(0, Math.min(rawTop, frameHeight - 1));
-	const width = Math.max(1, Math.min(rawWidth, frameWidth - left));
-	const height = Math.max(1, Math.min(rawHeight, frameHeight - top));
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
 	return {
 		crop: await (0, sharp.default)(frameData, { raw: {
 			width: frameWidth,
 			height: frameHeight,
 			channels: 3
-		} }).extract({
-			left,
-			top,
-			width,
-			height
-		}).jpeg({ quality: 90 }).toBuffer(),
-		width,
-		height
+		} }).extract(rect).jpeg({ quality: 90 }).toBuffer(),
+		width: rect.width,
+		height: rect.height
+	};
+}
+/**
+* The same cut, raw in and **raw RGB out** — for a caller that carries a
+* `DecodedFrame` and must keep `format: 'rgb'` true of the bytes it holds.
+*/
+async function extractCropRaw(frameData, frameWidth, frameHeight, bbox) {
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
+	return {
+		data: await (0, sharp.default)(frameData, { raw: {
+			width: frameWidth,
+			height: frameHeight,
+			channels: 3
+		} }).extract(rect).raw().toBuffer(),
+		width: rect.width,
+		height: rect.height
 	};
 }
 //#endregion
@@ -49947,6 +50171,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 +58829,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 +58865,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 +58928,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 +58964,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 +59107,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 +59140,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 +67849,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 +70933,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",
@@ -72155,6 +72455,92 @@ var RawGlobalStoreMirror = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/summary/group-crop.ts
+/** Padding around the union, as a fraction of its own size. */
+var GROUP_CROP_PADDING = .12;
+/**
+* Smallest crop, per axis, as a fraction of the frame.
+*
+* A quarter. Below that a thumbnail stops being legible at the sizes the
+* gallery draws it, and the extra context costs nothing — the subjects stay the
+* dominant thing in the picture at this size.
+*/
+var MIN_CROP_FRACTION = .25;
+/**
+* The crop, or `null` when there is nothing to cut to — no visible member, or
+* a frame with no dimensions. `null` means the caller keeps the full frame,
+* which is the only honest answer when nobody could say where the group was.
+*/
+function groupCropRect(input) {
+	const { frameWidth: fw, frameHeight: fh } = input;
+	if (fw <= 0 || fh <= 0) return null;
+	const boxes = input.boxes.filter((b) => b.width > 0 && b.height > 0);
+	if (boxes.length === 0) return null;
+	let left = Number.POSITIVE_INFINITY;
+	let top = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	let bottom = Number.NEGATIVE_INFINITY;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.width);
+		bottom = Math.max(bottom, b.y + b.height);
+	}
+	const padX = (right - left) * GROUP_CROP_PADDING;
+	const padY = (bottom - top) * GROUP_CROP_PADDING;
+	let x0 = left - padX;
+	let y0 = top - padY;
+	let x1 = right + padX;
+	let y1 = bottom + padY;
+	const minW = fw * MIN_CROP_FRACTION;
+	const minH = fh * MIN_CROP_FRACTION;
+	if (x1 - x0 < minW) {
+		const cx = (x0 + x1) / 2;
+		x0 = cx - minW / 2;
+		x1 = cx + minW / 2;
+	}
+	if (y1 - y0 < minH) {
+		const cy = (y0 + y1) / 2;
+		y0 = cy - minH / 2;
+		y1 = cy + minH / 2;
+	}
+	const width = Math.min(x1 - x0, fw);
+	const height = Math.min(y1 - y0, fh);
+	const x = Math.max(0, Math.min(x0, fw - width));
+	const y = Math.max(0, Math.min(y0, fh - height));
+	return {
+		x: Math.round(x),
+		y: Math.round(y),
+		width: Math.round(width),
+		height: Math.round(height)
+	};
+}
+/**
+* Carry a crop computed on the DETECTION frame onto the NATIVE surface.
+*
+* The two are different sizes by construction: detection runs on a downscaled
+* frame and the group shot is fetched at up to 4096 px. Applying the rectangle
+* raw would cut a corner of the picture and call it the group — the failure
+* mode is silent and looks like a framing bug.
+*
+* Scaled per axis rather than by one factor, because the two surfaces are not
+* guaranteed to share an aspect, and clamped to the native frame so rounding
+* can never ask for a pixel that is not there.
+*/
+function scaleCropToFrame(crop, from, to) {
+	if (from.width <= 0 || from.height <= 0 || to.width <= 0 || to.height <= 0) return null;
+	const sx = to.width / from.width;
+	const sy = to.height / from.height;
+	const x = Math.max(0, Math.min(Math.round(crop.x * sx), to.width - 1));
+	const y = Math.max(0, Math.min(Math.round(crop.y * sy), to.height - 1));
+	return {
+		x,
+		y,
+		width: Math.max(1, Math.min(Math.round(crop.width * sx), to.width - x)),
+		height: Math.max(1, Math.min(Math.round(crop.height * sy), to.height - y))
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/summary/summary-score.ts
 /** A member whose own box is covered this much by others is hidden. */
 var OCCLUDED_COVER_FRACTION = .5;
@@ -72203,12 +72589,24 @@ function scoreSummaryFrame(input) {
 	const visible = present.filter((d) => coveredFraction(d.bbox, present.filter((o) => o !== d).map((o) => o.bbox)) < OCCLUDED_COVER_FRACTION);
 	if (visible.length === 0) return {
 		visible: 0,
-		quality: 0
+		quality: 0,
+		crop: null
 	};
 	const quality = visible.reduce((sum, d) => sum + memberQuality(d, input.frameWidth, input.frameHeight), 0) / visible.length;
+	const crop = groupCropRect({
+		boxes: visible.map((d) => ({
+			x: d.bbox.x,
+			y: d.bbox.y,
+			width: d.bbox.width,
+			height: d.bbox.height
+		})),
+		frameWidth: input.frameWidth,
+		frameHeight: input.frameHeight
+	});
 	return {
 		visible: visible.length,
-		quality
+		quality,
+		crop
 	};
 }
 /**
@@ -72328,6 +72726,54 @@ var GroupShotTracker = class {
 };
 //#endregion
 //#region src/pipeline-analytics/summary/group-shot-materialiser.ts
+/**
+* Apply the group crop to the native surface, or hand it back untouched.
+*
+* Every reason to skip is a reason NOT to guess: no rectangle, no detection
+* geometry to scale from, or a cropper this deployment does not have. The full
+* frame is worse than a crop and far better than a wrong crop.
+*/
+async function cropNative(native, input, deps) {
+	const crop = input.crop;
+	if (!crop || !deps.cropFrame) return native;
+	const fw = input.cropFrameWidth;
+	const fh = input.cropFrameHeight;
+	if (fw === void 0 || fh === void 0) return native;
+	const scaled = scaleCropToFrame(crop, {
+		width: fw,
+		height: fh
+	}, native);
+	if (scaled === null) return native;
+	if (scaled.width >= native.width && scaled.height >= native.height) return native;
+	try {
+		const cut = await deps.cropFrame(native, scaled);
+		if (cut === null) return native;
+		const expected = cut.width * cut.height * 3;
+		if (cut.format === "rgb" && cut.data.length !== expected) {
+			deps.logger.warn("group shot crop returned a surface that is not its geometry", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					summaryId: input.summaryId,
+					width: cut.width,
+					height: cut.height,
+					expectedBytes: expected,
+					gotBytes: cut.data.length
+				}
+			});
+			return native;
+		}
+		return cut;
+	} catch (err) {
+		deps.logger.warn("group shot crop failed — storing the full frame", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				summaryId: input.summaryId,
+				error: require_dist.errMsg(err)
+			}
+		});
+		return native;
+	}
+}
 async function persistSummaryGroupShot(deps, input) {
 	const { deviceId, summaryId, frameHandle } = input;
 	const drop = {
@@ -72361,7 +72807,8 @@ async function persistSummaryGroupShot(deps, input) {
 			});
 			return { kind: "ram-tier" };
 		}
-		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(native);
+		const surface = await cropNative(native, input, deps);
+		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(surface);
 		const keyFrameMediaId = await deps.media.putReplacing({
 			deviceId,
 			ownerKind: "summary",
@@ -76237,6 +76684,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
 			}),
@@ -79580,13 +80028,30 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				fetchNativeFullFrame: getNative,
 				encodeVariants: encodeKeyFrameVariants,
 				media: mediaStore,
-				logger: this.ctx.logger
+				logger: this.ctx.logger,
+				cropFrame: async (frame, rect) => {
+					const out = await extractCropRaw(frame.data, frame.width, frame.height, {
+						x: rect.x / frame.width,
+						y: rect.y / frame.height,
+						w: rect.width / frame.width,
+						h: rect.height / frame.height
+					});
+					return {
+						...frame,
+						data: out.data,
+						width: out.width,
+						height: out.height
+					};
+				}
 			}, {
 				deviceId,
 				summaryId,
 				timestamp: result.timestamp,
 				frameHandle,
-				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
+				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH,
+				crop: score.crop,
+				cropFrameWidth: result.frameWidth,
+				cropFrameHeight: result.frameHeight
 			})
 		}).then((outcome) => {
 			if (outcome?.kind === "landed") {