@camstack/addon-post-analysis 1.2.84 → 1.2.86

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-C_mhxTWT.js");
+const require_dist = require("../dist-Crk9pYee.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -1586,11 +1586,32 @@ var NC_ALARM_DECLARATION = {
 *   retention="pruned by NcArtifactStore's shelf bounds (14 d / 2000 rows / 2 GiB) — the index row falls with its bytes, on the producer node only (see prune(null) gate)"
 */
 var NC_ARTIFACTS_COLLECTION = "notification-center:artifacts";
-var NcArtifactKindSchema = require_dist._enum([
+/**
+* What an artefact IS. The schema lives in the ADDON, not in `packages/types`,
+* for the same reason the summary rule's does: it ships on `camstack deploy`
+* and never waits for a framework train.
+*
+* TWO groups:
+*  - **Gallery tiles** — what the operator browses (timelapse, gif, mp4, mosaic).
+*  - **Posters** — companion stills (`timelapse-preview`, `event-still`). They
+*    exist so a video/gif tile can name its thumbnail via `posterArtifactId`.
+*    They are not a filter chip and they are omitted from an unfiltered list.
+*/
+var NC_GALLERY_ARTIFACT_KINDS = [
 	"timelapse",
-	"timelapse-preview",
+	"event-gif",
+	"event-clip",
 	"summary-mosaic"
-]);
+];
+var NC_POSTER_ARTIFACT_KINDS = ["timelapse-preview", "event-still"];
+var NC_ARTIFACT_KINDS = [...NC_GALLERY_ARTIFACT_KINDS, ...NC_POSTER_ARTIFACT_KINDS];
+var NcArtifactKindSchema = require_dist._enum(NC_ARTIFACT_KINDS);
+/** Kind a notification attachment is filed under in the gallery. */
+function artifactKindForMediaType(mediaType) {
+	if (mediaType === "gif") return "event-gif";
+	if (mediaType === "video") return "event-clip";
+	return "event-still";
+}
 /**
 * How the viewer should DRAW it. Derived from the mime once, here, so no client
 * has to carry a mime table — and so a GIF that degraded to a JPEG is drawn as
@@ -1949,7 +1970,7 @@ var NcArtifactIndex = class {
 	}
 	buildFilter(query, viewer) {
 		const whereIn = { ...this.visibility(viewer).whereIn };
-		if (query.kinds !== void 0 && query.kinds.length > 0) whereIn["kind"] = [...query.kinds];
+		whereIn["kind"] = query.kinds !== void 0 && query.kinds.length > 0 ? [...query.kinds] : [...NC_GALLERY_ARTIFACT_KINDS];
 		if (query.deviceIds !== void 0 && query.deviceIds.length > 0) whereIn["deviceId"] = [...query.deviceIds];
 		const whereBetween = {
 			capturedAt: [query.fromMs ?? TIME_MIN, query.toMs ?? TIME_MAX],
@@ -5694,7 +5715,7 @@ var NcAudioStillShelf = class {
 	}
 	async fetch(captureId, deviceId, atMs) {
 		try {
-			const shot = await withTimeout$2(this.deps.getSnapshot(deviceId), SNAPSHOT_TIMEOUT_MS);
+			const shot = await withTimeout$3(this.deps.getSnapshot(deviceId), SNAPSHOT_TIMEOUT_MS);
 			if (shot === null || shot.base64.length === 0) {
 				this.reportMiss(deviceId, "the camera returned no snapshot");
 				return;
@@ -5760,7 +5781,7 @@ function audioStillMedia(data, timestamp) {
 	];
 }
 /** Reject if `promise` does not settle within `ms`. */
-function withTimeout$2(promise, ms) {
+function withTimeout$3(promise, ms) {
 	return new Promise((resolve, reject) => {
 		const timer = setTimeout(() => {
 			reject(/* @__PURE__ */ new Error(`snapshot cap timed out after ${String(ms)}ms`));
@@ -7769,10 +7790,24 @@ function matchesSystemEvent(condition, subject) {
 	if (!condition.kinds.includes(subject.kind)) return false;
 	if (condition.deviceIds !== void 0 && (subject.deviceId === void 0 || !condition.deviceIds.includes(subject.deviceId))) return false;
 	if (condition.deviceTypes !== void 0 && (subject.deviceType === void 0 || !condition.deviceTypes.includes(subject.deviceType))) return false;
-	if (condition.nodeIds !== void 0 && (subject.nodeId === void 0 || !condition.nodeIds.includes(subject.nodeId))) return false;
-	if (condition.packageNames !== void 0 && (subject.packageName === void 0 || !condition.packageNames.includes(subject.packageName))) return false;
+	if (condition.nodeIds !== void 0) {
+		if (!subjectNodes(subject).some((id) => condition.nodeIds.includes(id))) return false;
+	}
+	if (condition.packageNames !== void 0) {
+		if (!subjectPackages(subject).some((name) => condition.packageNames.includes(name))) return false;
+	}
 	return true;
 }
+function subjectNodes(subject) {
+	const ids = [...subject.nodeIds ?? []];
+	if (subject.nodeId !== void 0 && !ids.includes(subject.nodeId)) ids.push(subject.nodeId);
+	return ids;
+}
+function subjectPackages(subject) {
+	const names = [...subject.packageNames ?? []];
+	if (subject.packageName !== void 0 && !names.includes(subject.packageName)) names.push(subject.packageName);
+	return names;
+}
 function evaluateRule(rule, subject, deviceState, zoneOwners, sceneStates) {
 	if (subject.kind === "system-event") {
 		if (rule.delivery !== "system-event") return fail("delivery");
@@ -8229,12 +8264,30 @@ var en_default = {
 		"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"
 	},
-	"system.addon-update-available.title": "Addon update available",
-	"system.addon-update-available.body": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}})",
+	"system.addon-update-available.title": {
+		"one": "{{count}} addon update available",
+		"other": "{{count}} addon updates available"
+	},
+	"system.addon-update-available.body": "{{list}}",
 	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}}) on node {{nodeId}}",
-	"system.server-update-available.title": "Server update available",
+	"system.server-update-available.title": {
+		"one": "Server update available on {{count}} node",
+		"other": "Server update available on {{count}} nodes"
+	},
 	"system.server-update-available.body": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}})",
 	"system.server-update-available.body.onNode": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}}) on node {{nodeId}}",
+	"system.server-update-available.body.onNodes": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}}) on {{nodes}}",
+	"system.addon-updated.title": {
+		"one": "{{count}} addon updated",
+		"other": "{{count}} addons updated"
+	},
+	"system.addon-updated.body": "{{list}}",
+	"system.server-updated.title": "Server updated",
+	"system.server-updated.body": "{{packageName}} on {{nodeId}} is now {{toVersion}} (was {{fromVersion}})",
+	"system.server-updated.body.plain": "{{packageName}} on {{nodeId}} was updated",
+	"system.export-completed.title": "Export ready",
+	"system.export-completed.body": "The footage export is ready",
+	"system.export-completed.body.titled": "{{title}} is ready",
 	"system.camera-online.title": "Device online",
 	"system.camera-online.body": "Device {{deviceName}} is online",
 	"system.camera-offline.title": "Device offline",
@@ -8423,12 +8476,30 @@ var it_default = {
 		"one": "La camera {{deviceName}} è analizzata da {{minutes}} minuto senza alcun rilevamento",
 		"other": "La camera {{deviceName}} è analizzata da {{minutes}} minuti senza alcun rilevamento"
 	},
-	"system.addon-update-available.title": "Aggiornamento addon disponibile",
-	"system.addon-update-available.body": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}})",
+	"system.addon-update-available.title": {
+		"one": "{{count}} aggiornamento addon disponibile",
+		"other": "{{count}} aggiornamenti addon disponibili"
+	},
+	"system.addon-update-available.body": "{{list}}",
 	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}}) sul nodo {{nodeId}}",
