@camstack/addon-post-analysis 1.2.622 → 1.2.623

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-MHJ9BSUV.js");
+const require_clip_model_registry = require("../clip-model-registry-KKT83z9U.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -5414,41 +5414,106 @@ var NC_TRACKS_AT_INSTANT_LIMIT = 25;
 */
 var NC_TRACK_LIFE_SLACK_MS = 200;
 /**
+* A position this close to the instant is drawn as it is: one detection tick,
+* the same notion as {@link NC_TRACK_LIFE_SLACK_MS}. Anything farther is a
+* position of a MOVED subject, so it is either interpolated (a position on
+* each side inside the tolerance) or the track is left out — never drawn at a
+* later place than it was at the picture's instant.
+*/
+var NC_BOX_EXACT_MS = NC_TRACK_LIFE_SLACK_MS;
+/** The box at `timestamp`: a near position as is, else the bracketing pair interpolated. */
+function boxAt(positions, timestamp, toleranceMs) {
+	let nearest = null;
+	let before = null;
+	let after = null;
+	for (const p of positions) {
+		const d = p.timestamp - timestamp;
+		if (nearest === null || Math.abs(d) < Math.abs(nearest.timestamp - timestamp)) nearest = p;
+		if (d <= 0 && (before === null || p.timestamp > before.timestamp)) before = p;
+		if (d >= 0 && (after === null || p.timestamp < after.timestamp)) after = p;
+	}
+	if (nearest === null) return null;
+	const dt = nearest.timestamp - timestamp;
+	if (Math.abs(dt) <= NC_BOX_EXACT_MS) return {
+		bbox: nearest.bbox,
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: false
+	};
+	if (before === null || after === null || timestamp - before.timestamp > toleranceMs || after.timestamp - timestamp > toleranceMs) return null;
+	const span = after.timestamp - before.timestamp;
+	const f = span === 0 ? 0 : (timestamp - before.timestamp) / span;
+	const lerp = (a, b) => a + (b - a) * f;
+	return {
+		bbox: {
+			x: lerp(before.bbox.x, after.bbox.x),
+			y: lerp(before.bbox.y, after.bbox.y),
+			w: lerp(before.bbox.w, after.bbox.w),
+			h: lerp(before.bbox.h, after.bbox.h)
+		},
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: true
+	};
+}
+/**
 * Every source track ALIVE at `timestamp` (± {@link NC_TRACK_LIFE_SLACK_MS})
-* with a position within `toleranceMs` of it, its nearest box normalised,
-* deduplicated by track id (a live copy and a persisted copy of one track are
-* one track). Pure.
+* with a box AT that instant: a trail position within {@link NC_BOX_EXACT_MS},
+* else the linear interpolation of the positions bracketing it (each within
+* `toleranceMs`). A track with neither is not drawn — `onDrop` names it.
+* Deduplicated by track id (a live copy and a persisted copy are one track).
+* Pure.
 */
-function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims) {
+function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims, onDrop) {
 	const out = /* @__PURE__ */ new Map();
 	for (const track of sources) {
 		if (out.has(track.trackId)) continue;
-		if (track.firstSeen > timestamp + NC_TRACK_LIFE_SLACK_MS || track.lastSeen < timestamp - NC_TRACK_LIFE_SLACK_MS) continue;
+		if (track.firstSeen > timestamp + NC_TRACK_LIFE_SLACK_MS || track.lastSeen < timestamp - NC_TRACK_LIFE_SLACK_MS) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "outside-life"
+			});
+			continue;
+		}
 		const w = track.frameWidth ?? fallbackDims?.w ?? 0;
 		const h = track.frameHeight ?? fallbackDims?.h ?? 0;
-		if (w <= 0 || h <= 0) continue;
-		let best = null;
-		let bestDelta = Number.POSITIVE_INFINITY;
-		for (const p of track.positions) {
-			const delta = Math.abs(p.timestamp - timestamp);
-			if (delta < bestDelta) {
-				bestDelta = delta;
-				best = p;
-			}
+		if (w <= 0 || h <= 0) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-frame-dims"
+			});
+			continue;
+		}
+		const at = boxAt(track.positions, timestamp, toleranceMs);
+		if (at === null) {
+			const nearestDtMs = track.positions.reduce((best, p) => {
+				const d = p.timestamp - timestamp;
+				return best === void 0 || Math.abs(d) < Math.abs(best) ? d : best;
+			}, void 0);
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-position-near-instant",
+				...nearestDtMs !== void 0 ? { nearestDtMs } : {}
+			});
+			continue;
 		}