-	"system.server-update-available.title": "Aggiornamento server disponibile",
+	"system.server-update-available.title": {
+		"one": "Aggiornamento server disponibile su {{count}} nodo",
+		"other": "Aggiornamento server disponibile su {{count}} nodi"
+	},
 	"system.server-update-available.body": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}})",
 	"system.server-update-available.body.onNode": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}}) sul nodo {{nodeId}}",
+	"system.server-update-available.body.onNodes": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}}) su {{nodes}}",
+	"system.addon-updated.title": {
+		"one": "{{count}} addon aggiornato",
+		"other": "{{count}} addon aggiornati"
+	},
+	"system.addon-updated.body": "{{list}}",
+	"system.server-updated.title": "Server aggiornato",
+	"system.server-updated.body": "{{packageName}} sul nodo {{nodeId}} è ora {{toVersion}} (era {{fromVersion}})",
+	"system.server-updated.body.plain": "{{packageName}} sul nodo {{nodeId}} è stato aggiornato",
+	"system.export-completed.title": "Export pronto",
+	"system.export-completed.body": "L'export del filmato è pronto",
+	"system.export-completed.body.titled": "{{title}} è pronto",
 	"system.camera-online.title": "Dispositivo online",
 	"system.camera-online.body": "Il dispositivo {{deviceName}} è online",
 	"system.camera-offline.title": "Dispositivo offline",
@@ -9155,7 +9226,7 @@ var NcDispatcher = class {
 			vars: { body: rendered },
 			frozen: rendered
 		}) : rendered;
-		const attachments = [...await this.withArtifactUrls(await this.resolveAttachments(entry)), ...frozenArtifactAttachments(entry)];
+		const attachments = [...await this.withArtifactUrls(entry, await this.resolveAttachments(entry)), ...frozenArtifactAttachments(entry)];
 		const params = pickParams(entry.payload.params);
 		const actions = await this.mintActions(entry, target);
 		return {
@@ -9216,11 +9287,39 @@ var NcDispatcher = class {
 			}
 		});
 	}
-	async withArtifactUrls(attachments) {
+	async withArtifactUrls(entry, attachments) {
+		const index = this.deps.indexArtifact;
 		const publish = this.deps.publishArtifact;
-		if (publish === void 0) return [...attachments];
+		if (index === void 0 && publish === void 0) return [...attachments];
 		const out = [];
+		let posterId = null;
+		const deviceId = entry.payload.subject.deviceId;
+		const common = {
+			deviceId: deviceId > 0 ? deviceId : null,
+			deviceIds: deviceId > 0 ? [deviceId] : [],
+			capturedAt: entry.payload.subject.timestamp,
+			ruleId: entry.ruleId,
+			ruleName: entry.payload.ruleName
+		};
 		for (const att of attachments) {
+			if (index !== void 0) {
+				const kind = artifactKindForMediaType(att.mediaType);
+				const meta = {
+					...common,
+					kind,
+					...posterId !== null && kind !== "event-still" ? { posterArtifactId: posterId } : {}
+				};
+				const pub = await index(att.bytes, att.mime, meta).catch(() => ({
+					url: null,
+					artifactId: null
+				}));
+				if (kind === "event-still" && pub.artifactId !== null) posterId = pub.artifactId;
+				out.push(pub.url === null ? { ...att } : {
+					...att,
+					url: pub.url
+				});
+				continue;
+			}
 			const url = await publish(att.bytes, att.mime).catch(() => null);
 			out.push(url === null ? { ...att } : {
 				...att,
@@ -9834,6 +9933,16 @@ function stringField(data, key) {
 	const value = data[key];
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function stringList(data, key) {
+	const raw = data[key];
+	if (!Array.isArray(raw)) return [];
+	const ids = [];
+	for (const item of raw) {
+		if (typeof item === "string" && item.length > 0 && !ids.includes(item)) ids.push(item);
+		if (ids.length >= 20) break;
+	}
+	return ids;
+}
 function numberField(data, key) {
 	const value = data[key];
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
@@ -9977,6 +10086,8 @@ function systemSubject(input) {
 				...input.deviceType !== void 0 ? { deviceType: input.deviceType } : {},
 				...input.nodeId !== void 0 ? { nodeId: input.nodeId } : {},
 				...input.packageName !== void 0 ? { packageName: input.packageName } : {},
+				...input.nodeIds !== void 0 ? { nodeIds: input.nodeIds } : {},
+				...input.packageNames !== void 0 ? { packageNames: input.packageNames } : {},
 				...input.textCount !== void 0 ? { textCount: input.textCount } : {},
 				...input.alarmSource !== void 0 ? { alarmSource: input.alarmSource } : {},
 				data
@@ -10153,34 +10264,189 @@ function incomingFromSystemEvent(event, lookup) {
 				...identity !== void 0 ? { deviceType: identity.type } : {}
 			});
 		}
-		case "update.available": {
-			const target = stringField(data, "target");
-			const packageName = stringField(data, "packageName");
-			const currentVersion = stringField(data, "currentVersion");
-			const latestVersion = stringField(data, "latestVersion");
-			if (target !== "addon" && target !== "server" || packageName === void 0 || currentVersion === void 0 || latestVersion === void 0) return null;
-			const addon = target === "addon";
-			const nodeId = stringField(data, "nodeId");
-			const nodeScope = nodeId ?? "hub";
-			const kind = addon ? "addon-update-available" : "server-update-available";
-			return systemSubject({
-				facts,
-				kind,
-				subject: addon ? `package:${nodeScope}:${packageName}` : `package:${packageName}`,
-				titleKey: `system.${kind}.title`,
-				bodyKey: nodeId !== void 0 ? `system.${kind}.body.onNode` : `system.${kind}.body`,
-				textParams: {
-					packageName,
-					currentVersion,
-					latestVersion,
-					...nodeId !== void 0 ? { nodeId } : {}
-				},
+		case "update.available": return incomingFromUpdateAvailable(facts, data);
+		case "addon.updated": {
+			const update = parseAddonUpdateComplete(data);
+			return update === null ? null : incomingFromAddonUpdates(facts, [update]);
+		}
+		case "system.restart-completed": return incomingFromServerUpdated(facts, data);
+		case "recording.export.completed": return incomingFromExportCompleted(facts, data);
+		default: return null;
+	}
+}
+function incomingFromUpdateAvailable(facts, data) {
+	const target = stringField(data, "target");
+	if (target !== "addon" && target !== "server") return null;
+	const packages = updatePackages(data);
+	if (packages.length === 0) return null;
+	const addon = target === "addon";
+	const kind = addon ? "addon-update-available" : "server-update-available";
+	const nodeIds = unique(packages.map((pkg) => pkg.nodeId).filter((id) => id !== void 0));
+	const packageNames = unique(packages.map((pkg) => pkg.packageName));
+	const signature = packages.map((pkg) => `${pkg.nodeId ?? ""}:${pkg.packageName}@${pkg.latestVersion}`).toSorted().join(",");
+	const list = packages.map(formatAvailableLine).join("\n");
+	const nodes = nodeIds.join(", ");
+	const head = packages[0];
+	const oneNode = nodeIds.length === 1 ? nodeIds[0] : void 0;
+	return systemSubject({
+		facts,
+		kind,
+		subject: addon ? `packages:addon:${signature}` : `packages:server:${signature}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: !addon && oneNode !== void 0 ? `system.${kind}.body.onNode` : !addon && nodeIds.length > 1 ? `system.${kind}.body.onNodes` : `system.${kind}.body`,
+		textParams: {
+			list,
+			packageName: head.packageName,
+			currentVersion: head.currentVersion,
+			latestVersion: head.latestVersion,
+			nodes,
+			count: String(addon ? packages.length : nodeIds.length > 0 ? nodeIds.length : 1),
+			...oneNode !== void 0 ? { nodeId: oneNode } : {}
+		},
+		textCount: addon ? packages.length : nodeIds.length > 0 ? nodeIds.length : 1,
+		packageName: head.packageName,
+		packageNames,
+		...oneNode !== void 0 ? { nodeId: oneNode } : {},
+		...nodeIds.length > 0 ? { nodeIds } : {}
+	});
+}
+/** Version-bearing `addon.updated` only — settings saves carry neither. */
+function parseAddonUpdateComplete(data) {
+	const packageName = stringField(data, "packageName");
+	const fromVersion = stringField(data, "fromVersion");
+	const toVersion = stringField(data, "toVersion");
+	if (packageName === void 0 || fromVersion === void 0 || toVersion === void 0) return null;
+	const nodeId = stringField(data, "agent") ?? stringField(data, "nodeId");
+	return {
+		packageName,
+		fromVersion,
+		toVersion,
+		...nodeId !== void 0 ? { nodeId } : {}
+	};
+}
+function incomingFromAddonUpdates(facts, updates) {
+	if (updates.length === 0) return null;
+	const packageNames = unique(updates.map((update) => update.packageName));
+	const nodeIds = unique(updates.map((update) => update.nodeId).filter((id) => id !== void 0));
+	const signature = updates.map((update) => `${update.nodeId ?? ""}:${update.packageName}@${update.toVersion}`).toSorted().join(",");
+	const list = updates.map((update) => update.nodeId !== void 0 ? `${update.packageName} ${update.fromVersion} → ${update.toVersion} (${update.nodeId})` : `${update.packageName} ${update.fromVersion} → ${update.toVersion}`).join("\n");
+	const head = updates[0];
+	return systemSubject({
+		facts,
+		kind: "addon-updated",
+		subject: `packages:addon-updated:${signature}`,
+		titleKey: "system.addon-updated.title",
+		bodyKey: "system.addon-updated.body",
+		textParams: {
+			list,
+			count: String(packageNames.length)
+		},
+		textCount: packageNames.length,
+		packageName: head.packageName,
+		packageNames,
+		...head.nodeId !== void 0 ? { nodeId: head.nodeId } : {},
+		...nodeIds.length > 0 ? { nodeIds } : {}
+	});
+}
+function incomingFromServerUpdated(facts, data) {
+	const kind = stringField(data, "kind");
+	const requestedBy = stringField(data, "requestedBy");
+	if (!(kind === "framework-update" || kind === "framework-bulk-update" || requestedBy !== void 0 && requestedBy.startsWith("server-update:"))) return null;
+	const packageName = stringField(data, "packageName") ?? "@camstack/server";
+	const fromVersion = stringField(data, "fromVersion");
+	const toVersion = stringField(data, "toVersion") ?? versionFromRequestedBy(requestedBy);
+	const nodeId = stringField(data, "nodeId") ?? "hub";
+	const bodyKey = fromVersion !== void 0 && toVersion !== void 0 ? "system.server-updated.body" : "system.server-updated.body.plain";
+	return systemSubject({
+		facts,
+		kind: "server-updated",
+		subject: `server-updated:${nodeId}:${toVersion ?? "unknown"}`,
+		titleKey: "system.server-updated.title",
+		bodyKey,
+		textParams: {
+			packageName,
+			nodeId,
+			...fromVersion !== void 0 ? { fromVersion } : {},
+			...toVersion !== void 0 ? { toVersion } : {}
+		},
+		packageName,
+		nodeId,
+		nodeIds: [nodeId]
+	});
+}
+function incomingFromExportCompleted(facts, data) {
+	const exportId = stringField(data, "exportId");
+	if (exportId === void 0) return null;
+	const deviceId = numberField(data, "deviceId");
+	const title = stringField(data, "title");
+	const bytes = numberField(data, "fileBytes");
+	const notifyTargetIds = stringList(data, "notifyTargetIds");
+	const incoming = systemSubject({
+		facts,
+		kind: "export-completed",
+		subject: `export:${exportId}`,
+		titleKey: "system.export-completed.title",
+		bodyKey: title !== void 0 ? "system.export-completed.body.titled" : "system.export-completed.body",
+		textParams: {
+			exportId,
+			...title !== void 0 ? { title } : {},
+			...bytes !== void 0 ? { bytes: String(bytes) } : {},
+			...deviceId !== void 0 ? { deviceId: String(deviceId) } : {}
+		},
+		...deviceId !== void 0 ? { deviceId } : {}
+	});
+	if (notifyTargetIds.length === 0) return incoming;
+	return {
+		...incoming,
+		controls: {
+			directTargetIds: notifyTargetIds,
+			bypassMute: true
+		}
+	};
+}
+function updatePackages(data) {
+	const raw = data["packages"];
+	if (Array.isArray(raw) && raw.length > 0) {
+		const rows = [];
+		for (const item of raw) {
+			if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+			const row = item;
+			const packageName = stringField(row, "packageName");
+			const currentVersion = stringField(row, "currentVersion");
+			const latestVersion = stringField(row, "latestVersion");
+			if (packageName === void 0 || currentVersion === void 0 || latestVersion === void 0) continue;
+			const nodeId = stringField(row, "nodeId");
+			rows.push({
 				packageName,
+				currentVersion,
+				latestVersion,
 				...nodeId !== void 0 ? { nodeId } : {}
 			});
 		}
-		default: return null;
+		if (rows.length > 0) return rows;
 	}
+	const packageName = stringField(data, "packageName");
+	const currentVersion = stringField(data, "currentVersion");
+	const latestVersion = stringField(data, "latestVersion");
+	if (packageName === void 0 || currentVersion === void 0 || latestVersion === void 0) return [];
+	const nodeId = stringField(data, "nodeId");
+	return [{
+		packageName,
+		currentVersion,
+		latestVersion,
+		...nodeId !== void 0 ? { nodeId } : {}
+	}];
+}
+function formatAvailableLine(pkg) {
+	const line = `${pkg.packageName} ${pkg.latestVersion} (current ${pkg.currentVersion})`;
+	return pkg.nodeId !== void 0 ? `${line} on ${pkg.nodeId}` : line;
+}
+function versionFromRequestedBy(requestedBy) {
+	if (requestedBy === void 0) return void 0;
+	return /@([^@\s]+)$/.exec(requestedBy)?.[1];
+}
+function unique(values) {
+	return [...new Set(values)];
 }
 /**
 * The COMBINED row's two keys, or null when this transition is not one.
@@ -10896,6 +11162,67 @@ function recordToRow$2(subject, data) {
 		updatedAt
 	};
 }
+function isDeviceLivenessKind(kind) {
+	return kind === "device-online" || kind === "device-offline" || kind === "camera-online" || kind === "camera-offline";
+}
+function livenessStateOfKind(kind) {
+	return kind.endsWith("-offline") ? "offline" : "online";
+}
+var DeviceLivenessHoldoff = class {
+	flush;
+	pending = /* @__PURE__ */ new Map();
+	lastNotified = /* @__PURE__ */ new Map();
+	timers = /* @__PURE__ */ new Map();
+	delayMs;
+	schedule;
+	cancel;
+	constructor(flush, options = {}) {
+		this.flush = flush;
+		this.delayMs = options.delayMs ?? 3e5;
+		this.schedule = options.schedule ?? setTimeout;
+		this.cancel = options.cancel ?? clearTimeout;
+	}
+	/** The seeded (or last delivered) state — a bounce back to this is silence. */
+	remember(subject, state) {
+		this.lastNotified.set(subject, state);
+	}
+	/** Directory-seeded rows never pass through {@link remember}; first flip does. */
+	rememberIfAbsent(subject, state) {
+		if (!this.lastNotified.has(subject)) this.lastNotified.set(subject, state);
+	}
+	/** A real ledger flip. Starts / resets the trailing timer. */
+	arm(subject, incoming) {
+		this.pending.set(subject, incoming);
+		const existing = this.timers.get(subject);
+		if (existing !== void 0) this.cancel(existing);
+		if (this.delayMs <= 0) {
+			this.timers.delete(subject);
+			this.fire(subject);
+			return;
+		}
+		const id = this.schedule(() => {
+			this.timers.delete(subject);
+			this.fire(subject);
+		}, this.delayMs);
+		this.timers.set(subject, id);
+	}
+	dispose() {
+		for (const id of this.timers.values()) this.cancel(id);
+		this.timers.clear();
+		this.pending.clear();
+	}
+	fire(subject) {
+		const incoming = this.pending.get(subject);
+		this.pending.delete(subject);
+		if (incoming === void 0) return;
+		const kind = incoming.subject.systemEvent?.kind;
+		if (kind === void 0) return;
+		const state = livenessStateOfKind(kind);
+		if (this.lastNotified.get(subject) === state) return;
+		this.lastNotified.set(subject, state);
+		this.flush(incoming);
+	}
+};
 //#endregion
 //#region src/notification-center/occupancy-watcher.ts
 /** Sentinel key segments for the "no zone" (whole-frame) and "no class" scopes. */
@@ -17793,6 +18120,36 @@ var TimelapseStore = class {
 		return rule;
 	}
 };
+var AddonUpdateCoalescer = class {
+	flush;
+	pending = /* @__PURE__ */ new Map();
+	timer = null;
+	delayMs;
+	schedule;
+	cancel;
+	constructor(flush, options = {}) {
+		this.flush = flush;
+		this.delayMs = options.delayMs ?? 3e4;
+		this.schedule = options.schedule ?? setTimeout;
+		this.cancel = options.cancel ?? clearTimeout;
+	}
+	observe(update) {
+		this.pending.set(update.packageName, update);
+		if (this.timer !== null) this.cancel(this.timer);
+		this.timer = this.schedule(() => {
+			this.timer = null;
+			const batch = [...this.pending.values()];
+			this.pending.clear();
+			if (batch.length > 0) this.flush(batch);
+		}, this.delayMs);
+	}
+	dispose() {
+		if (this.timer === null) return;
+		this.cancel(this.timer);
+		this.timer = null;
+		this.pending.clear();
+	}
+};
 //#endregion
 //#region src/notification-center/zone-owner-cache.ts
 var NcZoneOwnershipCache = class {
@@ -17902,6 +18259,15 @@ var TIMELAPSE_LOOKAHEAD_MS = 9 * 864e5;
 */
 var NC_ALARM_ANNOUNCE_RULE_ID = "nc-alarm-announce";
 /**
+* Synthetic rule id for an export's on-screen picker.
+*
+* The operator named these targets on the export screen, not in a rule. The
+* row still lives in the outbox so history, retry and language rendering are
+* the same path as every other notification. A matching `export-completed`
+* rule that already reached a target is skipped so one export is one push.
+*/
+var NC_EXPORT_NOTIFY_RULE_ID = "nc-export-notify";
+/**
 * Which alarm buttons a notification of this kind should carry, or `null` for
 * every notification that is not about the panel.
 *
@@ -18349,6 +18715,10 @@ var NotificationCenter = class NotificationCenter {
 	* seeds, only a real flip notifies.
 	*/
 	liveness;
+	/** Batches `addon.updated` (version-bearing) into one notification per 30 s. */
+	addonUpdates;
+	/** Trailing 5 min hold-off for camera liveness flaps (plugin restart). */
+	livenessHoldoff;
 	/**
 	* Serialized evaluation chain. The persist hooks are fire-and-forget for
 	* the frame path, but two concurrent evaluations of the same device
@@ -18651,6 +19021,16 @@ var NotificationCenter = class NotificationCenter {
 			store: deps.store,
 			logger: this.logger.child("liveness")
 		});
+		this.addonUpdates = new AddonUpdateCoalescer((updates) => {
+			const incoming = incomingFromAddonUpdates({
+				eventId: `addon-updated:${updates.map((u) => u.packageName).join(",")}`,
+				timestamp: this.now(),
+				category: "addon.updated",
+				data: { packages: updates }
+			}, updates);
+			if (incoming !== null) this.consumeEvent(incoming);
+		});
+		this.livenessHoldoff = new DeviceLivenessHoldoff((event) => this.consumeEvent(event), { delayMs: deps.livenessHoldoffMs ?? (process.env.VITEST ? 0 : 3e5) });
 		this.actionRunner = deps.actuate !== void 0 && deps.isCapDeviceScoped !== void 0 ? new NcRuleActionRunner({
 			logger: this.logger.child("actions"),
 			actuate: (input) => this.actuateWithAttribution(input),
@@ -18909,6 +19289,8 @@ var NotificationCenter = class NotificationCenter {
 		this.timelapseScheduler?.stop();
 		this.summaryProducer?.stop();
 		this.audioStills?.clear();
+		this.addonUpdates.dispose();
+		this.livenessHoldoff.dispose();
 		this.evaluationActive = false;
 	}
 	/**
@@ -19383,6 +19765,11 @@ var NotificationCenter = class NotificationCenter {
 	*/
 	onSystemEvent(event) {
 		if (!this.evaluationActive) return;
+		if (event.category === "addon.updated") {
+			const update = parseAddonUpdateComplete(event.data);
+			if (update !== null) this.addonUpdates.observe(update);
+			return;
+		}
 		const incoming = incomingFromSystemEvent(event, this.deviceDirectory.lookup());
 		if (incoming === null) {
 			const dropped = discardedSystemEvent(event);
@@ -19398,11 +19785,22 @@ var NotificationCenter = class NotificationCenter {
 		const system = incoming.subject.systemEvent;
 		const observation = system !== void 0 ? ledgeredLiveness(system) : null;
 		if (observation !== null) {
+			const previous = this.liveness.stateOf(observation.subject);
 			const verdict = this.liveness.observe(observation, this.now());
+			if (verdict === "seeded") {
+				this.livenessHoldoff.remember(observation.subject, observation.state);
+				this.reportLivenessDrop(incoming, verdict);
+				return;
+			}
 			if (verdict !== "flip") {
 				this.reportLivenessDrop(incoming, verdict);
 				return;
 			}
+			if (previous !== void 0) this.livenessHoldoff.rememberIfAbsent(observation.subject, previous);
+			if (isDeviceLivenessKind(observation.kind)) {
+				this.livenessHoldoff.arm(observation.subject, incoming);
+				return;
+			}
 		} else if (system !== void 0 && (system.kind.startsWith("device-") || system.kind.startsWith("stream-"))) {
 			if (this.lastSystemLiveness.get(system.subject) === system.kind) return;
 			this.lastSystemLiveness.set(system.subject, system.kind);
@@ -19895,6 +20293,55 @@ var NotificationCenter = class NotificationCenter {
 		});
 	}
 	/**
+	* Deliver to targets the producer named (`controls.directTargetIds`).
+	*
+	* Skips ids a matching rule already reached so one export is one push.
+	* Absent/empty is a no-op — every other producer omits the control.
+	*/
+	async enqueuePickerTargets(event, reached, outcomes) {
+		const ids = event.controls?.directTargetIds;
+		if (ids === void 0 || ids.length === 0) return;
+		const targets = [...new Set(ids)].filter((id) => !reached.has(id));
+		if (targets.length === 0) return;
+		const subject = event.subject;
+		const entries = targets.map((targetId) => ({
+			ruleId: NC_EXPORT_NOTIFY_RULE_ID,
+			targetId,
+			deviceId: subject.deviceId,
+			recordKind: "system-event",
+			recordId: subject.recordId,
+			payload: {
+				ruleName: "export",
+				delivery: "system-event",
+				priority: 2,
+				media: "none",
+				subject: {
+					deviceId: subject.deviceId,
+					className: "export",
+					zones: [],
+					timestamp: subject.timestamp,
+					...subject.systemEvent !== void 0 ? { systemEvent: subject.systemEvent } : {}
+				}
+			}
+		}));
+		const inserted = await this.outbox.enqueue(entries);
+		outcomes.push({
+			ruleId: NC_EXPORT_NOTIFY_RULE_ID,
+			ruleName: "export",
+			matched: true,
+			cooldown: "n/a",
+			enqueued: inserted,
+			targetIds: entries.map((entry) => entry.targetId)
+		});
+		this.logger.info("export picker notification enqueued", {
+			tags: { deviceId: subject.deviceId },
+			meta: {
+				targets: targets.length,
+				inserted
+			}
+		});
+	}
+	/**
 	* The COMBINED notification's second half: withdraw what it replaced.
 	*
 	* Only for the targets the alarm actually reached, and only while their rows
@@ -20019,6 +20466,8 @@ var NotificationCenter = class NotificationCenter {
 				}
 			});
 			if (kind === "track-end") await this.enqueueRecognitionUpgrades(subject, outcomes);
+			await this.enqueuePickerTargets(event, /* @__PURE__ */ new Set(), outcomes);
+			if (outcomes.some((outcome) => outcome.enqueued > 0)) return report({ candidates: 0 });
 			return report({ droppedBy: "no-candidate-rule" });
 		}
 		const now = this.now();
@@ -20215,6 +20664,8 @@ var NotificationCenter = class NotificationCenter {
 		}
 		if (!anyMatched && rejections.length > 0) this.reportNoMatch(subject, kind, rejections, now);
 		if (kind === "track-end") await this.enqueueRecognitionUpgrades(subject, outcomes);
+		const reached = new Set(outcomes.flatMap((outcome) => outcome.targetIds));
+		await this.enqueuePickerTargets(event, reached, outcomes);
 		return report({ candidates: candidates.length });
 	}
 	/**
@@ -21434,6 +21885,9 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-inference-unavailable") return `node-inference:${scope.nodeId ?? "hub"}`;
 	if (kind === "detection-blind") return `detection-blind:${scope.deviceId ?? 0}`;
 	if (kind === "addon-update-available" || kind === "server-update-available") return `package:${scope.packageName ?? "@camstack/server"}`;
+	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}`;
 	return `alarm:${scope.deviceId ?? 0}`;
 }
 /**
@@ -21545,7 +21999,13 @@ function planRuleTest(input) {
 					profile: "low",
 					seconds: "30",
 					devices: "cuda:0",
-					minutes: "15"
+					minutes: "15",
+					list: "@camstack/addon-pipeline 1.0.0 (current 0.0.0)",
+					nodes: "hub",
+					fromVersion: "0.0.0",
+					toVersion: "0.0.1",
+					title: "Export",
+					count: "1"
 				},
 				...systemScope.deviceId !== void 0 ? { deviceId: systemScope.deviceId } : {},
 				...c.systemEvent?.deviceTypes?.[0] !== void 0 ? { deviceType: c.systemEvent.deviceTypes[0] } : {},
@@ -28414,7 +28874,123 @@ var OrphanAuditActionResultSchema = require_dist.object({
 });
 var orphanAuditActions = require_dist.defineCustomActions({ "retention.orphanAudit": require_dist.customAction(OrphanAuditActionInputSchema, OrphanAuditActionResultSchema, { auth: "admin" }) });
 //#endregion
+//#region src/pipeline-analytics/videoclip-visits.ts
+/**
+* Videoclip visits — the grain a clip should have on an events-mode camera.
+*
+* Disk writes one fMP4 per ffmpeg roll (~8–12 s). The recorder calendar merges
+* only gaps ≤ 5 s, so a single pantry walk shows up as several availability
+* ranges with ~8 s GOP holes between them. Analytics then mints one 15 s clip
+* per motion heartbeat. A *visit* is the keep-window those fragments belong
+* to: cluster availability with {@link VISIT_MERGE_GAP_MS}, annotate with
+* overlapping events. No second copy of the media; the files stay the source
+* of truth.
+*/
+/** Synthetic event-id slot in `analytics:<start>:<end>:<id>` for a visit clip. */
+var VISIT_EVENT_ID = "visit";
+function clusterFootageVisits(ranges, gapMs = require_dist.VISIT_MERGE_GAP_MS) {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].toSorted((a, b) => a.startMs - b.startMs);
+	const visits = [];
+	let pieces = [sorted[0]];
+	let endMs = sorted[0].endMs;
+	for (let i = 1; i < sorted.length; i++) {
+		const next = sorted[i];
+		if (next.startMs <= endMs + gapMs) {
+			pieces.push(next);
+			endMs = Math.max(endMs, next.endMs);
+			continue;
+		}
+		visits.push(finishVisit(pieces, endMs));
+		pieces = [next];
+		endMs = next.endMs;
+	}
+	visits.push(finishVisit(pieces, endMs));
+	return visits;
+}
+function finishVisit(pieces, endMs) {
+	const holes = [];
+	for (let i = 1; i < pieces.length; i++) {
+		const prevEnd = pieces[i - 1].endMs;
+		const nextStart = pieces[i].startMs;
+		if (nextStart > prevEnd) holes.push({
+			startMs: prevEnd,
+			endMs: nextStart
+		});
+	}
+	return {
+		startMs: pieces[0].startMs,
+		endMs,
+		ranges: pieces,
+		holes
+	};
+}
+var KIND_ORDER = [
+	"object",
+	"motion",
+	"audio"
+];
+function eventOverlapsVisit(event, visit, pad) {
+	if (event.timestamp >= visit.startMs && event.timestamp <= visit.endMs) return true;
+	const windowStart = event.timestamp - pad.preMs;
+	const windowEnd = event.timestamp + pad.postMs;
+	return windowStart < visit.endMs && windowEnd > visit.startMs;
+}
+function dominantKind(attached) {
+	for (const kind of KIND_ORDER) if (attached.some((a) => a.kind === kind)) return kind;
+	return "motion";
+}
+function visitsToClips(visits, events, pad) {
+	const tagged = [
+		...events.object.map((event) => ({
+			kind: "object",
+			event
+		})),
+		...events.motion.map((event) => ({
+			kind: "motion",
+			event
+		})),
+		...events.audio.map((event) => ({
+			kind: "audio",
+			event
+		}))
+	];
+	return visits.map((visit) => {
+		const attached = tagged.filter((t) => eventOverlapsVisit(t.event, visit, pad));
+		const kind = dominantKind(attached);
+		const withThumb = attached.find((a) => a.kind === kind && a.event.mediaUrl) ?? attached.find((a) => a.event.mediaUrl);
+		return {
+			id: `analytics:${visit.startMs}:${visit.endMs}:${VISIT_EVENT_ID}`,
+			source: "analytics",
+			kind,
+			timeRange: {
+				startMs: visit.startMs,
+				endMs: visit.endMs
+			},
+			thumbnail: withThumb?.event.mediaUrl,
+			eventIds: attached.map((a) => a.event.id),
+			holes: [...visit.holes]
+		};
+	}).toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
+}
+//#endregion
 //#region src/pipeline-analytics/videoclips-provider.ts
+/**
+* Default `videoclips` provider — composes recorded footage visits with the
+* analytics event log. A clip is a time-WINDOW over existing footage, never a
+* separate file: `getClipPlayback` resolves to
+* `recording.getPlaybackManifest(startMs, endMs)`.
+*
+* When availability is present the grain is a *visit* (events-mode keep-window
+* clustered at `VISIT_MERGE_GAP_MS`), not one clip per motion heartbeat. The
+* clip id still encodes the window (`analytics:<startMs>:<endMs>:visit`) so
+* playback is self-contained. Without availability (or when that read fails)
+* the provider falls back to per-event padded windows.
+*
+* Pure helpers (`eventsToClips` / `clusterFootageVisits` / `clipIdFor` /
+* `parseClipId`) are unit-tested in isolation; the provider factory wires
+* injected fetch/resolve deps so the compose logic is testable without I/O.
+*/
 var SOURCE = "analytics";
 function clipIdFor(eventId, startMs, endMs) {
 	return `${SOURCE}:${startMs}:${endMs}:${eventId}`;
@@ -28457,36 +29033,29 @@ function eventsToClips(events, pad) {
 		...events.audio.map((e) => make(e, "audio"))
 	].toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
 }
-/** Keep only clips whose window overlaps at least one recorded range — a clip
-*  is a window over footage, so a window with nothing behind it is unplayable
-*  and must not be listed (a camera that never recorded showed 15 dead audio
-*  "clips" in the viewer ribbon, every tap a 500). Pure. */
-function filterClipsByFootage(clips, ranges) {
-	return clips.filter((c) => ranges.some((r) => c.timeRange.startMs < r.endMs && c.timeRange.endMs > r.startMs));
-}
 function createVideoclipsProvider(deps) {
 	return {
 		listClips: async ({ deviceId, since, until, limit }) => {
-			const clips = eventsToClips(await deps.fetchEvents({
+			const events = await deps.fetchEvents({
 				deviceId,
 				since,
 				until,
-				limit
-			}), deps.defaultPad);
-			let filtered = clips;
+				...deps.fetchAvailability ? {} : { limit }
+			});
+			let clips = eventsToClips(events, deps.defaultPad);
 			if (deps.fetchAvailability) try {
-				filtered = filterClipsByFootage(clips, await deps.fetchAvailability({
+				clips = visitsToClips(clusterFootageVisits(await deps.fetchAvailability({
 					deviceId,
 					since,
 					until
-				}));
+				}), require_dist.VISIT_MERGE_GAP_MS), events, deps.defaultPad);
 			} catch (err) {
 				deps.logWarn?.("videoclips: availability read failed — listing unfiltered", {
 					deviceId,
 					error: err instanceof Error ? err.message : String(err)
 				});
 			}
-			return limit != null ? filtered.slice(0, limit) : filtered;
+			return limit != null ? clips.slice(0, limit) : clips;
 		},
 		getClipPlayback: async ({ deviceId, clipId }) => {
 			const parsed = parseClipId(clipId);
@@ -29916,7 +30485,7 @@ var undecided = (candidate, reason) => ({
 	reason,
 	className: candidate.className
 });
-function withTimeout$1(promise, timeoutMs) {
+function withTimeout$2(promise, timeoutMs) {
 	return new Promise((resolve, reject) => {
 		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("confirmation-timeout")), timeoutMs);
 		promise.then((value) => {
@@ -29956,7 +30525,7 @@ async function confirmOne(candidate, config, deps, exhausted) {
 	const cropPx = Math.max(candidate.bbox.w, candidate.bbox.h);
 	if (config.minCropPx > 0 && cropPx < config.minCropPx) return undecided(candidate, "below-min-crop");
 	try {
-		return await withTimeout$1(runConfirmation(candidate, config, deps, exhausted), config.timeoutMs);
+		return await withTimeout$2(runConfirmation(candidate, config, deps, exhausted), config.timeoutMs);
 	} catch {
 		return undecided(candidate, "timeout");
 	}
@@ -34203,7 +34772,8 @@ function isMediaOwnerKind(value) {
 *   write="one row per blob written through put / putReplacing — a track's
 *     keyFrame, thumbnail, firstFrame and lastFrame (UPSERTED on a deterministic
 *     id, so one per track+kind however many captures race), its periodic
-*     snapshots, each event's crop and full frames, and the buffered face/plate
+*     snapshots, each event's crop and full frames, a motion visit's still
+*     (`kind: snapshot` on ownerKind event), and the buffered face/plate
 *     crops. A row is also REOWNED here (not rewritten) when the operator enrols a
 *     face or a plate, which is what moves it out of retention's reach."
 *   retention="no age sweep of its own — MediaStore.evictBefore was deleted (D59)
@@ -35615,7 +36185,8 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 			windowMs: t.lastSeen - t.firstSeen,
 			...t.markForTrain !== void 0 ? { markForTrain: t.markForTrain } : {},
 			...t.retrainStatus !== void 0 ? { retrainStatus: t.retrainStatus } : {},
-			...t.debug !== void 0 ? { debug: t.debug } : {}
+			...t.debug !== void 0 ? { debug: t.debug } : {},
+			...t.favourited !== void 0 ? { favourited: t.favourited } : {}
 		});
 	}
 	scored.sort((a, b) => b.importance - a.importance);
@@ -37258,7 +37829,8 @@ async function applyTrackFlags(deps, input) {
 	}
 	const patch = {
 		...input.flags.markForTrain !== void 0 ? { markForTrain: input.flags.markForTrain } : {},
-		...input.flags.debug !== void 0 ? { debug: input.flags.debug } : {}
+		...input.flags.debug !== void 0 ? { debug: input.flags.debug } : {},
+		...input.flags.favourited !== void 0 ? { favourited: input.flags.favourited } : {}
 	};
 	if (Object.keys(patch).length > 0) await store.setFlags(input.trackId, patch);
 	const retrainStatus = patch.markForTrain === void 0 ? current.retrainStatus : patch.markForTrain ? "staging" : "none";
@@ -37266,6 +37838,7 @@ async function applyTrackFlags(deps, input) {
 		trackId: input.trackId,
 		markForTrain: retrainStatus === "staging",
 		debug: patch.debug ?? current.debug,
+		favourited: patch.favourited ?? current.favourited,
 		retrainStatus
 	};
 }
@@ -38506,11 +39079,14 @@ function tieredLabelColumnData(patch) {
 *     (MOTION_EVENT_HEARTBEAT_MS) while it stays on. The analyzer path and the
 *     onboard-firmware path share that throttle, so a camera cannot double-count.
 *     Measured at ~7,200 rows/day/camera."
-*   retention="a TERMINAL age-keyed root — no trackId, no media, nothing references
-*     it, so the track cascade can never reach it. Deleted by
+*   retention="a TERMINAL age-keyed root — no trackId. A motion row may own a
+*     still (`ownerKind: 'event'`, `kind: 'snapshot'`) captured on the off→on
+*     visit so events-mode recordings have a videoclip thumbnail. Deleted by
 *     EventStore.evictTracklessBefore on the DEVICE's one retention window
-*     (follow-recordings horizon, or trackRetentionDays, default 7). 0 days = keep
-*     forever, and this table is the reason that setting is dangerous."
+*     (follow-recordings horizon, or trackRetentionDays, default 7), which
+*     folds in MediaStore.deleteForEvents so the still leaves with the row.
+*     0 days = keep forever, and this table is the reason that setting is
+*     dangerous."
 */
 var MOTION_EVENTS_COLLECTION = "pipeline-analytics:motion-events";
 /**
@@ -39239,9 +39815,10 @@ var EventStore = class {
 	* Object events now leave exactly one way: with their track, through
 	* {@link deleteByTracks} (D61).
 	*
-	* Motion and audio carry no `trackId`, own no media and are referenced by
-	* nothing — they are terminal retention ROOTS, so an age window on them
-	* cannot contradict anybody's (`retention/retention-model.ts`).
+	* Motion and audio carry no `trackId` and are referenced by nothing — they
+	* are terminal retention ROOTS, so an age window on them cannot contradict
+	* anybody's (`retention/retention-model.ts`). A motion visit still is
+	* event-owned media of that row and is deleted here in lockstep.
 	*
 	* **ONE cutoff for both kinds** (D62). They used to take a window each
 	* (`retentionMotionDays` / `retentionAudioDays`), which is two clocks over
@@ -39258,9 +39835,17 @@ var EventStore = class {
 			...params.deviceId !== void 0 ? { where: { deviceId: params.deviceId } } : {},
 			whereBetween: { timestamp: [0, params.cutoffMs] }
 		});
+		const motion = await batch(MOTION_EVENTS_COLLECTION);
+		const audio = await batch(AUDIO_EVENTS_COLLECTION);
+		const ids = [...motion, ...audio];
+		if (ids.length > 0 && this.media !== void 0) try {
+			await this.media.deleteForEvents(ids);
+		} catch (err) {
+			this.logger.warn("EventStore.evictTracklessBefore: event media delete failed", { meta: { error: String(err) } });
+		}
 		return {
-			motion: await batch(MOTION_EVENTS_COLLECTION),
-			audio: await batch(AUDIO_EVENTS_COLLECTION)
+			motion,
+			audio
 		};
 	}
 	/**
@@ -39285,23 +39870,32 @@ var EventStore = class {
 	* The SUBSET of `eventIds` that still exist — the orphan audit's liveness
 	* probe for event-owned media.
 	*
+	* Motion and audio rows can own stills (`kind: 'snapshot'` on a motion
+	* visit); probing only the object collection would classify those stills
+	* as orphans the moment they were written.
+	*
 	* THROWS on a query failure rather than answering partially. A probe that
 	* quietly under-reports here reads as "these events are gone", and the caller
 	* deletes live crops on the strength of it.
 	*/
 	async existingEventIds(eventIds) {
 		const found = /* @__PURE__ */ new Set();
+		const collections = [
+			OBJECT_EVENTS_COLLECTION,
+			MOTION_EVENTS_COLLECTION,
+			AUDIO_EVENTS_COLLECTION
+		];
 		for (let i = 0; i < eventIds.length; i += 500) {
 			const chunk = eventIds.slice(i, i + 500);
 			if (chunk.length === 0) continue;
-			const rows = await this.store.query.query({
-				collection: OBJECT_EVENTS_COLLECTION,
+			const pages = await Promise.all(collections.map((collection) => this.store.query.query({
+				collection,
 				filter: {
 					whereIn: { id: [...chunk] },
 					limit: chunk.length
 				}
-			});
-			for (const row of rows) found.add(row.id);
+			})));
+			for (const rows of pages) for (const row of rows) found.add(row.id);
 		}
 		return found;
 	}
@@ -41309,6 +41903,10 @@ var TRACKS_COLUMNS = [
 		name: "debug",
 		type: "BOOLEAN"
 	},
+	{
+		name: "favourited",
+		type: "BOOLEAN"
+	},
 	{
 		name: "hasFace",
 		type: "BOOLEAN"
@@ -41402,6 +42000,7 @@ function cloneTrack(t) {
 			markForTrain: t.retrainStatus === "staging"
 		} : {},
 		...t.debug !== void 0 ? { debug: t.debug } : {},
+		...t.favourited !== void 0 ? { favourited: t.favourited } : {},
 		...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
 		...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
 		...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {}
@@ -41747,11 +42346,13 @@ var TrackStore = class {
 		const nextStatus = patch.markForTrain === void 0 ? void 0 : patch.markForTrain ? "staging" : "none";
 		if (nextStatus !== void 0) data["retrainStatus"] = nextStatus;
 		if (patch.debug !== void 0) data["debug"] = patch.debug;
+		if (patch.favourited !== void 0) data["favourited"] = patch.favourited;
 		if (Object.keys(data).length === 0) return;
 		const active = this.active.get(trackId);
 		if (active) {
 			if (nextStatus !== void 0) active.retrainStatus = nextStatus;
 			if (patch.debug !== void 0) active.debug = patch.debug;
+			if (patch.favourited !== void 0) active.favourited = patch.favourited;
 		}
 		try {
 			await this.store.update.mutate({
@@ -41892,13 +42493,15 @@ var TrackStore = class {
 		const active = this.active.get(trackId);
 		if (active) return {
 			retrainStatus: active.retrainStatus ?? "none",
-			debug: active.debug === true
+			debug: active.debug === true,
+			favourited: active.favourited === true
 		};
 		const persisted = await this.getPersistedByTrackId(trackId);
 		if (!persisted) return null;
 		return {
 			retrainStatus: persisted.retrainStatus ?? "none",
-			debug: persisted.debug === true
+			debug: persisted.debug === true,
+			favourited: persisted.favourited === true
 		};
 	}
 	/**
@@ -42033,6 +42636,7 @@ var TrackStore = class {
 				filter: {
 					where: { deviceId },
 					whereIn: { retrainStatus: ["none", "trained"] },
+					whereNot: { favourited: true },
 					whereBetween: { lastSeen: [0, cutoffMs - 1] },
 					orderBy: {
 						field: "lastSeen",
@@ -42202,6 +42806,40 @@ var TrackStore = class {
 		}
 	}
 	/**
+	* How many of this device's tracks are FAVOURITED — optionally only those
+	* older than a cutoff, i.e. the rows a sweep just declined to touch because
+	* of the boolean pin (independent of `retrainStatus`).
+	*
+	* Mirrors {@link countStaging}: the sweep log must name held work or a
+	* favourited-only camera reads as "retention did nothing". Best-effort — a
+	* failure reports 0 rather than disturbing the caller.
+	*/
+	async countFavourited(query) {
+		const { deviceId, olderThanMs } = query;
+		try {
+			return await this.store.count.query({
+				collection: TRACKS_COLLECTION,
+				filter: {
+					where: {
+						deviceId,
+						favourited: true
+					},
+					...olderThanMs !== void 0 ? { whereBetween: { lastSeen: [0, olderThanMs - 1] } } : {}
+				}
+			});
+		} catch (err) {
+			this.logger.warn("TrackStore.countFavourited failed", {
+				tags: { deviceId },
+				meta: {
+					deviceId,
+					olderThanMs,
+					error: String(err)
+				}
+			});
+			return 0;
+		}
+	}
+	/**
 	* The SUBSET of `trackIds` that still have a persisted row — the orphan
 	* audit's liveness probe.
 	*
@@ -42574,6 +43212,7 @@ var TrackStore = class {
 				...t.audioLabels !== void 0 ? { audioLabels: [...t.audioLabels] } : {},
 				...t.retrainStatus !== void 0 ? { retrainStatus: t.retrainStatus } : {},
 				...t.debug !== void 0 ? { debug: t.debug } : {},
+				...t.favourited !== void 0 ? { favourited: t.favourited } : {},
 				...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
 				...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
 				...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {},
@@ -42611,6 +43250,7 @@ var TrackStore = class {
 		const audioLabels = data["audioLabels"];
 		const retrainParsed = require_dist.RetrainStatusSchema.safeParse(data["retrainStatus"]);
 		const debug = data["debug"];
+		const favourited = data["favourited"];
 		const hasFace = data["hasFace"];
 		/** Same read as `hasFace` — NULL / missing stays ABSENT, never `false`. */
 		const hasRider = data["hasRider"];
@@ -42650,6 +43290,7 @@ var TrackStore = class {
 				markForTrain: retrainParsed.data === "staging"
 			} : {},
 			...typeof debug === "boolean" ? { debug } : {},
+			...typeof favourited === "boolean" ? { favourited } : {},
 			...typeof hasFace === "boolean" ? { hasFace } : {},
 			...typeof hasRider === "boolean" ? { hasRider } : {},
 			...closedReason !== void 0 ? { closedReason } : {},
@@ -44672,7 +45313,10 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_dist.EventCategory.WorkerOffline,
 	require_dist.EventCategory.PipelineNodeInferenceUnavailable,
 	require_dist.EventCategory.PipelineDetectionBlind,
-	require_dist.EventCategory.UpdateAvailable
+	require_dist.EventCategory.UpdateAvailable,
+	require_dist.EventCategory.AddonUpdated,
+	require_dist.EventCategory.SystemRestartCompleted,
+	require_dist.EventCategory.RecordingExportCompleted
 ];
 /**
 * Install the addon's bus subscriptions. Identical set + relative order to the
@@ -46109,16 +46753,16 @@ var DEFAULT_DEBOUNCE_MS = 1e4;
 /** A hanging snapshot cap must not stall the sensor state-change path. */
 var DEFAULT_SNAPSHOT_TIMEOUT_MS = 1e4;
 /** Distinguishes a snapshot-cap timeout from a fetch failure for reporting. */
-var SnapshotTimeoutError = class extends Error {
+var SnapshotTimeoutError$1 = class extends Error {
 	constructor(ms) {
 		super(`snapshot cap timed out after ${ms}ms`);
 		this.name = "SnapshotTimeoutError";
 	}
 };
 /** Reject with `SnapshotTimeoutError` if `promise` doesn't settle within `ms`. */
-function withTimeout(promise, ms) {
+function withTimeout$1(promise, ms) {
 	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(new SnapshotTimeoutError(ms)), ms);
+		const timer = setTimeout(() => reject(new SnapshotTimeoutError$1(ms)), ms);
 		promise.then((value) => {
 			clearTimeout(timer);
 			resolve(value);
@@ -46173,11 +46817,11 @@ var SyntheticTrackMaterializer = class {
 	*/
 	async fetchSnapshot(cameraId, timeoutMs) {
 		try {
-			const snap = await withTimeout(this.deps.snapshot.getSnapshot({ deviceId: cameraId }), timeoutMs);
+			const snap = await withTimeout$1(this.deps.snapshot.getSnapshot({ deviceId: cameraId }), timeoutMs);
 			if (snap === null) this.deps.onError?.("getSnapshot", /* @__PURE__ */ new Error("snapshot returned null"), cameraId);
 			return snap;
 		} catch (err) {
-			this.deps.onError?.(err instanceof SnapshotTimeoutError ? "snapshotTimeout" : "snapshotMedia", err, cameraId);
+			this.deps.onError?.(err instanceof SnapshotTimeoutError$1 ? "snapshotTimeout" : "snapshotMedia", err, cameraId);
 			return null;
 		}
 	}
@@ -46243,6 +46887,66 @@ var SyntheticTrackMaterializer = class {
 		return track;
 	}
 };
+var SnapshotTimeoutError = class extends Error {
+	constructor(ms) {
+		super(`snapshot cap timed out after ${ms}ms`);
+		this.name = "SnapshotTimeoutError";
+	}
+};
+function withTimeout(promise, ms) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new SnapshotTimeoutError(ms)), ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (err) => {
+			clearTimeout(timer);
+			reject(err instanceof Error ? err : new Error(String(err)));
+		});
+	});
+}
+var MotionEventSnapshotCapturer = class {
+	deps;
+	snapshotTimeoutMs;
+	constructor(deps) {
+		this.deps = deps;
+		this.snapshotTimeoutMs = deps.snapshotTimeoutMs ?? 2500;
+	}
+	/**
+	* Fetch a still and persist it as the motion event's snapshot. Never
+	* throws — the durable record is the motion row, already inserted by
+	* the caller.
+	*/
+	async capture(input) {
+		let snap;
+		try {
+			snap = await withTimeout(this.deps.snapshot.getSnapshot({ deviceId: input.deviceId }), this.snapshotTimeoutMs);
+		} catch (err) {
+			this.deps.onError?.(err instanceof SnapshotTimeoutError ? "snapshotTimeout" : "snapshotFetch", err, input.deviceId);
+			return;
+		}
+		if (snap === null) return;
+		const raw = Buffer.from(snap.base64, "base64");
+		let data = raw;
+		try {
+			data = await downscaleFullFrameJpeg(raw, 960, 540);
+		} catch (err) {
+			this.deps.onError?.("downscaleSnapshot", err, input.deviceId);
+		}
+		try {
+			await this.deps.media.put({
+				deviceId: input.deviceId,
+				ownerKind: "event",
+				ownerId: input.eventId,
+				kind: "snapshot",
+				timestamp: input.timestamp,
+				data
+			});
+		} catch (err) {
+			this.deps.onError?.("snapshotMedia", err, input.deviceId);
+		}
+	}
+};
 var TrackingSettingsSchema = require_dist.object({
 	/**
 	* How much of a detection's box must lie inside a zone (0-1 fraction of the
@@ -49213,6 +49917,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	/** The ONE projector of non-spatial events into synthetic snapshot-carrying
 	*  tracks — linked sensor/control state changes AND audio markers. */
 	syntheticTracks = null;
+	/** Still for a motion row that has no track (events-mode recording without
+	*  a detection). Lands as event-owned `kind: 'snapshot'` so videoclip
+	*  thumbnails resolve through the existing event-media plane. */
+	motionEventSnapshots = null;
 	/** Decides which audio frames deserve a synthetic marker (D62). */
 	audioMarkers = null;
 	faceStore = null;
@@ -50406,6 +51114,17 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			} })
 		});
 		this.syntheticTracks = syntheticTracks;
+		this.motionEventSnapshots = new MotionEventSnapshotCapturer({
+			snapshot: { getSnapshot: (i) => api.snapshot?.getSnapshot.query(i) ?? Promise.resolve(null) },
+			media: mediaStore,
+			onError: (scope, err, deviceId) => logger.warn("motion event snapshot failed", {
+				...deviceId !== void 0 ? { tags: { deviceId } } : {},
+				meta: {
+					scope,
+					error: require_dist.errMsg(err)
+				}
+			})
+		});
 		this.audioMarkers = new AudioMarkerProjector({
 			sink: syntheticTracks,
 			isMotionActive: (deviceId, atMs, quietMs) => this.isMotionActive(deviceId, atMs, quietMs),
@@ -50771,6 +51490,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				},
 				renderEventMedia: (req) => this.renderEventMedia(req),
 				publishArtifact: async (bytes, mime) => await this.ncArtifactPlane?.publish(bytes, mime) ?? null,
+				indexArtifact: async (bytes, mime, meta) => await this.ncArtifactPlane?.publishIndexed(bytes, mime, meta) ?? {
+					url: null,
+					artifactId: null
+				},
 				listTargets: async () => {
 					return (await api.notificationOutput.listTargets.query({})).map((t) => {
 						const owner = t.config["ownerUserId"];
@@ -53472,7 +54195,13 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const last = this.lastMotionInsertByDevice.get(deviceId);
 		const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
 		const transitionedOn = detected && (last === void 0 || last.detected === false);
-		if (!detected) return;
+		if (!detected) {
+			if (last?.detected === true) this.lastMotionInsertByDevice.set(deviceId, {
+				detected: false,
+				atMs: timestamp
+			});
+			return;
+		}
 		if (!transitionedOn && !heartbeatDue) return;
 		const ev = {
 			id: (0, node_crypto.randomUUID)(),
@@ -53515,6 +54244,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				timestamp: ev.timestamp
 			}
 		});
+		if (transitionedOn) await this.motionEventSnapshots?.capture({
+			deviceId,
+			eventId: ev.id,
+			timestamp: ev.timestamp
+		});
 	}
 	/**
 	* Persist firmware-driven (onboard) motion events. Mirrors
@@ -53539,7 +54273,13 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const last = this.lastMotionInsertByDevice.get(deviceId);
 		const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
 		const transitionedOn = detected && (last === void 0 || last.detected === false);
-		if (!detected) return;
+		if (!detected) {
+			if (last?.detected === true) this.lastMotionInsertByDevice.set(deviceId, {
+				detected: false,
+				atMs: timestamp
+			});
+			return;
+		}
 		if (!transitionedOn && !heartbeatDue) return;
 		const regions = payload.regions ?? [];
 		const ev = {
@@ -53583,6 +54323,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				timestamp: ev.timestamp
 			}
 		});
+		if (transitionedOn) await this.motionEventSnapshots?.capture({
+			deviceId,
+			eventId: ev.id,
+			timestamp: ev.timestamp
+		});
 	}
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
@@ -53651,8 +54396,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*
 	*   1. the track sweep, per device, cascading;
 	*   2. the TRACKLESS roots — motion, audio and sensor events, which carry no
-	*      trackId, own nothing and are referenced by nothing, so the cascade can
-	*      never reach them and a clock is the only thing that can.
+	*      trackId and are referenced by nothing, so the cascade can never reach
+	*      them and a clock is the only thing that can. Motion visit stills leave
+	*      with their row inside `evictTracklessBefore`.
 	*
 	* That clock used to be three more settings (`retentionMotionDays` /
 	* `retentionObjectDays` / `retentionAudioDays`). It is now the device's own
@@ -55431,6 +56177,19 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 							deleted: counts.tracks
 						}
 					});
+					const favourited = await this.trackStore?.countFavourited({
+						deviceId,
+						olderThanMs: cutoffMs
+					});
+					if (favourited !== void 0 && favourited > 0) this.ctx.logger.info("track retention held favourited tracks", {
+						tags: { deviceId },
+						meta: {
+							deviceId,
+							favourited,
+							cutoffMs,
+							deleted: counts.tracks
+						}
+					});
 					if (counts.tracks > 0) this.eventsOpsLog?.append({
 						op: "prune",
 						reason: "retention",