-		if (best === null || bestDelta > toleranceMs) continue;
 		const label = track.subLabel ?? track.label;
 		out.set(track.trackId, {
 			trackId: track.trackId,
 			className: track.className,
 			...label !== void 0 && label !== track.className ? { label } : {},
-			...best.score !== void 0 ? { confidence: best.score } : {},
+			...at.score !== void 0 ? { confidence: at.score } : {},
 			bbox: {
-				x: best.bbox.x / w,
-				y: best.bbox.y / h,
-				w: best.bbox.w / w,
-				h: best.bbox.h / h
-			}
+				x: at.bbox.x / w,
+				y: at.bbox.y / h,
+				w: at.bbox.w / w,
+				h: at.bbox.h / h
+			},
+			dtMs: at.dtMs,
+			interpolated: at.interpolated
 		});
 	}
 	return [...out.values()];
@@ -19350,11 +19415,16 @@ var DebugNoteArchiveStore = class {
 };
 //#endregion
 //#region src/pipeline-analytics/store/event-ledger-collection.ts
+/**
+* One event ledger (motion, audio, sensor, faces, plates …) over its
+* `ctx.records` kind. Every node has `ctx.records`, so there is no other path.
+*/
 /** Matches {@link EventStore.LEDGER_PAGE_SIZE} — kept local to avoid a circular import. */
 var LEDGER_PAGE_SIZE = 500;
 var EventLedgerCollection = class EventLedgerCollection {
 	collection;
 	kind;
+	records;
 	autoIntegerId;
 	legacyAtField;
 	deviceIdMode;
@@ -19370,6 +19440,7 @@ var EventLedgerCollection = class EventLedgerCollection {
 		this.logger = deps.logger;
 		this.deriveBody = deps.deriveBody;
 		this.indexFields = deps.definition.declaration.indexes.map((i) => i.fields);
+		this.records = deps.records;
 		const handle = deps.records.kind(deps.definition);
 		this.kind = handle;
 	}
@@ -19388,6 +19459,31 @@ var EventLedgerCollection = class EventLedgerCollection {
 		}
 		await this.kind.put(put);
 	}
+	/**
+	* `upsertRow` as an op of {@link EventLedgerCollection.transact}. A row that
+	* cannot be mapped THROWS here: inside a transaction a silently skipped write
+	* would let the rest of the call commit without it.
+	*/
+	async txUpsert(id, value) {
+		const put = this.buildRecordPut(id, value);
+		if (put === null) throw new require_clip_model_registry.InvalidRecordError(`${this.collection}/${id}: the record could not be mapped`);
+		return this.kind.txPut(put);
+	}
+	/** `update` as an op of {@link EventLedgerCollection.transact}. */
+	txUpdate(id, patch) {
+		return this.kind.txPatch(id, this.derived(patch, "patch"));
+	}
+	/** `deleteKey` as an op of {@link EventLedgerCollection.transact}. */
+	txDelete(id) {
+		return this.kind.txDelete(id);
+	}
+	/**
+	* Run ops (built by the `tx*` methods of ledgers whose kinds share a
+	* `transactFamily`) in ONE transaction: all land or none does.
+	*/
+	transact(ops) {
+		return this.records.transact(ops);
+	}
 	async insert(record) {
 		const idNum = this.autoIntegerId ? await this.kind.allocateId() : null;
 		const id = idNum !== null ? String(idNum) : typeof record["id"] === "string" ? record["id"] : null;
@@ -22329,8 +22425,9 @@ var RetrainAnnotationStore = class {
 	* The old rows' deletion, the new rows, the frame's `dismissed` set and its
 	* bumped `revision` run under a per-frame commit lock, guarded by
 	* `commit.fromRevision`: a concurrent save in this process leaves one winner
-	* and one `conflict` — never a blend. The steps are separate records writes,
-	* so a crash between them is NOT rolled back.
+	* and one `conflict` — never a blend. The deletion, the new rows and the frame
+	* row are ONE records `transact` (the four retrain kinds share a family): a
+	* failure leaves the frame exactly as it was.
 	*
 	* Returns the persisted rows so the caller renders ids it can address.
 	*/
@@ -22447,21 +22544,14 @@ var RetrainAnnotationStore = class {
 		}
 		return stamped;
 	}
-	/** Remove every annotation of a frame — the operator un-selecting it. */
-	async deleteForFrame(mediaKey) {
-		const rows = await this.listByFrame(mediaKey);
-		for (const row of rows) try {
-			await this.annotations.deleteKey(row.id);
-		} catch (err) {
-			this.logger.warn("retrain annotation delete failed", {
-				tags: { deviceId: row.deviceId },
-				meta: {
-					annotationId: row.id,
-					error: String(err)
-				}
-			});
-		}
-		return rows.length;
+	/**
+	* The delete ops of every annotation of a frame, for ONE transaction with
+	* the frame row and its memberships (RetrainService.removeFrame). A failed
+	* read THROWS: "no annotations" must never be the answer to an unreadable
+	* store, because the frame row would then be deleted over live boxes.
+	*/
+	async deleteOpsForFrame(mediaKey) {
+		return (await this.annotations.query({ where: { mediaKey } })).map((row) => this.annotations.txDelete(row.id));
 	}
 	async replaceForFrameOnRecords(mediaKey, rows, commit, nextRevision) {
 		const frame = await this.frames.get(mediaKey);
@@ -22474,12 +22564,14 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		await this.annotations.deleteWhere({ where: { mediaKey } });
-		for (const row of rows) await this.annotations.upsertRow(row.id, this.toRecord(row));
-		await this.frames.update(mediaKey, {
+		const ops = [];
+		for (const existing of await this.annotations.query({ where: { mediaKey } })) ops.push(this.annotations.txDelete(existing.id));
+		for (const row of rows) ops.push(await this.annotations.txUpsert(row.id, this.toRecord(row)));
+		ops.push(await this.frames.txUpdate(mediaKey, {
 			revision: nextRevision,
 			...commit.dismissed !== void 0 ? { dismissed: [...commit.dismissed] } : {}
-		});
+		}));
+		await this.frames.transact(ops);
 		return {
 			kind: "saved",
 			rows,
@@ -22497,8 +22589,10 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		for (const row of eligible) await this.annotations.update(row.id, { origin: origins.get(row.id) ?? null });
-		await this.frames.update(mediaKey, { revision: nextRevision });
+		const ops = [];
+		for (const row of eligible) ops.push(await this.annotations.txUpdate(row.id, { origin: origins.get(row.id) ?? null }));
+		ops.push(await this.frames.txUpdate(mediaKey, { revision: nextRevision }));
+		await this.frames.transact(ops);
 		return {
 			kind: "updated",
 			updated: eligible.length,
@@ -22669,16 +22763,16 @@ var RetrainCollectionStore = class {
 			}, counts.get(input.id) ?? 0)
 		};
 	}
-	/** Remove the collection and its memberships — members first, so a crash
-	*  never leaves memberships pointing at a name that no longer exists. */
+	/** Remove the collection and its memberships in ONE transaction: a failure
+	*  leaves the collection with all its members, never memberships pointing at
+	*  a name that no longer exists, nor a collection that silently lost some. */
 	async delete(id) {
 		if (await this.readRow(id) === null) return {
 			deleted: false,
 			memberFrameIds: []
 		};
 		const members = await this.memberships.query({ where: { collectionId: id } });
-		for (const m of members) await this.memberships.deleteKey(m.id);
-		await this.collections.deleteKey(id);
+		await this.collections.transact([...members.map((m) => this.memberships.txDelete(m.id)), this.collections.txDelete(id)]);
 		this.logger.info("retrain collection deleted", { meta: {
 			collectionId: id,
 			members: members.length
@@ -22707,11 +22801,29 @@ var RetrainCollectionStore = class {
 		await this.memberships.deleteKey(key);
 		return true;
 	}
-	/** Remove a frame from EVERY collection — the frame itself is leaving. */
-	async forgetFrame(frameId) {
-		const rows = await this.membershipRows({ frameId });
-		for (const r of rows) await this.memberships.deleteKey(r.id);
-		return rows.length;
+	/**
+	* The delete ops of every membership of a frame, for ONE transaction with
+	* the frame row and its annotations (RetrainService.removeFrame). A failed
+	* read THROWS: the frame row must not be deleted over memberships nobody
+	* could list.
+	*/
+	async forgetFrameOps(frameId) {
+		return (await this.memberships.query({ where: { frameId } })).map((r) => this.memberships.txDelete(r.id));
+	}
+	/**
+	* The op that adds a frame to a collection, for ONE transaction with the
+	* frame's own row (a still stored from the recording). `null` when it is
+	* already a member: there is nothing to write.
+	*/
+	async addFrameOp(input) {
+		const key = membershipKey(input.collectionId, input.frameId);
+		if (await this.memberships.get(key) !== null) return null;
+		return this.memberships.txUpsert(key, {
+			collectionId: input.collectionId,
+			frameId: input.frameId,
+			deviceId: input.deviceId,
+			addedAt: this.now()
+		});
 	}
 	/** The frames of a collection, in the order they were added. */
 	async listFrameIds(collectionId) {
@@ -23303,7 +23415,7 @@ var RetrainFrameStore = class {
 	* returned untouched; the blob lands before the row; a refusal is named.
 	* `capturedAt` IS the instant — the camera saw this frame then.
 	*/
-	async storeRecordingStill(input) {
+	async storeRecordingStill(input, withRow = []) {
 		const frameId = recordingFrameId(input.deviceId, input.epochMs);
 		const existing = await this.get(frameId);
 		if (existing !== null) return {
@@ -23350,7 +23462,7 @@ var RetrainFrameStore = class {
 				relativePath: path,
 				data: input.bytes
 			});
-			await this.ledger.upsertRow(frameId, {
+			const row = await this.ledger.txUpsert(frameId, {
 				deviceId: frame.deviceId,
 				trackId: "",
 				sourceMediaId: 0,
@@ -23367,6 +23479,7 @@ var RetrainFrameStore = class {
 				origin: "recording",
 				epochMs: input.epochMs
 			});
+			await this.ledger.transact([row, ...withRow]);
 		};
 		try {
 			if (this.writeGate) await this.writeGate.run(persist);
@@ -23420,22 +23533,33 @@ var RetrainFrameStore = class {
 	/**
 	* Drop a copy and its blob — the operator un-selecting a frame.
 	*
-	* The caller must have removed the frame's annotations first; this store does
-	* not cascade, because a store that deletes rows in another table on a
-	* best-effort write is how a half-deleted annotation set happens.
+	* The ROW goes first, in one transaction with `withRow` (the frame's
+	* annotations and collection memberships, which the caller builds): a failure
+	* leaves the frame, its boxes and its memberships all in place, and throws.
+	* The blob goes after: if that fails the row is already gone and the bytes
+	* are reclaimable junk, logged, never a row pointing at missing media.
 	*/
-	async deleteFrame(frame) {
+	async deleteFrame(frame, withRow = []) {
 		const remove = async () => {
+			try {
+				await this.ledger.transact([...withRow, this.ledger.txDelete(frame.frameId)]);
+			} catch (err) {
+				this.logger.error("retrain frame delete failed; nothing was removed", {
+					tags: { deviceId: frame.deviceId },
+					meta: {
+						frameId: frame.frameId,
+						error: String(err)
+					}
+				});
+				throw err;
+			}
 			try {
 				await this.storage.delete({
 					location: frame.locationId ?? LEGACY_RETRAIN_MEDIA_LOCATION,
 					relativePath: framePath(frame)
 				});
-			} catch {}
-			try {
-				await this.ledger.deleteKey(frame.frameId);
 			} catch (err) {
-				this.logger.warn("RetrainFrameStore.deleteFrame row delete failed", {
+				this.logger.warn("retrain frame removed but its blob could not be deleted", {
 					tags: { deviceId: frame.deviceId },
 					meta: {
 						frameId: frame.frameId,
@@ -28431,7 +28555,9 @@ function incomingFromSystemEvent(event, lookup) {
 			const blindForMs = numberField(data, "blindForMs");
 			if (deviceId === void 0 || blindForMs === void 0) return null;
 			const identity = lookup(deviceId);
-			const minutes = Math.max(1, Math.round(blindForMs / 6e4));
+			const motionMs = numberField(data, "motionMs") ?? blindForMs;
+			const sessions = numberField(data, "sessions") ?? 1;
+			const minutes = Math.max(1, Math.round(motionMs / 6e4));
 			return systemSubject({
 				facts,
 				kind: "detection-blind",
@@ -28440,13 +28566,39 @@ function incomingFromSystemEvent(event, lookup) {
 				bodyKey: "system.detection-blind.body",
 				textParams: {
 					...deviceTextParams(deviceId, identity),
-					minutes: String(minutes)
+					minutes: String(minutes),
+					sessions: String(sessions)
 				},
 				textCount: minutes,
 				deviceId,
 				...identity !== void 0 ? { deviceType: identity.type } : {}
 			});
 		}
+		case "pipeline.motion-noisy":
+		case "pipeline.motion-calm": {
+			const deviceId = numberField(data, "deviceId");
+			const dutyPct = numberField(data, "dutyPct");
+			const sessions = numberField(data, "sessions");
+			const windowMs = numberField(data, "windowMs");
+			if (deviceId === void 0 || dutyPct === void 0 || sessions === void 0 || windowMs === void 0) return null;
+			const noisy = event.category === "pipeline.motion-noisy";
+			const identity = lookup(deviceId);
+			return systemSubject({
+				facts,
+				kind: noisy ? "motion-noisy" : "motion-calm",
+				subject: `motion-noise:${deviceId}`,
+				titleKey: noisy ? "system.motion-noisy.title" : "system.motion-calm.title",
+				bodyKey: noisy ? "system.motion-noisy.body" : "system.motion-calm.body",
+				textParams: {
+					...deviceTextParams(deviceId, identity),
+					minutes: String(Math.max(1, Math.round(windowMs / 6e4))),
+					duty: String(dutyPct),
+					sessions: String(sessions)
+				},
+				deviceId,
+				...identity !== void 0 ? { deviceType: identity.type } : {}
+			});
+		}
 		case "recording.health.stalled": {
 			const deviceId = numberField(data, "deviceId");
 			const idleMs = numberField(data, "idleMs");
@@ -28564,7 +28716,7 @@ function incomingFromSystemEvent(event, lookup) {
 		case "system.restarting": return incomingFromNodeRestarting(facts, data);
 		case "recording.export.completed": return incomingFromExportCompleted(facts, data);
 		case "backup.run-completed": return incomingFromBackupCompleted(facts, data);
-		case "alert.episode": return incomingFromAlertEpisode(facts);
+		case "alert.episode": return incomingFromAlertEpisode(facts, lookup);
 		default: return null;
 	}
 }
@@ -28580,9 +28732,11 @@ function incomingFromSystemEvent(event, lookup) {
 * Whether an edge is notified at all (once per episode, reconciled from the
 * alerts store) is decided before this point, by `NcAlertEpisodeLedger`.
 */
-function incomingFromAlertEpisode(facts) {
+function incomingFromAlertEpisode(facts, lookup) {
 	const payload = require_clip_model_registry.parseAlertEpisodePayload(facts.data);
 	if (payload === null) return null;
+	const attention = incomingFromDeviceAttention(facts, payload, lookup);
+	if (attention !== null) return attention;
 	const kind = require_clip_model_registry.alertEpisodeKind(payload.severity, payload.phase);
 	if (kind === null) return null;
 	return systemSubject({
@@ -28603,6 +28757,38 @@ function incomingFromAlertEpisode(facts) {
 		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
 	});
 }
+/**
+* A CRITICAL alert whose source is a DEVICE (D911) is announced in the devices
+* family — `device-attention-required` / `-resolved`, carrying the device id so
+* a rule's device filters apply — and NOT as `alert-critical`, so one alert
+* never notifies twice through two families. A device source whose id is not a
+* device id falls through to the generic alert kinds.
+*/
+function incomingFromDeviceAttention(facts, payload, lookup) {
+	if (payload.sourceType !== "device" || payload.sourceId === void 0) return null;
+	const kind = require_clip_model_registry.deviceAttentionKind(payload.severity, payload.phase);
+	if (kind === null) return null;
+	const deviceId = Number(payload.sourceId);
+	if (!Number.isInteger(deviceId)) return null;
+	const identity = lookup?.(deviceId);
+	return systemSubject({
+		facts,
+		kind,
+		subject: `alert:${payload.episodeId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body`,
+		textParams: {
+			...deviceTextParams(deviceId, identity),
+			title: payload.title,
+			message: payload.message,
+			category: payload.category,
+			actionUrl: payload.actionUrl ?? ""
+		},
+		deviceId,
+		...identity !== void 0 ? { deviceType: identity.type } : {},
+		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
+	});
+}
 /** The shells whose update has its own sentence. Anything else gets the plain
 *  one: a body that names a shell nobody observed is worse than a vague body. */
 var WRAPPER_BODY_KINDS = new Set([
@@ -30593,9 +30779,13 @@ var en_default = {
 	"system.addon-crash-loop.body": "The {{addons}} addon on node {{nodeId}} crashed {{count}} times in a row and will NOT be restarted. Everything it provides is offline until it is repaired.",
 	"system.detection-blind.title": "Detecting nothing — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "Camera {{deviceName}} has been analysed for {{minutes}} minute with no detection at all",
-		"other": "Camera {{deviceName}} has been analysed for {{minutes}} minutes with no detection at all"
+		"one": "Camera {{deviceName}} moved for {{minutes}} minute over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate",
+		"other": "Camera {{deviceName}} moved for {{minutes}} minutes over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate"
 	},
+	"system.motion-noisy.title": "Constant motion, no subject — {{deviceName}}",
+	"system.motion-noisy.body": "Camera {{deviceName}} has been in motion {{duty}}% of the last {{minutes}} minutes ({{sessions}} sessions) without a single detection. The detector is fine — tune this camera's motion zones or sensitivity.",
+	"system.motion-calm.title": "Motion calm again — {{deviceName}}",
+	"system.motion-calm.body": "Camera {{deviceName}} is no longer in constant motion ({{duty}}% of the last {{minutes}} minutes, {{sessions}} sessions)",
 	"system.recording-stalled.title": "Recording stalled — {{deviceName}}",
 	"system.recording-stalled.body": {
 		"one": "Camera {{deviceName}} has not written a recording segment for {{minutes}} minute",
@@ -30605,6 +30795,10 @@ var en_default = {
 	"system.recording-healthy.body": "Camera {{deviceName}} is writing recording segments again",
 	"system.recording-degraded.title": "Recording degraded — {{deviceName}}",
 	"system.recording-degraded.body": "Camera {{deviceName}} exhausted its writer restart budget ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Resolved: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} no longer needs attention",
 	"system.storage-location-low.title": "Storage low — {{locationName}}",
 	"system.storage-location-low.body": "Location {{locationName}} is down to {{freePercent}}% free ({{reason}})",
 	"system.storage-location-critical.title": "Storage critical — {{locationName}}",
@@ -30993,6 +31187,10 @@ var it_default = {
 	"system.recording-healthy.body": "La camera {{deviceName}} scrive di nuovo i segmenti",
 	"system.recording-degraded.title": "Registrazione degradata — {{deviceName}}",
 	"system.recording-degraded.body": "La camera {{deviceName}} ha esaurito i riavvii del writer ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Risolto: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} non richiede più intervento",
 	"system.storage-location-low.title": "Storage basso — {{locationName}}",
 	"system.storage-location-low.body": "La location {{locationName}} è al {{freePercent}}% libero ({{reason}})",
 	"system.storage-location-critical.title": "Storage critico — {{locationName}}",
@@ -31001,9 +31199,13 @@ var it_default = {
 	"system.storage-location-ok.body": "La location {{locationName}} ha recuperato spazio libero",
 	"system.detection-blind.title": "Senza detection — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "La camera {{deviceName}} è analizzata da {{minutes}} minuto senza alcun rilevamento",
-		"other": "La camera {{deviceName}} è analizzata da {{minutes}} minuti senza alcun rilevamento"
+		"one": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuto in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole",
+		"other": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuti in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole"
 	},
+	"system.motion-noisy.title": "Movimento continuo senza soggetto — {{deviceName}}",
+	"system.motion-noisy.body": "La camera {{deviceName}} è stata in movimento il {{duty}}% degli ultimi {{minutes}} minuti ({{sessions}} sessioni) senza alcun rilevamento. Il detector funziona — regola le zone di movimento o la sensibilità di questa camera.",
+	"system.motion-calm.title": "Movimento di nuovo calmo — {{deviceName}}",
+	"system.motion-calm.body": "La camera {{deviceName}} non è più in movimento continuo ({{duty}}% degli ultimi {{minutes}} minuti, {{sessions}} sessioni)",
 	"system.addon-update-available.title": {
 		"one": "{{count}} aggiornamento addon disponibile",
 		"other": "{{count}} aggiornamenti addon disponibili"
@@ -33563,6 +33765,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-online" || kind === "node-offline") return `node:${scope.nodeId ?? "hub"}`;
 	if (kind === "node-inference-unavailable") return `node-inference:${scope.nodeId ?? "hub"}`;
 	if (kind === "detection-blind") return `detection-blind:${scope.deviceId ?? 0}`;
+	if (kind === "motion-noisy" || kind === "motion-calm") return `motion-noise:${scope.deviceId ?? 0}`;
 	if (kind === "addon-crash-loop") return `addon-crash:${scope.nodeId ?? "hub"}:${TEST_CRASHED_RUNNER}`;
 	if (kind === "addon-update-available" || kind === "server-update-available") return `package:${scope.packageName ?? "@camstack/server"}`;
 	if (kind === "wrapper-update-available") return `wrapper:${scope.nodeId ?? "hub"}`;
@@ -33708,6 +33911,8 @@ function planRuleTest(input) {
 					seconds: "30",
 					devices: "cuda:0",
 					minutes: "15",
+					duty: "55",
+					sessions: "96",
 					addons: TEST_CRASHED_RUNNER,
 					list: "@camstack/addon-pipeline 1.0.1 (current 1.0.0)",
 					nodes: "hub",
@@ -40365,7 +40570,17 @@ var NcNotificationImageStage = class {
 			...subjectBox,
 			label: imageLabelText(payload.subject.label ?? payload.subject.className, payload.subject.confidence)
 		} : null;
-		const others = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox, payload.subject.className).map((t) => ({
+		const othersDrawn = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox, payload.subject.className) : [];
+		if (mode === "scene-boxes") this.deps.logger.info("scene-boxes: other boxes drawn", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: entry.ruleId,
+				recordId: entry.recordId,
+				instant: source.timestamp,
+				drawn: othersDrawn.map((t) => `${t.trackId}/${t.className}/dt=${t.dtMs ?? "?"}ms/${t.interpolated === true ? "interpolated" : "exact"}`).join(",")
+			}
+		});
+		const others = mode === "scene-boxes" ? othersDrawn.map((t) => ({
 			...t.bbox,
 			label: imageLabelText(t.label ?? t.className, t.confidence),
 			...t.confidence !== void 0 ? { confidence: t.confidence } : {}
@@ -87732,7 +87947,12 @@ var RetrainCollectionService = class {
 				reason: "unknown-collection"
 			};
 		}
-		const stored = await this.storeStill(input.deviceId, input.epochMs);
+		const membershipOp = await this.deps.collections.addFrameOp({
+			collectionId: input.collectionId,
+			frameId: recordingFrameId(input.deviceId, input.epochMs),
+			deviceId: input.deviceId
+		});
+		const stored = await this.storeStill(input.deviceId, input.epochMs, membershipOp === null ? [] : [membershipOp]);
 		if (stored.kind === "refused") {
 			this.deps.logger.info("retrain collection add refused", {
 				tags,
@@ -87744,7 +87964,7 @@ var RetrainCollectionService = class {
 			});
 			return stored;
 		}
-		await this.deps.collections.addFrame({
+		if (stored.reused) await this.deps.collections.addFrame({
 			collectionId: input.collectionId,
 			frameId: stored.frame.frameId,
 			deviceId: input.deviceId
@@ -87809,7 +88029,7 @@ var RetrainCollectionService = class {
 		const ids = await this.deps.collections.listFrameIds(input.collectionId);
 		return this.deps.retrain.toWireFrames(await this.deps.frames.getMany(ids));
 	}
-	async storeStill(deviceId, epochMs) {
+	async storeStill(deviceId, epochMs, withRow) {
 		const existing = await this.deps.frames.get(recordingFrameId(deviceId, epochMs));
 		if (existing !== null) return {
 			kind: "stored",
@@ -87829,7 +88049,7 @@ var RetrainCollectionService = class {
 			deviceId,
 			epochMs,
 			bytes: still.jpeg
-		});
+		}, withRow);
 		return stored.kind === "copied" ? {
 			kind: "stored",
 			frame: stored.frame,
@@ -90152,9 +90372,9 @@ var RetrainService = class {
 			...this.frameUrls(updated.frameId)
 		};
 	}
-	/** Un-select: annotations first, then the copy. Never the other way round —
-	*  an annotation whose frame is gone is unopenable and unfixable. The frame's
-	*  collection memberships go with it. */
+	/** Un-select: the frame row, its annotations and its collection memberships
+	*  leave in one transaction (an annotation whose frame is gone is unopenable
+	*  and unfixable, so they never part); the blob is deleted after the row. */
 	async deselectFrame(input) {
 		const frame = await this.deps.frames.get(input.frameId);
 		if (frame === null) {
@@ -90173,11 +90393,16 @@ var RetrainService = class {
 			removedAnnotations: await this.removeFrame(frame)
 		};
 	}
-	/** Remove a frame from the dataset: annotations, memberships, then the copy. */
+	/**
+	* Remove a frame from the dataset. The frame row, its annotations and its
+	* collection memberships leave in ONE transaction (a failure removes nothing
+	* and throws); the blob is deleted after the row, never before.
+	*/
 	async removeFrame(frame) {
-		const removedAnnotations = await this.deps.annotations.deleteForFrame(frame.frameId);
-		await this.deps.memberships?.forgetFrame(frame.frameId);
-		await this.deps.frames.deleteFrame(frame);
+		const annotationOps = await this.deps.annotations.deleteOpsForFrame(frame.frameId);
+		const membershipOps = await this.deps.memberships?.forgetFrameOps(frame.frameId) ?? [];
+		await this.deps.frames.deleteFrame(frame, [...annotationOps, ...membershipOps]);
+		const removedAnnotations = annotationOps.length;
 		this.deps.logger.info("retrain frame removed from the dataset", {
 			tags: { deviceId: frame.deviceId },
 			meta: {
@@ -90371,7 +90596,8 @@ var RetrainService = class {
 	* The guarded replace. A caller that names the revision it saw gets exactly
 	* one attempt: a different current revision is a conflict, never a retry —
 	* the point is that it must look again. A caller that names none asked for
-	* last-write-wins, so a race lost between our read and the transaction is
+	* last-write-wins, so a race lost between our revision read and the records
+	* `transact` that commits the save (a per-frame lock serialises the two) is
 	* retried on the fresh revision, a bounded number of times.
 	*/
 	async replaceGuarded(frame, input, drafts, dismissed) {
@@ -103998,6 +104224,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_clip_model_registry.EventCategory.WorkerOffline,
 	require_clip_model_registry.EventCategory.PipelineNodeInferenceUnavailable,
 	require_clip_model_registry.EventCategory.PipelineDetectionBlind,
+	require_clip_model_registry.EventCategory.PipelineMotionNoisy,
+	require_clip_model_registry.EventCategory.PipelineMotionCalm,
 	require_clip_model_registry.EventCategory.RecordingHealthStalled,
 	require_clip_model_registry.EventCategory.RecordingHealthOk,
 	require_clip_model_registry.EventCategory.RecordingHealthDegraded,
@@ -107016,6 +107244,18 @@ Object.freeze({
 				"empty"
 			]
 		},
+		{
+			"path": "filterCleaningDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareRemainingRuns",
+			"valueType": "number"
+		},
 		{
 			"path": "halfLoad",
 			"valueType": "boolean"
@@ -116310,7 +116550,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 						since: timestamp - toleranceMs,
 						limit: NC_TRACKS_AT_INSTANT_LIMIT
 					});
-					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId));
+					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId), (drop) => this.ctx.logger.info("scene-boxes: other track not drawn", {
+						tags: { deviceId },
+						meta: {
+							trackId: drop.trackId,
+							className: drop.className,
+							reason: drop.reason,
+							instant: timestamp,
+							...drop.nearestDtMs !== void 0 ? { nearestDtMs: drop.nearestDtMs } : {}
+						}
+					}));
 				},
 				getDeviceName,
 				getDeviceLocation,