@camstack/addon-post-analysis 1.2.73 → 1.2.74

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-DDv-TKUR.js");
+const require_dist = require("../dist-Cy8lyywE.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -1580,6 +1580,11 @@ var NC_ALARM_DECLARATION = {
 };
 //#endregion
 //#region src/notification-center/artifact-index.ts
+/**
+* @durable class=ledger owner=notification-center
+*   write="one row per RETAINED artefact, written once at publish; expiresAt patched never"
+*   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([
 	"timelapse",
@@ -3232,8 +3237,8 @@ function defaultPrompt(input) {
 }
 /** Longest-edge downscale via sharp — the production `downscale` dep. */
 async function downscaleJpeg(bytes, maxPx) {
-	const { default: sharp$12 } = await import("sharp");
-	const out = await sharp$12(Buffer.from(bytes)).resize({
+	const { default: sharp$13 } = await import("sharp");
+	const out = await sharp$13(Buffer.from(bytes)).resize({
 		width: maxPx,
 		height: maxPx,
 		fit: "inside",
@@ -5014,13 +5019,27 @@ function attachmentKindPreference(policy, ownerKind) {
 * scene is the honest fallback (same picture, no annotation) — never a subject
 * crop, which shows something else entirely.
 *
+* **`boxed` used to decide nothing.** Its first rung was `fullFrameBoxed`, a
+* kind RETIRED for new tracks on 2026-07-21 (`event-media-dispatcher.ts`), and
+* the rest of the ladder was the clean `keyFrame` family — so an authorable
+* option degraded, silently and always, to exactly what `full` returns. A knob
+* that decides nothing is worse than no knob: the operator set it and believed
+* they had asked for something.
+*
+* The annotated frames were there the whole time under different names.
+* `firstFrame` / `snapshot` / `lastFrame` are written by `boxedTimelineFrame`
+* — the track's OWN box burned onto the native full frame — so `boxed` now asks
+* for them, newest-moment-first-per-family, before degrading to the clean
+* scene. No new capture path, no new kind, and the option answers its own
+* question again.
+*
 * The strictness is about FAMILY, not about which moment of the track the
-* frame is from: every rung of the `full`/track ladder is a clean, unannotated
-* whole scene from this camera. `lastFrame` is `firstFrame`'s twin — the media
-* schema defines them together, "full-frame snapshots captured at a track's
-* start and end" — and `snapshot` is the same picture again. A live audit found
-* a track holding ONLY a `lastFrame` ship text-only: the honest answer to the
-* rule's question was stored and the ladder stopped one rung short of it.
+* frame is from. On the `full`/track ladder, `keyFrame`/`keyFrameSmall` are the
+* clean whole scene; `firstFrame`/`lastFrame`/`snapshot` are the same whole
+* scene WITH the track's own box on it, which is why they sit below the clean
+* pair and above nothing. (They are on this ladder because a live audit found a
+* track holding ONLY a `lastFrame` ship text-only: an annotated whole scene is
+* a far better answer to "what is going on" than no picture at all.)
 */
 function framePreference(frame, ownerKind) {
 	if (frame === "cropped") return ownerKind === "track" ? [
@@ -5034,6 +5053,9 @@ function framePreference(frame, ownerKind) {
 	];
 	if (frame === "boxed") return [
 		"fullFrameBoxed",
+		"snapshot",
+		"lastFrame",
+		"firstFrame",
 		"keyFrame",
 		"keyFrameSmall",
 		"fullFrame"
@@ -5129,6 +5151,26 @@ var en_default = {
 		"other": "plates"
 	},
 	"class.other": "{{name}}",
+	"group.others.person": {
+		"one": "1 other person",
+		"other": "{{count}} other people"
+	},
+	"group.others.vehicle": {
+		"one": "1 other vehicle",
+		"other": "{{count}} other vehicles"
+	},
+	"group.others.animal": {
+		"one": "1 other animal",
+		"other": "{{count}} other animals"
+	},
+	"group.others.package": {
+		"one": "1 other package",
+		"other": "{{count}} other packages"
+	},
+	"group.others.other": {
+		"one": "1 other {{classNoun}}",
+		"other": "{{count}} other {{classNoun}}"
+	},
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupied",
 	"occupancy.op.free": "free",
@@ -5152,6 +5194,13 @@ var en_default = {
 	"system.node-offline.title": "Node offline",
 	"system.node-offline.body.agent": "Agent {{nodeId}} is offline",
 	"system.node-offline.body.worker": "Worker {{nodeId}} is offline",
+	"system.node-inference-unavailable.title": "Node has no usable inference device",
+	"system.node-inference-unavailable.body": "Node {{nodeId}} can no longer run inference — every enabled device is unavailable ({{devices}}). It will not receive cameras until one returns.",
+	"system.detection-blind.title": "Camera detecting nothing",
+	"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"
+	},
 	"system.addon-update-available.title": "Addon update available",
 	"system.addon-update-available.body": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}})",
 	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}}) on node {{nodeId}}",
@@ -5296,6 +5345,26 @@ var it_default = {
 		"other": "targhe"
 	},
 	"class.other": "{{name}}",
+	"group.others.person": {
+		"one": "1 altra persona",
+		"other": "{{count}} altre persone"
+	},
+	"group.others.vehicle": {
+		"one": "1 altro veicolo",
+		"other": "{{count}} altri veicoli"
+	},
+	"group.others.animal": {
+		"one": "1 altro animale",
+		"other": "{{count}} altri animali"
+	},
+	"group.others.package": {
+		"one": "1 altro pacco",
+		"other": "{{count}} altri pacchi"
+	},
+	"group.others.other": {
+		"one": "1 altro {{classNoun}}",
+		"other": "{{count}} altri {{classNoun}}"
+	},
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupata",
 	"occupancy.op.free": "libera",
@@ -5319,6 +5388,13 @@ var it_default = {
 	"system.node-offline.title": "Nodo offline",
 	"system.node-offline.body.agent": "L'agent {{nodeId}} è offline",
 	"system.node-offline.body.worker": "Il worker {{nodeId}} è offline",
+	"system.node-inference-unavailable.title": "Nodo senza dispositivi di inferenza utilizzabili",
+	"system.node-inference-unavailable.body": "Il nodo {{nodeId}} non può più eseguire inferenza — tutti i dispositivi abilitati non sono disponibili ({{devices}}). Non riceverà camere finché uno non torna disponibile.",
+	"system.detection-blind.title": "Camera che non rileva nulla",
+	"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"
+	},
 	"system.addon-update-available.title": "Aggiornamento addon disponibile",
 	"system.addon-update-available.body": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}})",
 	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}}) sul nodo {{nodeId}}",
@@ -5573,6 +5649,149 @@ var NcTextCatalog = class {
 	}
 };
 //#endregion
+//#region src/shared/frame/box-drawer.ts
+var DEFAULT_COLOR = require_dist.DEFAULT_EVENT_COLOR;
+var DEFAULT_QUALITY = 80;
+var STROKE_WIDTH = 3;
+function escapeXml$2(s) {
+	return s.replace(/[<>&'"]/g, (ch) => {
+		switch (ch) {
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			case "&": return "&amp;";
+			case "'": return "&apos;";
+			default: return "&quot;";
+		}
+	});
+}
+/** Clamp a pixel box to the frame so the rect always stays inside [0,W]×[0,H]. */
+function clampBox(b, frameWidth, frameHeight) {
+	const x = Math.max(0, Math.min(Math.round(b.x), frameWidth - 1));
+	const y = Math.max(0, Math.min(Math.round(b.y), frameHeight - 1));
+	return {
+		x,
+		y,
+		w: Math.max(1, Math.min(Math.round(b.w), frameWidth - x)),
+		h: Math.max(1, Math.min(Math.round(b.h), frameHeight - y))
+	};
+}
+/**
+* Draw bounding boxes over a raw RGB frame and JPEG-encode it.
+*
+* The frame is composited with an SVG overlay (one `<rect>` per box, plus an
+* optional caption) at full resolution, then optionally downscaled — so the
+* box stays crisp relative to the scene. Boxes are clamped to frame bounds to
+* avoid sharp `extract`/region errors on slightly-out-of-range detections.
+*/
+async function drawBoxedFrame(frameData, frameWidth, frameHeight, boxes, opts = {}) {
+	const quality = opts.quality ?? DEFAULT_QUALITY;
+	let base = frameData;
+	let baseIsRaw = true;
+	if (boxes.length > 0) {
+		const fontSize = Math.max(12, Math.round(frameHeight / 30));
+		const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${frameWidth}" height="${frameHeight}">${boxes.map((b) => {
+			const c = clampBox(b, frameWidth, frameHeight);
+			const color = b.color ?? DEFAULT_COLOR;
+			const rect = `<rect x="${c.x}" y="${c.y}" width="${c.w}" height="${c.h}" fill="none" stroke="${color}" stroke-width="${STROKE_WIDTH}"/>`;
+			if (!b.label) return rect;
+			const ty = Math.max(fontSize, c.y - 4);
+			return rect + `<text x="${c.x}" y="${ty}" font-family="sans-serif" font-size="${fontSize}" fill="${color}" stroke="black" stroke-width="0.5">${escapeXml$2(b.label)}</text>`;
+		}).join("")}</svg>`;
+		base = await (0, sharp.default)(frameData, { raw: {
+			width: frameWidth,
+			height: frameHeight,
+			channels: 3
+		} }).composite([{
+			input: Buffer.from(svg),
+			top: 0,
+			left: 0
+		}]).png().toBuffer();
+		baseIsRaw = false;
+	}
+	let pipeline = baseIsRaw ? (0, sharp.default)(base, { raw: {
+		width: frameWidth,
+		height: frameHeight,
+		channels: 3
+	} }) : (0, sharp.default)(base);
+	if (opts.maxWidth !== void 0) pipeline = pipeline.resize({
+		width: opts.maxWidth,
+		withoutEnlargement: true
+	});
+	return pipeline.jpeg({ quality }).toBuffer();
+}
+/** JPEG quality of the composed artefact — the mosaic's number, same reasons. */
+var GROUP_FRAME_QUALITY = 82;
+/**
+* Draw the members onto the frame. Returns `null` when there is nothing to
+* draw, or when anything at all goes wrong — the caller then ships the
+* unannotated frame unchanged.
+*/
+async function composeGroupFrame(input) {
+	const freshnessMs = input.freshnessMs ?? 3e3;
+	const fresh = input.boxes.filter((b) => Math.abs(input.at - b.observedAt) <= freshnessMs);
+	const withheld = input.boxes.length - fresh.length;
+	if (fresh.length < 2) {
+		if (withheld > 0) input.logger.info("group frame not drawn — too few members with fresh geometry", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				groupKey: input.groupKey,
+				members: input.boxes.length,
+				fresh: fresh.length,
+				withheld
+			}
+		});
+		return null;
+	}
+	try {
+		const decoded = await (0, sharp.default)(input.jpeg).raw().toBuffer({ resolveWithObject: true });
+		const { width, height, channels } = decoded.info;
+		if (!(width > 0 && height > 0) || channels !== 3) {
+			input.logger.warn("group frame not drawn — unexpected raster shape", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					groupKey: input.groupKey,
+					width,
+					height,
+					channels
+				}
+			});
+			return null;
+		}
+		const boxes = fresh.map((b) => ({
+			x: b.bbox.x * width,
+			y: b.bbox.y * height,
+			w: b.bbox.w * width,
+			h: b.bbox.h * height,
+			...b.label !== void 0 && b.label.length > 0 ? { label: b.label } : {}
+		}));
+		const bytes = await drawBoxedFrame(decoded.data, width, height, boxes, { quality: GROUP_FRAME_QUALITY });
+		input.logger.debug("group frame composed", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				groupKey: input.groupKey,
+				drawn: boxes.length,
+				withheld,
+				width,
+				height
+			}
+		});
+		return {
+			bytes,
+			drawn: boxes.length,
+			withheld
+		};
+	} catch (err) {
+		input.logger.warn("group frame compose failed — shipping the unannotated frame", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				groupKey: input.groupKey,
+				error: err instanceof Error ? err.message : String(err)
+			}
+		});
+		return null;
+	}
+}
+//#endregion
 //#region src/notification-center/text-compose.ts
 /** One normalisation, used on both sides of every class lookup — a pipeline
 *  that emitted `Person` must find the key written `class.person`. */
@@ -5658,6 +5877,70 @@ function ncDetectionSummary(texts, counts) {
 	return texts.join(parts);
 }
 //#endregion
+//#region src/notification-center/group/nc-group-text.ts
+var DEFAULT_MAX_NAMES = 2;
+/**
+* `N altre persone` — the remainder phrase for one class, in its own gender.
+*
+* Mirrors {@link ncClassNoun} byte for byte, including the fallback: a class no
+* locale names falls through to `group.others.other`, which prints the raw class
+* name rather than vanishing. A custom model's class must appear in the sentence.
+*/
+function ncGroupOthers(texts, className, count) {
+	const classNoun = ncClassNoun(texts, className, count);
+	const key = `group.others.${className.trim().toLowerCase()}`;
+	if (texts.has(key)) return texts.text({
+		key,
+		count,
+		vars: {
+			count: `${count}`,
+			classNoun
+		}
+	});
+	return texts.text({
+		key: "group.others.other",
+		count,
+		vars: {
+			count: `${count}`,
+			classNoun
+		}
+	});
+}
+/** Counts per class, in first-seen order so the same burst always reads the same. */
+function countByClass(members) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const m of members) counts.set(m.className, (counts.get(m.className) ?? 0) + 1);
+	return [...counts].map(([className, count]) => ({
+		className,
+		count
+	}));
+}
+/**
+* The finished `{{subject}}` phrase for a group.
+*
+* Pure: a catalog in, a string out. No clock, no store, no I/O — like every
+* other composer in `text-compose.ts`, and for the same reason.
+*/
+function ncGroupSubjectText(texts, input) {
+	const members = input.members;
+	const only = members.length === 1 ? members[0] : void 0;
+	if (only !== void 0) return ncSubjectText(texts, {
+		className: only.className,
+		...only.label !== void 0 ? { label: only.label } : {},
+		...only.labelKind !== void 0 ? { labelKind: only.labelKind } : {}
+	});
+	if (members.length === 0) return "";
+	const maxNames = input.maxNames !== void 0 && input.maxNames >= 0 ? input.maxNames : DEFAULT_MAX_NAMES;
+	const named = members.filter((m) => m.label !== void 0 && m.label.length > 0);
+	const names = named.slice(0, maxNames).map((m) => m.label ?? "");
+	if (names.length === 0) return ncDetectionSummary(texts, countByClass(members));
+	const spoken = new Set(named.slice(0, maxNames));
+	const remainder = members.filter((m) => !spoken.has(m));
+	if (remainder.length === 0) return texts.join(names);
+	const others = countByClass(remainder).map((c) => ncGroupOthers(texts, c.className, c.count));
+	return texts.join([...names, ...others]);
+}
+//#endregion
 //#region src/notification-center/dispatcher.ts
 var DEFAULT_TARGET_CACHE_TTL_MS = 6e4;
 /**
@@ -6144,7 +6427,7 @@ var NcDispatcher = class {
 			title,
 			priority: clampPriority(paramNumber(entry.payload.params, "priority") ?? entry.payload.priority),
 			...params,
-			tag: entry.ruleId,
+			tag: entry.payload.group?.key ?? entry.ruleId,
 			...systemEvent !== void 0 ? systemEvent.deviceId !== void 0 ? { deviceId: systemEvent.deviceId } : {} : { deviceId: subject.deviceId },
 			...subject.eventId !== void 0 ? { eventId: subject.eventId } : {},
 			...systemEvent !== void 0 ? { metadata: {
@@ -6230,7 +6513,14 @@ var NcDispatcher = class {
 					bytes: cropped,
 					name: "zone.jpg"
 				} : still);
-			} else out.push(still);
+			} else {
+				const grouped = await this.groupFrame(entry, still.bytes);
+				out.push(grouped !== null ? {
+					...still,
+					bytes: grouped,
+					name: "group.jpg"
+				} : still);
+			}
 		} else if (entry.payload.media !== "none") this.deps.logger.info("no still could be resolved — this notification ships text-only", {
 			tags: { deviceId: entry.payload.subject.deviceId },
 			meta: {
@@ -6355,8 +6645,8 @@ var NcDispatcher = class {
 		try {
 			const points = (await this.deps.getZonePolygons?.(deviceId, zoneIds) ?? []).flat();
 			if (points.length === 0) return null;
-			const { default: sharp$11 } = await import("sharp");
-			const img = sharp$11(Buffer.from(jpeg));
+			const { default: sharp$12 } = await import("sharp");
+			const img = sharp$12(Buffer.from(jpeg));
 			const meta = await img.metadata();
 			const W = meta.width ?? 0;
 			const H = meta.height ?? 0;
@@ -6396,6 +6686,47 @@ var NcDispatcher = class {
 			return null;
 		}
 	}
+	/**
+	* Draw the group's members onto the still this row already resolved.
+	*
+	* Produced at SEND, like every other media decision here, and returned as
+	* BYTES: an annotated frame is a delivery artefact and must never enter the
+	* media store as a track-owned kind (`retrain-frame-selection.ts` calls a
+	* boxed frame "worse than useless" as model input, and the mosaic renderer
+	* refuses boxes because a burnt-in box is permanent).
+	*
+	* Null on anything less than two drawable members, or on any failure at all —
+	* the caller then ships the frame it already had. A group notification with a
+	* plain picture is a small loss; one that does not arrive is the feature.
+	*/
+	async groupFrame(entry, jpeg) {
+		const group = entry.payload.group;
+		if (group === void 0 || group.members.length < 2) return null;
+		const boxes = group.members.filter((m) => m.bbox !== void 0).map((m) => ({
+			bbox: m.bbox ?? {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			label: m.label ?? ncClassNoun(this.texts, m.className, 1),
+			observedAt: m.at
+		}));
+		if (boxes.length < 2) return null;
+		const anchor = group.members.find((m) => m.trackId === group.anchorTrackId);
+		const composed = await composeGroupFrame({
+			jpeg: Buffer.from(jpeg),
+			boxes,
+			at: anchor?.at ?? Math.max(...group.members.map((m) => m.at)),
+			logger: this.deps.logger,
+			deviceId: entry.payload.subject.deviceId,
+			groupKey: group.key
+		});
+		if (composed === null) return null;
+		const bytes = new Uint8Array(composed.bytes.byteLength);
+		bytes.set(composed.bytes);
+		return bytes;
+	}
 	async resolveAttachment(entry, policyOverride) {
 		const policy = policyOverride ?? entry.payload.media;
 		if (policy === "none") return null;
@@ -6477,11 +6808,21 @@ function percentOf(confidence) {
 * params go last because they are the row's own truth about a system event and
 * outrank the live vocabulary for exactly those names.
 */
+/** Class composition of a group, busiest classes in first-seen order. */
+function classCounts(members) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const m of members) counts.set(m.className, (counts.get(m.className) ?? 0) + 1);
+	return [...counts].map(([className, count]) => ({
+		className,
+		count
+	}));
+}
 function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
 	const subject = entry.payload.subject;
 	const occupancy = subject.occupancy;
 	const systemEvent = subject.systemEvent;
 	const detection = systemEvent?.alarmSource?.className !== void 0 ? systemEvent.alarmSource : void 0;
+	const group = entry.payload.group;
 	return {
 		camera: deviceName,
 		class: detection?.className ?? subject.className,
@@ -6490,18 +6831,19 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels) {
 		subject: detection?.className !== void 0 ? ncSubjectText(texts, {
 			className: detection.className,
 			...detection.label !== void 0 ? { label: detection.label } : {}
-		}) : systemEvent?.subject ?? ncSubjectText(texts, {
+		}) : (group !== void 0 && group.members.length > 1 ? ncGroupSubjectText(texts, { members: group.members }) : void 0) ?? systemEvent?.subject ?? ncSubjectText(texts, {
 			className: subject.className,
 			...subject.label !== void 0 ? { label: subject.label } : {},
 			...subject.labelKind !== void 0 ? { labelKind: subject.labelKind } : {}
 		}),
+		detectionSummary: group !== void 0 && group.members.length > 1 ? ncDetectionSummary(texts, classCounts(group.members)) : "",
 		inZones: ncInZonesText(texts, zoneLabels),
 		scope: occupancy?.zone ?? deviceName,
 		zone: occupancy?.zone ?? zoneLabels[0] ?? "",
 		confidence: percentOf(detection?.confidence ?? subject.confidence),
 		time: new Date(subject.timestamp).toLocaleTimeString(),
 		rule: entry.payload.ruleName,
-		count: occupancy !== void 0 ? `${occupancy.count}` : "",
+		count: occupancy !== void 0 ? `${occupancy.count}` : group !== void 0 && group.members.length > 1 ? `${group.members.length}` : "",
 		capacity: occupancy !== void 0 ? `${occupancy.capacity}` : "",
 		op: occupancy !== void 0 ? ncOccupancyOp(texts, occupancy.occupied) : "",
 		eventKind: systemEvent?.kind ?? "",
@@ -7009,6 +7351,45 @@ function incomingFromSystemEvent(event, lookup) {
 				nodeId
 			});
 		}
+		case "pipeline.node-inference-unavailable": {
+			const nodeId = stringField(data, "nodeId");
+			if (nodeId === void 0) return null;
+			const keys = data["unavailableDeviceKeys"];
+			const devices = Array.isArray(keys) ? keys.filter((k) => typeof k === "string") : [];
+			return systemSubject({
+				facts,
+				kind: "node-inference-unavailable",
+				subject: `node-inference:${nodeId}`,
+				titleKey: "system.node-inference-unavailable.title",
+				bodyKey: "system.node-inference-unavailable.body",
+				textParams: {
+					nodeId,
+					devices: devices.join(", ")
+				},
+				nodeId
+			});
+		}
+		case "pipeline.detection-blind": {
+			const deviceId = numberField(data, "deviceId");
+			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));
+			return systemSubject({
+				facts,
+				kind: "detection-blind",
+				subject: `detection-blind:${deviceId}`,
+				titleKey: "system.detection-blind.title",
+				bodyKey: "system.detection-blind.body",
+				textParams: {
+					...deviceTextParams(deviceId, identity),
+					minutes: String(minutes)
+				},
+				textCount: minutes,
+				deviceId,
+				...identity !== void 0 ? { deviceType: identity.type } : {}
+			});
+		}
 		case "update.available": {
 			const target = stringField(data, "target");
 			const packageName = stringField(data, "packageName");
@@ -8793,6 +9174,353 @@ function rowToEntry$1(id, data) {
 	};
 }
 //#endregion
+//#region src/notification-center/group/nc-group-buffer.ts
+var DEFAULT_MAX_MEMBERS = 12;
+var NcGroupBuffer = class NcGroupBuffer {
+	/** One OPEN group per `${ruleId}${deviceId}`. Sealed groups leave. */
+	open = /* @__PURE__ */ new Map();
+	maxMembers;
+	constructor(options = {}) {
+		this.maxMembers = options.maxMembers !== void 0 && options.maxMembers > 0 ? options.maxMembers : DEFAULT_MAX_MEMBERS;
+	}
+	static slot(ruleId, deviceId) {
+		return `${ruleId}${deviceId}`;
+	}
+	/** Currently open (unsealed) groups — for the store mirror and for tests. */
+	openGroups() {
+		return [...this.open.values()];
+	}
+	/** The open group for this rule + camera, if any. */
+	peek(ruleId, deviceId) {
+		return this.open.get(NcGroupBuffer.slot(ruleId, deviceId));
+	}
+	/**
+	* Offer a matching subject to its group.
+	*
+	* Never throws and never blocks: it is called from inside the serialized
+	* evaluation chain, where a failure would cost the notification itself.
+	*/
+	admit(input, now) {
+		if (!(input.idleSec > 0)) return { outcome: "disabled" };
+		const slot = NcGroupBuffer.slot(input.ruleId, input.deviceId);
+		const existing = this.open.get(slot);
+		const idleMs = input.idleSec * 1e3;
+		if (existing !== void 0 && now - existing.lastActivityAt >= idleMs) {
+			this.open.delete(slot);
+			return this.openGroup(slot, input, now);
+		}
+		if (existing === void 0) return this.openGroup(slot, input, now);
+		const at = existing.members.findIndex((m) => m.trackId === input.member.trackId);
+		if (at === -1) {
+			if (existing.members.length >= this.maxMembers) {
+				this.open.set(slot, {
+					...existing,
+					lastActivityAt: now
+				});
+				return {
+					outcome: "refused",
+					groupKey: existing.key,
+					memberCount: existing.members.length
+				};
+			}
+			const grown = {
+				...existing,
+				members: [...existing.members, input.member],
+				revision: existing.revision + 1,
+				lastGrowthAt: now,
+				lastActivityAt: now,
+				anchorTrackId: input.member.trackId
+			};
+			this.open.set(slot, grown);
+			return {
+				outcome: "grown",
+				group: {
+					...grown,
+					reason: "member"
+				}
+			};
+		}
+		const previous = existing.members[at];
+		const named = input.member.label !== void 0 && input.member.label !== previous.label;
+		const refreshed = {
+			...previous,
+			...input.member.label !== void 0 ? {
+				label: input.member.label,
+				...input.member.labelKind !== void 0 ? { labelKind: input.member.labelKind } : {}
+			} : {},
+			...input.member.bbox !== void 0 ? { bbox: input.member.bbox } : {},
+			eventId: input.member.eventId,
+			at: now
+		};
+		const members = existing.members.map((m, i) => i === at ? refreshed : m);
+		const updated = {
+			...existing,
+			members,
+			lastActivityAt: now,
+			...named ? {
+				revision: existing.revision + 1,
+				lastGrowthAt: now,
+				anchorTrackId: refreshed.trackId
+			} : {}
+		};
+		this.open.set(slot, updated);
+		return named ? {
+			outcome: "grown",
+			group: {
+				...updated,
+				reason: "name"
+			}
+		} : {
+			outcome: "unchanged",
+			group: updated
+		};
+	}
+	/**
+	* Close every group whose idle cutoff has elapsed, and report them ONCE.
+	*
+	* A close is a transition, not a state: re-reporting it every tick would turn
+	* one arrival into an unbounded stream of "group closed" lines. `idleSec` is
+	* carried on the group so a rule edited mid-burst does not change the cutoff
+	* of a burst already open.
+	*/
+	sweep(now) {
+		const closed = [];
+		for (const [slot, group] of this.open) {
+			if (now - group.lastActivityAt < group.idleMs) continue;
+			this.open.delete(slot);
+			closed.push({
+				...group,
+				sealed: true
+			});
+		}
+		return closed;
+	}
+	openGroup(slot, input, now) {
+		const group = {
+			key: `g:${input.ruleId}:d:${input.deviceId}:${now}`,
+			ruleId: input.ruleId,
+			deviceId: input.deviceId,
+			openedAt: now,
+			lastGrowthAt: now,
+			lastActivityAt: now,
+			revision: 1,
+			members: [input.member],
+			anchorTrackId: input.member.trackId,
+			sealed: false,
+			idleMs: input.idleSec * 1e3
+		};
+		this.open.set(slot, group);
+		return {
+			outcome: "opened",
+			group
+		};
+	}
+};
+//#endregion
+//#region src/notification-center/group/nc-group-store.ts
+/**
+* @durable class=audit owner=notification-center
+*   write="one row per burst at OPEN, patched at each growth and at close, best-effort"
+*   retention="ring — the newest NC_GROUP_MAX_ROWS_PER_DEVICE rows per device, pruned on write; never age-keyed"
+*/
+var NC_GROUPS_COLLECTION = "notification-center:track-groups";
+var NC_GROUPS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "ruleId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "openedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "lastGrowthAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** JSON `string[]` — the members, in admission order. */
+	{
+		name: "memberTrackIds",
+		type: "JSON",
+		notNull: true
+	}),
+	{
+		name: "memberCount",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** How many notifications this group has produced (1 at open, +1 per growth). */
+	{
+		name: "revision",
+		type: "INTEGER",
+		notNull: true
+	}),
+	{
+		name: "sealed",
+		type: "BOOLEAN",
+		notNull: true
+	}
+];
+var NC_GROUPS_INDEXES = [{
+	name: "idx_nc_groups_device_opened",
+	columns: ["deviceId", "openedAt"]
+}, {
+	name: "idx_nc_groups_rule",
+	columns: ["ruleId"]
+}];
+/** Read cap, so a client cannot ask for the whole ring in one call. */
+var MAX_QUERY_LIMIT = 200;
+var NcGroupStore = class {
+	store;
+	logger;
+	/** Writes since the last prune, per device — the ring is trimmed lazily. */
+	writesSincePrune = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: NC_GROUPS_COLLECTION,
+			columns: [...NC_GROUPS_COLUMNS],
+			indexes: [...NC_GROUPS_INDEXES]
+		});
+	}
+	/**
+	* Record a group as it stands. Idempotent on the group key, so open, every
+	* growth and the close all write the SAME row — a burst is one record, never
+	* one per revision.
+	*
+	* Best-effort by construction: this is an audit surface, and a failed write
+	* must never cost the notification it is describing. It is called from the
+	* serialized evaluation chain, so it is also deliberately not awaited there.
+	*/
+	async record(group) {
+		try {
+			await this.store.set.mutate({
+				collection: NC_GROUPS_COLLECTION,
+				key: group.key,
+				value: {
+					ruleId: group.ruleId,
+					deviceId: group.deviceId,
+					openedAt: group.openedAt,
+					lastGrowthAt: group.lastGrowthAt,
+					memberTrackIds: group.members.map((m) => m.trackId),
+					memberCount: group.members.length,
+					revision: group.revision,
+					sealed: group.sealed
+				}
+			});
+			await this.pruneIfDue(group.deviceId);
+		} catch (err) {
+			this.logger.warn("group record write failed", {
+				tags: { deviceId: group.deviceId },
+				meta: {
+					groupKey: group.key,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+		}
+	}
+	/** Newest first. The timeline card's read. */
+	async list(query = {}) {
+		const where = {};
+		if (query.deviceId !== void 0) where["deviceId"] = query.deviceId;
+		if (query.ruleId !== void 0) where["ruleId"] = query.ruleId;
+		try {
+			return (await this.store.query.query({
+				collection: NC_GROUPS_COLLECTION,
+				filter: {
+					...Object.keys(where).length > 0 ? { where } : {},
+					...query.since !== void 0 ? { whereBetween: { openedAt: [query.since, Number.MAX_SAFE_INTEGER] } } : {},
+					orderBy: {
+						field: "openedAt",
+						direction: "desc"
+					},
+					limit: Math.min(query.limit ?? 50, MAX_QUERY_LIMIT)
+				}
+			})).map((r) => rowToRecord(r.id, r.data));
+		} catch (err) {
+			this.logger.warn("group record read failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return [];
+		}
+	}
+	/**
+	* Trim the ring for one camera, every {@link PRUNE_EVERY} writes.
+	*
+	* Lazy rather than per-write because the delete is a query + a bulk delete and
+	* a busy camera writes several times per burst; amortising it keeps the write
+	* path a single `set`.
+	*/
+	async pruneIfDue(deviceId) {
+		const n = (this.writesSincePrune.get(deviceId) ?? 0) + 1;
+		if (n < PRUNE_EVERY) {
+			this.writesSincePrune.set(deviceId, n);
+			return;
+		}
+		this.writesSincePrune.set(deviceId, 0);
+		const keep = await this.store.query.query({
+			collection: NC_GROUPS_COLLECTION,
+			filter: {
+				where: { deviceId },
+				orderBy: {
+					field: "openedAt",
+					direction: "desc"
+				},
+				limit: 500,
+				offset: 500
+			}
+		});
+		if (keep.length === 0) return;
+		const cutoff = keep[0]?.data["openedAt"];
+		if (typeof cutoff !== "number") return;
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: NC_GROUPS_COLLECTION,
+			filter: {
+				where: { deviceId },
+				whereBetween: { openedAt: [0, cutoff] }
+			}
+		});
+		if (deleted > 0) this.logger.debug("group ring trimmed", {
+			tags: { deviceId },
+			meta: {
+				deleted,
+				keptPerDevice: 500
+			}
+		});
+	}
+};
+var PRUNE_EVERY = 50;
+function rowToRecord(id, data) {
+	const members = data["memberTrackIds"];
+	return {
+		id,
+		ruleId: typeof data["ruleId"] === "string" ? data["ruleId"] : "",
+		deviceId: typeof data["deviceId"] === "number" ? data["deviceId"] : 0,
+		openedAt: typeof data["openedAt"] === "number" ? data["openedAt"] : 0,
+		lastGrowthAt: typeof data["lastGrowthAt"] === "number" ? data["lastGrowthAt"] : 0,
+		memberTrackIds: Array.isArray(members) ? members.filter((m) => typeof m === "string") : [],
+		memberCount: typeof data["memberCount"] === "number" ? data["memberCount"] : 0,
+		revision: typeof data["revision"] === "number" ? data["revision"] : 1,
+		sealed: data["sealed"] === true
+	};
+}
+//#endregion
 //#region src/notification-center/rule-actions.ts
 var NcRuleActionRunner = class {
 	deps;
@@ -10175,7 +10903,7 @@ var GLYPH_ADVANCE = .56;
 var LABEL_USABLE_FRACTION = .94;
 /** `<`, `>`, `&`, `'`, `"` in a camera name or an operator caption would each
 *  turn the overlay into a document librsvg refuses. */
-function escapeXml$2(s) {
+function escapeXml$1(s) {
 	return s.replace(/[<>&'"]/g, (ch) => {
 		switch (ch) {
 			case "<": return "&lt;";
@@ -10263,7 +10991,7 @@ function tileLabelSvg(width, height, label) {
 	const baseline = height - Math.round((bandHeight - fitted.fontPx) / 2) - Math.round(fitted.fontPx * .18);
 	return Buffer.from(`<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
   <rect x="0" y="${height - bandHeight}" width="${width}" height="${bandHeight}" fill="black" fill-opacity="0.55"/>
-  <text x="${padding}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" fill="white">${escapeXml$2(fitted.text)}</text>
+  <text x="${padding}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" fill="white">${escapeXml$1(fitted.text)}</text>
 </svg>`);
 }
 /** The mosaic's own title band. */
@@ -10272,7 +11000,7 @@ function titleSvg(width, height, caption) {
 	const baseline = Math.round(height / 2 + fitted.fontPx * .36);
 	return Buffer.from(`<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
   <rect x="0" y="0" width="${width}" height="${height}" fill="#111111"/>
-  <text x="${Math.round(width / 2)}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" text-anchor="middle" fill="white">${escapeXml$2(fitted.text)}</text>
+  <text x="${Math.round(width / 2)}" y="${baseline}" font-size="${fitted.fontPx}" font-family="sans-serif" font-weight="bold" text-anchor="middle" fill="white">${escapeXml$1(fitted.text)}</text>
 </svg>`);
 }
 /**
@@ -12039,8 +12767,8 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 	];
 	if (bbox === void 0) return files;
 	try {
-		const { default: sharp$10 } = await import("sharp");
-		const meta = await sharp$10(Buffer.from(jpeg)).metadata();
+		const { default: sharp$11 } = await import("sharp");
+		const meta = await sharp$11(Buffer.from(jpeg)).metadata();
 		const W = meta.width ?? 0;
 		const H = meta.height ?? 0;
 		if (W === 0 || H === 0) return files;
@@ -12048,7 +12776,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		const top = Math.max(0, Math.min(H - 1, Math.floor(bbox.y * H)));
 		const width = Math.max(1, Math.min(W - left, Math.ceil(bbox.w * W)));
 		const height = Math.max(1, Math.min(H - top, Math.ceil(bbox.h * H)));
-		const cropBuf = await sharp$10(Buffer.from(jpeg)).extract({
+		const cropBuf = await sharp$11(Buffer.from(jpeg)).extract({
 			left,
 			top,
 			width,
@@ -12070,7 +12798,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		});
 		const stroke = Math.max(2, Math.round(Math.min(W, H) / 240));
 		const overlay = Buffer.from(`<svg width="${W}" height="${H}"><rect x="${left}" y="${top}" width="${width}" height="${height}" fill="none" stroke="#22d3ee" stroke-width="${stroke}"/></svg>`);
-		const boxedBuf = await sharp$10(Buffer.from(jpeg)).composite([{
+		const boxedBuf = await sharp$11(Buffer.from(jpeg)).composite([{
 			input: overlay,
 			top: 0,
 			left: 0
@@ -14434,6 +15162,16 @@ var NotificationCenter = class NotificationCenter {
 	alarmPanel = null;
 	/** In-memory cooldown map — seeded from persisted outbox rows on start. */
 	lastFiredAt = /* @__PURE__ */ new Map();
+	/**
+	* The open BURSTS, one per (rule, camera). See `group/nc-group-buffer.ts`.
+	*
+	* It sits on the serialized evaluation chain, so it needs no locking, and it
+	* is RAM-only on purpose: losing it costs the current burst its updates and
+	* degrades to exactly the behaviour that shipped before grouping existed.
+	*/
+	groups = new NcGroupBuffer();
+	/** The audit record behind a future timeline card. */
+	groupStore;
 	/** The AI confirm gate, or null when this node has no vision LLM wired. */
 	confirmGate;
 	/**
@@ -14752,6 +15490,10 @@ var NotificationCenter = class NotificationCenter {
 			store: deps.store,
 			logger: this.logger.child("occupancy")
 		});
+		this.groupStore = new NcGroupStore({
+			store: deps.store,
+			logger: this.logger.child("groups")
+		});
 		this.liveness = new NcLivenessLedger({
 			store: deps.store,
 			logger: this.logger.child("liveness")
@@ -14932,6 +15674,7 @@ var NotificationCenter = class NotificationCenter {
 		await NcSummaryStore.declare(store);
 		await NcTextCatalogStore.declare(store);
 		await NcArtifactIndex.declare(store);
+		await NcGroupStore.declare(store);
 	}
 	/**
 	* Load rules (every node — the cap provider serves CRUD from any node).
@@ -16047,8 +16790,74 @@ var NotificationCenter = class NotificationCenter {
 				continue;
 			}
 			this.runRuleActions(rule, subject, kind, controls);
+			const admission = this.admitToGroup(rule, subject, now);
+			if (admission.outcome === "unchanged") {
+				this.logger.debug("subject already in the open group — no new notification", {
+					tags: { deviceId: subject.deviceId },
+					meta: {
+						ruleId: rule.id,
+						rule: rule.name,
+						groupKey: admission.group.key,
+						members: admission.group.members.length,
+						eventId: subject.recordId,
+						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
+					}
+				});
+				outcomes.push({
+					ruleId: rule.id,
+					ruleName: rule.name,
+					matched: true,
+					...evaluation.matchedOn !== void 0 ? { matchedOn: [...evaluation.matchedOn] } : {},
+					cooldown: "suppressed",
+					enqueued: 0,
+					targetIds: []
+				});
+				anyMatched = true;
+				continue;
+			}
+			if (admission.outcome === "refused") {
+				this.logger.info("group is full — subject not added to the notification", {
+					tags: { deviceId: subject.deviceId },
+					meta: {
+						ruleId: rule.id,
+						rule: rule.name,
+						groupKey: admission.groupKey,
+						members: admission.memberCount,
+						eventId: subject.recordId,
+						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
+					}
+				});
+				outcomes.push({
+					ruleId: rule.id,
+					ruleName: rule.name,
+					matched: true,
+					...evaluation.matchedOn !== void 0 ? { matchedOn: [...evaluation.matchedOn] } : {},
+					cooldown: "suppressed",
+					enqueued: 0,
+					targetIds: []
+				});
+				anyMatched = true;
+				continue;
+			}
+			const group = admission.outcome === "disabled" ? void 0 : admission.group;
+			if (group !== void 0) {
+				this.logger.info(admission.outcome === "opened" ? "group opened" : "group grew — updating the notification", {
+					tags: { deviceId: subject.deviceId },
+					meta: {
+						ruleId: rule.id,
+						rule: rule.name,
+						groupKey: group.key,
+						revision: group.revision,
+						members: group.members.length,
+						...group.reason !== void 0 ? { grewBy: group.reason } : {},
+						eventId: subject.recordId,
+						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
+					}
+				});
+				this.groupStore.record(group);
+			}
 			const key = cooldownKey(rule, subject);
-			const cooling = isCoolingDown(rule, this.lastFiredAt.get(key), now);
+			const cooling = group !== void 0 && admission.outcome === "grown" ? false : isCoolingDown(rule, this.lastFiredAt.get(key), now);
 			if (cooling && controls.bypassCooldown !== true) {
 				this.logger.debug("rule matched but is cooling down", {
 					tags: { deviceId: subject.deviceId },
@@ -16110,7 +16919,7 @@ var NotificationCenter = class NotificationCenter {
 			const entries = this.buildEntries(rule, subject, kind, evaluation.matchedOn, userTargets, origin, {
 				key,
 				at: now
-			});
+			}, void 0, group);
 			const inserted = await this.outbox.enqueue(entries);
 			this.noteRecognitionFire(rule, subject, kind, entries, inserted);
 			if (inserted > 0 && controls.bypassCooldown !== true) this.lastFiredAt.set(key, now);
@@ -16244,6 +17053,78 @@ var NotificationCenter = class NotificationCenter {
 		}
 	}
 	/**
+	* Offer a matching subject to its rule's open burst.
+	*
+	* Every gate lives here so the evaluation loop reads as one decision:
+	*
+	*  - **grouping is per-rule and opt-in.** No `groupIdleSec` ⇒ `disabled` ⇒
+	*    the caller does exactly what it did before this existed;
+	*  - **a subject with no track cannot be a member.** A device event, a system
+	*    event and an occupancy edge have no subject to draw a box for and no
+	*    identity to add later — grouping them would be grouping *records*, which
+	*    is not what the operator asked about;
+	*  - **an actuation is never grouped.** `runRuleActions` has already fired by
+	*    the time this is reached, and deliberately so: "how often may this gate
+	*    physically move" is the sequence runner's own `minDelaySec`, and it must
+	*    not become a notification question.
+	*/
+	admitToGroup(rule, subject, now) {
+		const idleSec = rule.groupIdleSec;
+		if (idleSec === void 0 || idleSec <= 0) return { outcome: "disabled" };
+		const trackId = subject.trackId;
+		if (trackId === void 0) return { outcome: "disabled" };
+		const member = {
+			trackId,
+			className: subject.classNames[0] ?? "event",
+			...subject.label !== void 0 ? { label: subject.label } : {},
+			...subject.labelKind !== void 0 ? { labelKind: subject.labelKind } : {},
+			...subject.bbox !== void 0 ? { bbox: subject.bbox } : {},
+			eventId: subject.recordId,
+			at: subject.timestamp
+		};
+		return this.groups.admit({
+			ruleId: rule.id,
+			deviceId: subject.deviceId,
+			idleSec,
+			member
+		}, now);
+	}
+	/**
+	* The grouped bursts, newest first — the timeline card's read.
+	*
+	* The STORE, not the live buffer: a card is about arrivals that happened, and
+	* the buffer only knows the ones still open on this process. The open group's
+	* row is written at open and patched at each growth, so a burst in progress
+	* is in the answer too, with `sealed: false`.
+	*/
+	async listTrackGroups(query = {}) {
+		return this.groupStore.list(query);
+	}
+	/**
+	* Close every burst whose idle cutoff has elapsed, and say so ONCE.
+	*
+	* Ridden on the outbox drain tick rather than a timer of its own: the drain
+	* already runs every 2 s, which is an order of magnitude finer than the
+	* shortest sensible cutoff, and a second interval would be a second thing to
+	* stop on shutdown. The close is a LOG plus a sealed record — it sends
+	* nothing. Nobody wants a notification saying a group is over.
+	*/
+	sweepGroups(now) {
+		for (const group of this.groups.sweep(now)) {
+			this.logger.info("group closed", {
+				tags: { deviceId: group.deviceId },
+				meta: {
+					ruleId: group.ruleId,
+					groupKey: group.key,
+					members: group.members.length,
+					revisions: group.revision,
+					openForMs: group.lastActivityAt - group.openedAt
+				}
+			});
+			this.groupStore.record(group);
+		}
+	}
+	/**
 	* Run this rule's `onTrigger` sequences for this match.
 	*
 	* Called BEFORE the cooldown gate — see the call site for why. Everything
@@ -16311,7 +17192,7 @@ var NotificationCenter = class NotificationCenter {
 			}
 		});
 	}
-	buildEntries(rule, subject, kind, matchedOn, userTargets = [], origin = "pipeline", cooldown, upgrade) {
+	buildEntries(rule, subject, kind, matchedOn, userTargets = [], origin = "pipeline", cooldown, upgrade, group) {
 		const hasEventMedia = kind === "object-event" || kind === "package-event";
 		const isTrackScoped = kind === "object-event" || kind === "track-end";
 		const isSystemEvent = kind === "system-event";
@@ -16345,6 +17226,19 @@ var NotificationCenter = class NotificationCenter {
 				...!noMedia && mediaRule.media?.clipSpeed !== void 0 ? { mediaClipSpeed: mediaRule.media.clipSpeed } : {},
 				...!noMedia && mediaRule.media.clipPostRollSec !== void 0 ? { mediaClipPostRollSec: mediaRule.media.clipPostRollSec } : {},
 				...matchedOn !== void 0 && matchedOn.length > 0 ? { matchedOn } : {},
+				...group !== void 0 && group.members.length > 1 ? { group: {
+					key: group.key,
+					revision: group.revision,
+					anchorTrackId: group.anchorTrackId,
+					members: group.members.map((m) => ({
+						trackId: m.trackId,
+						className: m.className,
+						...m.label !== void 0 ? { label: m.label } : {},
+						...m.labelKind === "identity" || m.labelKind === "plate" ? { labelKind: m.labelKind } : {},
+						...m.bbox !== void 0 ? { bbox: m.bbox } : {},
+						at: m.at
+					}))
+				} } : {},
 				...target.params !== void 0 ? { params: target.params } : {},
 				subject: {
 					deviceId: subject.deviceId,
@@ -16367,7 +17261,7 @@ var NotificationCenter = class NotificationCenter {
 				recordKind: kind === "occupancy-event" ? "device-event" : kind,
 				recordId: subject.recordId,
 				...isTrackScoped && subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
-				...upgrade !== void 0 ? { dedupRef: upgrade.dedupRef } : {},
+				...upgrade !== void 0 ? { dedupRef: upgrade.dedupRef } : group !== void 0 && group.revision > 1 ? { dedupRef: `${group.key}:v${group.revision}` } : {},
 				payload
 			};
 		});
@@ -16741,6 +17635,7 @@ var NotificationCenter = class NotificationCenter {
 	}
 	async drainTick() {
 		await this.snoozes.load();
+		this.sweepGroups(this.now());
 		await this.outbox.drainOnce();
 		await this.deliverDueDigests();
 		this.drainTicks += 1;
@@ -17189,6 +18084,8 @@ function systemEventSubject(kind, scope) {
 	if (kind === "device-online" || kind === "device-offline") return `device:${scope.deviceId ?? 0}`;
 	if (kind === "stream-online" || kind === "stream-offline") return `stream:${scope.deviceId ?? 0}`;
 	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 === "addon-update-available" || kind === "server-update-available") return `package:${scope.packageName ?? "@camstack/server"}`;
 	return `alarm:${scope.deviceId ?? 0}`;
 }
@@ -17295,7 +18192,9 @@ function planRuleTest(input) {
 					currentVersion: "0.0.0",
 					latestVersion: "0.0.0",
 					profile: "low",
-					seconds: "30"
+					seconds: "30",
+					devices: "cuda:0",
+					minutes: "15"
 				},
 				...systemScope.deviceId !== void 0 ? { deviceId: systemScope.deviceId } : {},
 				...c.systemEvent?.deviceTypes?.[0] !== void 0 ? { deviceType: c.systemEvent.deviceTypes[0] } : {},
@@ -17345,6 +18244,27 @@ var NcViewerTimelapseRuleSchema = require_dist.TimelapseRuleSchema.extend({ read
 /** Same verdict, for a multi-camera digest rule. */
 var NcViewerSummaryRuleSchema = NcSummaryRuleSchema.extend({ readOnly: require_dist.boolean() });
 /**
+* One grouped burst, as the viewer reads it.
+*
+* The LIGHT half of the Phase-2 group entity on purpose: ids and timestamps, no
+* representative frame and no clustering verdict. A card needs to know which
+* tracks were one arrival and when; anything more would be a second source of
+* truth about a relation the entity has not been built for yet.
+*/
+var NcTrackGroupSchema = require_dist.object({
+	id: require_dist.string(),
+	ruleId: require_dist.string(),
+	deviceId: require_dist.number().int(),
+	openedAt: require_dist.number().int(),
+	lastGrowthAt: require_dist.number().int(),
+	memberTrackIds: require_dist.array(require_dist.string()).readonly(),
+	memberCount: require_dist.number().int(),
+	/** How many notifications the burst produced — 1 at open, +1 per growth. */
+	revision: require_dist.number().int(),
+	/** False while the arrival is still happening. */
+	sealed: require_dist.boolean()
+});
+/**
 * The action catalog — the tRPC contract Group B (the viewer client) consumes
 * against `addonId: 'pipeline-analytics'`. Every entry that depends on the
 * caller identity is declared `caller: 'required'` so the dispatcher forwards
@@ -17385,6 +18305,22 @@ var ncActions = require_dist.defineCustomActions({
 	* desk. Scoped to the caller: their own windows plus the global ones that
 	* silence them.
 	*/
+	/**
+	* The BURSTS this hub has grouped — the data half of the timeline's
+	* expandable group card.
+	*
+	* Rides the generic bridge, like every other viewer read here: no cap method,
+	* no codegen, ships train-free. Read-only and deliberately thin — it answers
+	* "which tracks were one arrival", and the per-subject tracks stay the record
+	* and stay clickable. A group card EXPANDS to its members; it never replaces
+	* them.
+	*/
+	"nc.listTrackGroups": require_dist.customAction(require_dist.object({
+		deviceId: require_dist.number().int().optional(),
+		ruleId: require_dist.string().optional(),
+		since: require_dist.number().int().optional(),
+		limit: require_dist.number().int().min(1).max(200).optional()
+	}), require_dist.object({ groups: require_dist.array(NcTrackGroupSchema) }), { caller: "required" }),
 	"nc.listSnoozes": require_dist.customAction(require_dist.object({}), require_dist.object({ snoozes: require_dist.array(require_dist.NcSnoozeSchema) }), { caller: "required" }),
 	"nc.createSnooze": require_dist.customAction(require_dist.object({ snooze: require_dist.NcSnoozeInputSchema }), require_dist.object({ snooze: require_dist.NcSnoozeSchema }), {
 		kind: "mutation",
@@ -17718,6 +18654,12 @@ function makeNcActionHandlers(deps) {
 				readOnly: !c.isAdmin && r.ownerUserId !== c.userId
 			})) };
 		},
+		"nc.listTrackGroups": async (input, caller) => {
+			requireCaller(caller);
+			const list = deps.listTrackGroups;
+			if (list === void 0) return { groups: [] };
+			return { groups: [...await list(input)] };
+		},
 		"nc.getConditionCatalog": async () => ({
 			catalog: [...require_dist.NC_CONDITION_CATALOG],
 			taxonomy: require_dist.NC_TAXONOMY
@@ -18334,7 +19276,7 @@ function buildProbeDurationArgs(inputPath) {
 }
 /** `<`, `>`, `&`, `'` and `"` in an operator's free-text caption would each
 *  turn the overlay into a document librsvg refuses. */
-function escapeXml$1(s) {
+function escapeXml(s) {
 	return s.replace(/[<>&'"]/g, (ch) => {
 		switch (ch) {
 			case "<": return "&lt;";
@@ -18422,7 +19364,7 @@ function buildTitleSvg(input) {
   <rect x="0" y="0" width="${width}" height="${height}" fill="black" fill-opacity="${TITLE_SCRIM_OPACITY}"/>
 ${lines.map((line, i) => {
 		const y = top + lineHeight * i + Math.round(fontPx * .8);
-		const esc = escapeXml$1(line);
+		const esc = escapeXml(line);
 		return [`  <text x="${cx + shadow}" y="${y + shadow}" ${font} fill="black" fill-opacity="${TITLE_SHADOW_OPACITY}">${esc}</text>`, `  <text x="${cx}" y="${y}" ${font} fill="white">${esc}</text>`].join("\n");
 	}).join("\n")}
 </svg>`;
@@ -21730,6 +22672,8 @@ function ruleApplies(resolved, det, className, maskInfo, _zones, frameWidth, fra
 *
 * One FrameProcessor per device — lifecycle managed by DeviceRegistry.
 */
+/** Shared empty — a fold is rare and every other frame would allocate. */
+var EMPTY_RIDER_FOLDS = [];
 /** Mapping from StateAnalyzer's `ObjectState.state` values to the
 *  canonical TrackState enum used on tracks + events. */
 function mapObjectStateToTrackState(s) {
@@ -21788,8 +22732,6 @@ var FrameProcessor = class {
 	* this frame still carries the zones it was in. See the use site.
 	*/
 	lastZonesByTrack = /* @__PURE__ */ new Map();
-	/** See {@link getLastRiderPairs}. */
-	lastRiderPairs = [];
 	/** See {@link getLastLabelWriteRefusals}. */
 	lastLabelWriteRefusals = [];
 	/**
@@ -21850,17 +22792,11 @@ var FrameProcessor = class {
 	setZoneMembershipMinOverlap(minOverlap) {
 		this.zoneMembershipMinOverlap = Number.isFinite(minOverlap) && minOverlap >= 0 && minOverlap <= 1 ? minOverlap : 0;
 	}
-	/** Rider pairings folded on the most recent frame — the PERSON half that was
-	*  dropped so the passage counts once, as a vehicle. Reported so both
-	*  entities stay on the record rather than one silently disappearing. */
-	getLastRiderPairs() {
-		return this.lastRiderPairs;
-	}
 	/**
 	* Label candidates the write rule refused on the most recent frame (see
 	* `resolveTieredLabelWrite` in `label-tier.ts`).
 	*
-	* Reported for the same reason as {@link getLastRiderPairs}: the branch DROPS
+	* Reported for the same reason a {@link RiderFold} is: the branch DROPS
 	* a value, and a drop nobody logs reads as "it never happened". The five live
 	* rows that produced the macro-class rule were found by reading the rows, a
 	* week after the fact. Deduped per (track, token) so a track that keeps
@@ -21985,16 +22921,30 @@ var FrameProcessor = class {
 			bbox: d.bbox,
 			score: d.score
 		})));
+		/**
+		* Pending folds, keyed by the SURVIVING vehicle's bbox object.
+		*
+		* The bbox object reference is the file's established way to carry
+		* frame-local facts across the tracker (`labelsByBbox`,
+		* `firstLevelBboxById`): the tracker assigns `track.bbox = det.bbox` on
+		* every match and spawn, so the emitted `TrackedDetection.bbox` IS this
+		* object when the vehicle was seen this frame.
+		*/
+		const foldByVehicleBbox = /* @__PURE__ */ new Map();
 		if (riderPairs.length > 0) {
 			const riderIdx = new Set(riderPairs.map((p) => Number(p.personId)));
-			this.lastRiderPairs = riderPairs.map((p) => ({
-				overlap: p.overlap,
-				personScore: filteredDetections[Number(p.personId)]?.score ?? 0,
-				vehicleScore: filteredDetections[Number(p.vehicleId)]?.score ?? 0,
-				vehicleClass: filteredDetections[Number(p.vehicleId)]?.originalClass ?? "two-wheeler"
-			}));
+			for (const p of riderPairs) {
+				const vehicle = filteredDetections[Number(p.vehicleId)];
+				if (vehicle === void 0) continue;
+				foldByVehicleBbox.set(vehicle.bbox, {
+					overlap: p.overlap,
+					personScore: filteredDetections[Number(p.personId)]?.score ?? 0,
+					vehicleScore: vehicle.score,
+					vehicleClass: vehicle.originalClass ?? "two-wheeler"
+				});
+			}
 			filteredDetections = filteredDetections.filter((_, i) => !riderIdx.has(i));
-		} else if (this.lastRiderPairs.length > 0) this.lastRiderPairs = [];
+		}
 		const gate = this.stationaryGate ? this.stationaryGate.filter({
 			detections: filteredDetections,
 			frameWidth,
@@ -22009,6 +22959,13 @@ var FrameProcessor = class {
 			frameWidth,
 			frameHeight
 		});
+		const riderFolds = foldByVehicleBbox.size === 0 ? EMPTY_RIDER_FOLDS : [...foldByVehicleBbox].map(([bbox, fold]) => {
+			const td = trackedDetections.find((t) => t.bbox === bbox && t.matchedThisFrame !== false);
+			return td !== void 0 ? {
+				...fold,
+				trackId: td.trackId
+			} : fold;
+		});
 		const objectStates = this.stateAnalyzer.analyze(trackedDetections, timestamp);
 		const zonesByTrack = /* @__PURE__ */ new Map();
 		const overlapsByTrack = /* @__PURE__ */ new Map();
@@ -22204,7 +23161,8 @@ var FrameProcessor = class {
 			appearanceEvents,
 			rawTrackedDetections: trackedDetections,
 			stationaryConfirmed: gate.confirmed,
-			stationaryWoken: gate.wokenEntryIds
+			stationaryWoken: gate.wokenEntryIds,
+			riderFolds
 		};
 	}
 };
@@ -31014,77 +31972,6 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 	return scored.slice(0, options.limit);
 }
 //#endregion
-//#region src/shared/frame/box-drawer.ts
-var DEFAULT_COLOR = require_dist.DEFAULT_EVENT_COLOR;
-var DEFAULT_QUALITY = 80;
-var STROKE_WIDTH = 3;
-function escapeXml(s) {
-	return s.replace(/[<>&'"]/g, (ch) => {
-		switch (ch) {
-			case "<": return "&lt;";
-			case ">": return "&gt;";
-			case "&": return "&amp;";
-			case "'": return "&apos;";
-			default: return "&quot;";
-		}
-	});
-}
-/** Clamp a pixel box to the frame so the rect always stays inside [0,W]×[0,H]. */
-function clampBox(b, frameWidth, frameHeight) {
-	const x = Math.max(0, Math.min(Math.round(b.x), frameWidth - 1));
-	const y = Math.max(0, Math.min(Math.round(b.y), frameHeight - 1));
-	return {
-		x,
-		y,
-		w: Math.max(1, Math.min(Math.round(b.w), frameWidth - x)),
-		h: Math.max(1, Math.min(Math.round(b.h), frameHeight - y))
-	};
-}
-/**
-* Draw bounding boxes over a raw RGB frame and JPEG-encode it.
-*
-* The frame is composited with an SVG overlay (one `<rect>` per box, plus an
-* optional caption) at full resolution, then optionally downscaled — so the
-* box stays crisp relative to the scene. Boxes are clamped to frame bounds to
-* avoid sharp `extract`/region errors on slightly-out-of-range detections.
-*/
-async function drawBoxedFrame(frameData, frameWidth, frameHeight, boxes, opts = {}) {
-	const quality = opts.quality ?? DEFAULT_QUALITY;
-	let base = frameData;
-	let baseIsRaw = true;
-	if (boxes.length > 0) {
-		const fontSize = Math.max(12, Math.round(frameHeight / 30));
-		const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${frameWidth}" height="${frameHeight}">${boxes.map((b) => {
-			const c = clampBox(b, frameWidth, frameHeight);
-			const color = b.color ?? DEFAULT_COLOR;
-			const rect = `<rect x="${c.x}" y="${c.y}" width="${c.w}" height="${c.h}" fill="none" stroke="${color}" stroke-width="${STROKE_WIDTH}"/>`;
-			if (!b.label) return rect;
-			const ty = Math.max(fontSize, c.y - 4);
-			return rect + `<text x="${c.x}" y="${ty}" font-family="sans-serif" font-size="${fontSize}" fill="${color}" stroke="black" stroke-width="0.5">${escapeXml(b.label)}</text>`;
-		}).join("")}</svg>`;
-		base = await (0, sharp.default)(frameData, { raw: {
-			width: frameWidth,
-			height: frameHeight,
-			channels: 3
-		} }).composite([{
-			input: Buffer.from(svg),
-			top: 0,
-			left: 0
-		}]).png().toBuffer();
-		baseIsRaw = false;
-	}
-	let pipeline = baseIsRaw ? (0, sharp.default)(base, { raw: {
-		width: frameWidth,
-		height: frameHeight,
-		channels: 3
-	} }) : (0, sharp.default)(base);
-	if (opts.maxWidth !== void 0) pipeline = pipeline.resize({
-		width: opts.maxWidth,
-		withoutEnlargement: true
-	});
-	return pipeline.jpeg({ quality }).toBuffer();
-}
-//#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-capture.ts
 /** Cap (px) on the width of the native KEY FRAME (full-frame native capture).
 *  Native resolution is the point: a 4K cam (3840) resolves TRUE native (no
@@ -31514,9 +32401,22 @@ function pickedUpEventId(entryId) {
 }
 var PackageDropDetector = class {
 	deps;
+	/** Per-device mirror of the last LOGGED value of the `packageDropEnabled`
+	*  switch, so gate 0 logs a transition instead of one line per promotion. */
+	disabledLogged = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
 	}
+	/** Log the `packageDropEnabled` switch only when it MOVES for a device. */
+	noteDisabled(deviceId, disabled) {
+		if (this.disabledLogged.get(deviceId) === disabled) return;
+		this.disabledLogged.set(deviceId, disabled);
+		if (disabled) this.deps.logger.info("package gate 0/5 switch — packageDropEnabled is false", { tags: { deviceId } });
+	}
+	/** Drop a device's gate-log mirror (unbind / teardown). */
+	forgetDevice(deviceId) {
+		this.disabledLogged.delete(deviceId);
+	}
 	/** Single entrypoint — bridge the registry's `onChange` here. Never
 	*  throws (telemetry-lossy, D8): a failure only misses one package event. */
 	async onStationaryChange(change) {
@@ -31537,22 +32437,104 @@ var PackageDropDetector = class {
 	}
 	async onAppeared(entry, timestamp) {
 		const settings = await this.deps.resolveSettings(entry.deviceId);
-		if (!settings.packageDropEnabled) return;
-		if (!settings.packageDropClassFilter.includes(entry.className)) return;
+		if (!settings.packageDropEnabled) {
+			this.noteDisabled(entry.deviceId, true);
+			return;
+		}
+		this.noteDisabled(entry.deviceId, false);
+		if (!settings.packageDropClassFilter.includes(entry.className)) {
+			this.deps.logger.debug("package gate 1/5 class — not a package class", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					entryId: entry.id,
+					className: entry.className,
+					classFilter: settings.packageDropClassFilter
+				}
+			});
+			return;
+		}
+		const tags = { deviceId: entry.deviceId };
 		const rules = (await this.deps.resolvePackageRules(entry.deviceId)).filter((r) => r.enabled !== false);
-		if (rules.length === 0) return;
+		if (rules.length === 0) {
+			this.deps.logger.info("package gate 2/5 zone — no enabled package-stage zone rule", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					className: entry.className
+				}
+			});
+			return;
+		}
 		const ruleZoneIds = new Set(rules.flatMap((r) => r.zoneIds));
-		const hitZones = computeStationaryEntryZones(entry, await this.deps.resolveZones(entry.deviceId)).filter((z) => ruleZoneIds.has(z));
-		if (hitZones.length === 0) return;
-		if (timestamp - entry.firstSeenAt < settings.packageDropDwellSec * 1e3) return;
+		const zones = await this.deps.resolveZones(entry.deviceId);
+		const entryZones = computeStationaryEntryZones(entry, zones);
+		const hitZones = entryZones.filter((z) => ruleZoneIds.has(z));
+		if (hitZones.length === 0) {
+			this.deps.logger.info("package gate 2/5 zone — centroid outside every package zone", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					bbox: entry.bbox,
+					entryZones,
+					ruleZoneIds: [...ruleZoneIds],
+					zonesOnDevice: zones.length
+				}
+			});
+			return;
+		}
+		const dwellMs = timestamp - entry.firstSeenAt;
+		const requiredDwellMs = settings.packageDropDwellSec * 1e3;
+		if (dwellMs < requiredDwellMs) {
+			this.deps.logger.info("package gate 3/5 dwell — not still long enough", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					dwellMs,
+					requiredDwellMs
+				}
+			});
+			return;
+		}
 		const frameArea = entry.frameWidth * entry.frameHeight;
-		if (frameArea <= 0) return;
-		if (entry.bbox.w * entry.bbox.h / frameArea < settings.packageDropMinBboxAreaFrac) return;
+		if (frameArea <= 0) {
+			this.deps.logger.info("package gate 4/5 size — frame dimensions unknown", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					frameWidth: entry.frameWidth,
+					frameHeight: entry.frameHeight
+				}
+			});
+			return;
+		}
+		const areaFrac = entry.bbox.w * entry.bbox.h / frameArea;
+		if (areaFrac < settings.packageDropMinBboxAreaFrac) {
+			this.deps.logger.info("package gate 4/5 size — bbox below the minimum area", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					areaFrac: Number(areaFrac.toFixed(5)),
+					minAreaFrac: settings.packageDropMinBboxAreaFrac,
+					bbox: entry.bbox,
+					frame: [entry.frameWidth, entry.frameHeight]
+				}
+			});
+			return;
+		}
 		const eventId = deliveredEventId(entry.id);
 		if ((await this.deps.events.queryObject({
 			deviceId: entry.deviceId,
 			classFilter: "package"
-		})).some((e) => e.id === eventId)) return;
+		})).some((e) => e.id === eventId)) {
+			this.deps.logger.info("package gate 5/5 idempotence — delivery already recorded", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					eventId
+				}
+			});
+			return;
+		}
 		const ev = {
 			id: eventId,
 			kind: "object",
@@ -31562,7 +32544,7 @@ var PackageDropDetector = class {
 			trackId: entry.sourceTrackId ?? entry.id,
 			className: PACKAGE_EVENT_CLASS,
 			...entry.label !== void 0 ? { label: entry.label } : {},
-			confidence: PACKAGE_IMPORTANCE,
+			confidence: entry.confidence ?? PACKAGE_IMPORTANCE,
 			bbox: {
 				x: entry.bbox.x,
 				y: entry.bbox.y,
@@ -31593,9 +32575,26 @@ var PackageDropDetector = class {
 			},
 			timestamp
 		});
+		this.deps.logger.info("package delivered — all 5 gates passed", {
+			tags: { deviceId: entry.deviceId },
+			meta: {
+				entryId: entry.id,
+				eventId,
+				zoneIds: hitZones,
+				dwellMs,
+				areaFrac: Number(areaFrac.toFixed(5)),
+				...entry.confidence !== void 0 ? { confidence: entry.confidence } : {}
+			}
+		});
 	}
 	async onDeparted(entry, timestamp) {
-		if (!(await this.deps.resolveSettings(entry.deviceId)).packageDropPickupEnabled) return;
+		if (!(await this.deps.resolveSettings(entry.deviceId)).packageDropPickupEnabled) {
+			this.deps.logger.debug("package pick-up skipped — packageDropPickupEnabled is false", {
+				tags: { deviceId: entry.deviceId },
+				meta: { entryId: entry.id }
+			});
+			return;
+		}
 		const deliveredId = deliveredEventId(entry.id);
 		const pickedUpId = pickedUpEventId(entry.id);
 		const rows = await this.deps.events.queryObject({
@@ -31603,8 +32602,26 @@ var PackageDropDetector = class {
 			classFilter: PACKAGE_EVENT_CLASS
 		});
 		const delivered = rows.find((e) => e.id === deliveredId);
-		if (delivered === void 0) return;
-		if (rows.some((e) => e.id === pickedUpId)) return;
+		if (delivered === void 0) {
+			this.deps.logger.debug("package pick-up skipped — no delivery row for this entry", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					entryId: entry.id,
+					className: entry.className
+				}
+			});
+			return;
+		}
+		if (rows.some((e) => e.id === pickedUpId)) {
+			this.deps.logger.info("package pick-up skipped — already recorded", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					entryId: entry.id,
+					eventId: pickedUpId
+				}
+			});
+			return;
+		}
 		const ev = {
 			id: pickedUpId,
 			kind: "object",
@@ -31636,6 +32653,14 @@ var PackageDropDetector = class {
 			className: entry.className,
 			timestamp
 		});
+		this.deps.logger.info("package picked up", {
+			tags: { deviceId: entry.deviceId },
+			meta: {
+				entryId: entry.id,
+				eventId: pickedUpId,
+				deliveredEventId: deliveredId
+			}
+		});
 	}
 };
 //#endregion
@@ -31821,6 +32846,150 @@ function evaluateStationaryPromotion(input) {
 		spanFrac: metrics.pathSpanFrac
 	};
 }
+var DEFAULT_PACKAGE_STILLNESS_CONFIG = {
+	minRounds: 2,
+	roundGapMs: 5e3,
+	ttlMs: 5 * 6e4,
+	assocIou: .3
+};
+var PackageStillnessTracker = class {
+	config;
+	newId;
+	byDevice = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.config = deps.config ?? DEFAULT_PACKAGE_STILLNESS_CONFIG;
+		this.newId = deps.newId;
+	}
+	/**
+	* Fold one frame's package sightings into the per-device candidate set and
+	* report the transitions. Immutable: every candidate touched is replaced,
+	* never mutated. Never throws.
+	*/
+	observe(input) {
+		const next = [...this.byDevice.get(input.deviceId) ?? []];
+		const consumed = /* @__PURE__ */ new Set();
+		const promoted = [];
+		for (const s of input.sightings) {
+			const index = this.bestMatch(next, s, consumed);
+			if (index < 0) {
+				const fresh = this.openCandidate(input, s);
+				next.push(fresh);
+				consumed.add(fresh.id);
+				continue;
+			}
+			const prev = next[index];
+			if (prev === void 0) continue;
+			consumed.add(prev.id);
+			const updated = confirm(prev, input, s, this.config.roundGapMs);
+			if (!(updated.promotedAt === null && updated.rounds >= this.config.minRounds && input.timestamp - updated.firstSeenAt >= input.minDwellMs)) {
+				next[index] = updated;
+				continue;
+			}
+			const parked = {
+				...updated,
+				promotedAt: input.timestamp
+			};
+			next[index] = parked;
+			promoted.push(toEntry(parked));
+		}
+		const departed = [];
+		const kept = [];
+		for (const c of next) {
+			if (input.timestamp - c.lastSeenAt > this.config.ttlMs) {
+				if (c.promotedAt !== null) departed.push(toEntry(c));
+				continue;
+			}
+			kept.push(c);
+		}
+		if (kept.length === 0) this.byDevice.delete(input.deviceId);
+		else this.byDevice.set(input.deviceId, kept);
+		return {
+			promoted,
+			departed
+		};
+	}
+	/** Drop a device's candidates (unbind / step disabled). */
+	forgetDevice(deviceId) {
+		this.byDevice.delete(deviceId);
+	}
+	reset() {
+		this.byDevice.clear();
+	}
+	/** Live candidate count for a device — diagnostics and tests only. */
+	debugCandidateCount(deviceId) {
+		return this.byDevice.get(deviceId)?.length ?? 0;
+	}
+	/** Best same-class candidate over the association floor, ignoring any already
+	*  consumed by an earlier sighting in THIS frame (two boxes never collapse
+	*  into one parcel). */
+	bestMatch(candidates, s, consumed) {
+		let bestIndex = -1;
+		let bestIou = this.config.assocIou;
+		for (let i = 0; i < candidates.length; i += 1) {
+			const c = candidates[i];
+			if (c === void 0 || consumed.has(c.id) || c.className !== s.className) continue;
+			const overlap = iou(c.bbox, s.bbox);
+			if (overlap >= bestIou) {
+				bestIou = overlap;
+				bestIndex = i;
+			}
+		}
+		return bestIndex;
+	}
+	openCandidate(input, s) {
+		return {
+			id: this.newId(),
+			deviceId: input.deviceId,
+			className: s.className,
+			bbox: { ...s.bbox },
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight,
+			firstSeenAt: input.timestamp,
+			lastSeenAt: input.timestamp,
+			rounds: 1,
+			promotedAt: null,
+			...s.trackId !== void 0 ? { sourceTrackId: s.trackId } : {},
+			...s.label !== void 0 ? { label: s.label } : {},
+			...s.confidence !== void 0 ? { confidence: s.confidence } : {},
+			...s.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: s.keyFrameMediaKey } : {}
+		};
+	}
+};
+/** Re-confirm a candidate with this frame's box. A new ROUND is only counted
+*  when the gap since the last sighting clears `roundGapMs`, so a burst of
+*  frames inside one governor round counts once. */
+function confirm(prev, input, s, roundGapMs) {
+	const newRound = input.timestamp - prev.lastSeenAt >= roundGapMs;
+	return {
+		...prev,
+		bbox: { ...s.bbox },
+		frameWidth: input.frameWidth,
+		frameHeight: input.frameHeight,
+		lastSeenAt: input.timestamp,
+		rounds: newRound ? prev.rounds + 1 : prev.rounds,
+		...s.trackId !== void 0 ? { sourceTrackId: s.trackId } : {},
+		...s.label !== void 0 ? { label: s.label } : {},
+		...s.confidence !== void 0 ? { confidence: s.confidence } : {},
+		...s.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: s.keyFrameMediaKey } : {}
+	};
+}
+function toEntry(c) {
+	return {
+		id: c.id,
+		deviceId: c.deviceId,
+		className: c.className,
+		bbox: { ...c.bbox },
+		frameWidth: c.frameWidth,
+		frameHeight: c.frameHeight,
+		firstSeenAt: c.firstSeenAt,
+		becameStationaryAt: c.promotedAt ?? c.lastSeenAt,
+		lastConfirmedAt: c.lastSeenAt,
+		...c.sourceTrackId !== void 0 ? { sourceTrackId: c.sourceTrackId } : {},
+		...c.label !== void 0 ? { label: c.label } : {},
+		...c.confidence !== void 0 ? { confidence: c.confidence } : {},
+		...c.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: c.keyFrameMediaKey } : {}
+	};
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-registry.ts
 /**
@@ -33617,6 +34786,24 @@ var OBJECT_COLUMNS = [
 		name: "source",
 		type: "TEXT"
 	},
+	(
+	/**
+	* The SCENE key — every event of one processed frame shares it
+	* (`frame-processor.ts`, stamped on every emitted event).
+	*
+	* It was documented on the cap from the day the collection existed ("lets a
+	* consumer group co-occurring detections (e.g. 2 people + 1 dog) under one
+	* full frame"), stamped by the producer, and read back by `slimObject` — with
+	* no column to land in. The sqlite backend drops an undeclared key WITHOUT
+	* ERROR (`if (decl.columns.has(k))`), so the value was written into the void
+	* on every row ever persisted and the co-occurrence relation was unanswerable
+	* from SQL. Additive and nullable: legacy rows keep reading `undefined`,
+	* which is the truth about them.
+	*/
+	{
+		name: "frameId",
+		type: "TEXT"
+	}),
 	{
 		name: "trackId",
 		type: "TEXT",
@@ -33726,10 +34913,17 @@ var EventStore = class {
 		await store.declareCollection.mutate({
 			collection: OBJECT_EVENTS_COLLECTION,
 			columns: [...OBJECT_COLUMNS],
-			indexes: [...COMMON_INDEXES("object"), {
-				name: "idx_object_track",
-				columns: ["trackId"]
-			}]
+			indexes: [
+				...COMMON_INDEXES("object"),
+				{
+					name: "idx_object_track",
+					columns: ["trackId"]
+				},
+				{
+					name: "idx_object_frame",
+					columns: ["frameId"]
+				}
+			]
 		});
 		await store.declareCollection.mutate({
 			collection: AUDIO_EVENTS_COLLECTION,
@@ -36192,6 +37386,10 @@ var TRACKS_COLUMNS = [
 		name: "hasFace",
 		type: "BOOLEAN"
 	},
+	{
+		name: "hasRider",
+		type: "BOOLEAN"
+	},
 	{
 		name: "envMinX",
 		type: "REAL"
@@ -36273,7 +37471,8 @@ function cloneTrack(t) {
 			markForTrain: t.retrainStatus === "staging"
 		} : {},
 		...t.debug !== void 0 ? { debug: t.debug } : {},
-		...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {}
+		...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
+		...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {}
 	};
 }
 var TrackStore = class {
@@ -36679,6 +37878,41 @@ var TrackStore = class {
 		}
 	}
 	/**
+	* Record that a rider was folded into THIS vehicle subject (D34).
+	*
+	* The twin of {@link markFaceDetected}, deliberately: same set-once
+	* semantics, same live-then-persisted branch, same best-effort failure. What
+	* it closes is a record gap — the fold deletes the person detection before the
+	* tracker, and until this method existed nothing durable said so, while both
+	* the ADR and the code comment claimed otherwise.
+	*
+	* Set-once and never cleared: the fold is a fact about a moment of the
+	* track's life, and a rider who dismounts later does not un-ride the frames
+	* where they were riding. (The dismount itself needs nothing here — the fold
+	* is per-FRAME, so the person simply stops overlapping and spawns its own
+	* track, which is D34's whole design.)
+	*/
+	async markRiderFolded(trackId) {
+		const active = this.active.get(trackId);
+		if (active) {
+			if (active.hasRider === true) return;
+			active.hasRider = true;
+			return;
+		}
+		try {
+			await this.store.update.mutate({
+				collection: TRACKS_COLLECTION,
+				id: trackId,
+				data: { hasRider: true }
+			});
+		} catch (err) {
+			this.logger.warn("markRiderFolded persist failed", { meta: {
+				trackId,
+				error: String(err)
+			} });
+		}
+	}
+	/**
 	* Write the retrain LIFECYCLE state directly — the move `setFlags` cannot
 	* express.
 	*
@@ -37364,6 +38598,7 @@ var TrackStore = class {
 				...t.retrainStatus !== void 0 ? { retrainStatus: t.retrainStatus } : {},
 				...t.debug !== void 0 ? { debug: t.debug } : {},
 				...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
+				...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
 				...envelope !== null && dims !== void 0 ? {
 					envMinX: envelope.minX,
 					envMinY: envelope.minY,
@@ -37399,6 +38634,8 @@ var TrackStore = class {
 		const retrainParsed = require_dist.RetrainStatusSchema.safeParse(data["retrainStatus"]);
 		const debug = data["debug"];
 		const hasFace = data["hasFace"];
+		/** Same read as `hasFace` — NULL / missing stays ABSENT, never `false`. */
+		const hasRider = data["hasRider"];
 		const envMinX = data["envMinX"];
 		const envMinY = data["envMinY"];
 		const envMaxX = data["envMaxX"];
@@ -37435,6 +38672,7 @@ var TrackStore = class {
 			} : {},
 			...typeof debug === "boolean" ? { debug } : {},
 			...typeof hasFace === "boolean" ? { hasFace } : {},
+			...typeof hasRider === "boolean" ? { hasRider } : {},
 			...envelope !== null ? { envelope } : {}
 		};
 	}
@@ -39427,6 +40665,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_dist.EventCategory.AgentOffline,
 	require_dist.EventCategory.WorkerOnline,
 	require_dist.EventCategory.WorkerOffline,
+	require_dist.EventCategory.PipelineNodeInferenceUnavailable,
+	require_dist.EventCategory.PipelineDetectionBlind,
 	require_dist.EventCategory.UpdateAvailable
 ];
 /**
@@ -44364,6 +45604,16 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	stationarySettingsCache = this.settingsCaches.registerDeviceCache("stationary", SETTINGS_CACHE_TTL_MS);
 	/** Turns stationary appear/depart into package-delivered/picked-up events. */
 	packageDropDetector = null;
+	/**
+	* The DEDICATED package promotion path. The generic stationary registry
+	* needs 4 positions inside 30s; `package-detection` is gated by the
+	* `MotionSettleGovernor` at one observation per 45s, so that criterion is
+	* arithmetically unreachable and `PackageDropDetector` never fired once in
+	* its life. This tracker re-associates a package box across governor rounds
+	* BY POSITION (the track dies between rounds) and feeds the detector the
+	* same appear/depart shape the registry does. Vehicles are untouched.
+	*/
+	packageStillness = new PackageStillnessTracker({ newId: () => (0, node_crypto.randomUUID)() });
 	/** Consecutive detector-dropout frames skipped per (deviceId, source) key. */
 	dropoutSkipsByKey = /* @__PURE__ */ new Map();
 	/** The per-track close-path orchestrator (S2, refactor spec 2026-07-22):
@@ -44749,6 +45999,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			listCallerTargetIds: async (userId) => {
 				return (await api.notificationOutput.listTargets.query({})).filter((t) => t.config["ownerUserId"] === userId).map((t) => t.id);
 			},
+			listTrackGroups: (query) => center.listTrackGroups(query),
 			injectTestEvent: (input) => center.injectTestEvent(input, { getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }) }),
 			timelapse: {
 				store: center.timelapseStore,
@@ -46103,6 +47354,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			this.trackStore?.clearDevice(data.deviceId);
 			this.residents.closeDevice(data.deviceId);
 			this.stationaryRegistry?.forgetDevice(data.deviceId);
+			this.packageStillness.forgetDevice(data.deviceId);
+			this.packageDropDetector?.forgetDevice(data.deviceId);
 			this.overlayState.clearDevice(data.deviceId);
 			this.overlaySynthesisWarnAt.delete(data.deviceId);
 			this.forgetDeviceProcessors(data.deviceId);
@@ -46116,6 +47369,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.trackStore?.clearDevice(deviceId);
 		this.residents.closeDevice(deviceId);
 		this.stationaryRegistry?.forgetDevice(deviceId);
+		this.packageStillness.forgetDevice(deviceId);
+		this.packageDropDetector?.forgetDevice(deviceId);
 		this.overlayState.clearDevice(deviceId);
 		this.overlaySynthesisWarnAt.delete(deviceId);
 		this.forgetDeviceProcessors(deviceId);
@@ -46403,7 +47658,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			return;
 		}
 		this.dropoutSkipsByKey.set(key, 0);
-		if (source === "pipeline" && this.stationaryRegistry) await this.resolveDeviceStationarySettings(deviceId);
+		if (source === "pipeline" && this.stationaryRegistry) {
+			await this.resolveDeviceStationarySettings(deviceId);
+			await this.resolveDevicePackageDropSettings(deviceId);
+		}
 		const processor = await this.getOrCreateProcessor(deviceId, source);
 		const proxy = await this.ensureProxy(deviceId);
 		const liveZones = await this.deviceZones.resolve(deviceId);
@@ -46415,15 +47673,6 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			timestamp: frame.timestamp,
 			frame
 		});
-		for (const r of processor.getLastRiderPairs()) this.ctx.logger.info("rider folded into vehicle", {
-			tags: { deviceId },
-			meta: {
-				vehicleClass: r.vehicleClass,
-				personScore: r.personScore,
-				vehicleScore: r.vehicleScore,
-				overlap: r.overlap
-			}
-		});
 		for (const r of processor.getLastLabelWriteRefusals()) {
 			const message = r.reason.kind === "macro-class" ? "label tier collapse refused" : "label write refused";
 			this.ctx.logger.info(message, {
@@ -46434,6 +47683,29 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				}
 			});
 		}
+		for (const fold of result.riderFolds) {
+			const meta = {
+				vehicleClass: fold.vehicleClass,
+				overlap: fold.overlap,
+				personScore: fold.personScore,
+				vehicleScore: fold.vehicleScore
+			};
+			if (fold.trackId === void 0) {
+				this.ctx.logger.info("rider folded but no surviving track emitted this frame", {
+					tags: { deviceId },
+					meta
+				});
+				continue;
+			}
+			this.ctx.logger.info("rider folded into its machine", {
+				tags: { deviceId },
+				meta: {
+					...meta,
+					trackId: fold.trackId
+				}
+			});
+			this.trackStore?.markRiderFolded(fold.trackId);
+		}
 		if (source === "pipeline") this.stationaryRegistry?.noteFrame(deviceId, result.timestamp);
 		if (this.stationaryRegistry && (result.stationaryConfirmed.length > 0 || result.stationaryWoken.length > 0)) this.stationaryRegistry.applyFrameOutcome({
 			deviceId,
@@ -46659,6 +47931,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.lastActiveTrackIds.set(key, currentTrackIds);
 		if (currentTrackIds.size > 0) this.lastTrackActivityMs.set(deviceId, Date.now());
 		const stationarySettings = this.stationarySettingsFromCache(deviceId);
+		const packageSettings = this.packageDropSettingsFromCache(deviceId);
+		const packageClasses = new Set(packageSettings.packageDropClassFilter);
 		if (source === "pipeline" && this.stationaryRegistry && stationarySettings.enabled) {
 			const dims = this.lastFrameDimsByDevice.get(deviceId);
 			if (dims && dims.w > 0 && dims.h > 0) {
@@ -46668,6 +47942,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					windowMs: stationarySettings.promotionWindowMs
 				};
 				for (const t of result.tracked) {
+					if (packageClasses.has(t.className)) continue;
 					const active = this.trackStore.peekActive(t.trackId);
 					if (!active) continue;
 					const { promote } = evaluateStationaryPromotion({
@@ -46691,6 +47966,15 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				}
 			}
 		}
+		if (source === "pipeline") this.runPackageStillness({
+			deviceId,
+			tracked: result.tracked,
+			packageClasses,
+			dwellSec: packageSettings.packageDropDwellSec,
+			frameWidth: result.frameWidth,
+			frameHeight: result.frameHeight,
+			timestamp: result.timestamp
+		});
 		if (this.detailDispatcher && detailSteps && detailSteps.length > 0) {
 			const dispatcher = this.detailDispatcher;
 			const steps = detailSteps;
@@ -47240,6 +48524,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	stationarySettingsFromCache(deviceId) {
 		return this.stationarySettingsCache.peek(deviceId) ?? STATIONARY_DEFAULTS;
 	}
+	/** Synchronous read of the per-device package-drop settings — warmed by
+	*  `processFrame` before the promotion loop, exactly like the stationary one. */
+	packageDropSettingsFromCache(deviceId) {
+		return this.packageDropSettingsCache.peek(deviceId) ?? PACKAGE_DROP_DEFAULTS;
+	}
 	async resolveDevicePackageDropSettings(deviceId) {
 		return this.packageDropSettingsCache.get(deviceId, (id) => this.readDeviceSettings(id, resolvePackageDropSettings));
 	}
@@ -48381,6 +49670,73 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* tracker + store forget the track so its detections stop re-spawning tracks,
 	* and the registry suppresses them from the next frame on.
 	*/
+	/**
+	* Feed this frame's package-class detections to the dedicated stillness
+	* tracker and bridge its transitions into `PackageDropDetector` — the SAME
+	* `onStationaryChange` contract the generic registry uses, so the detector
+	* has no idea there are two producers.
+	*
+	* Called on every pipeline frame with the (possibly empty) sighting list:
+	* an empty list is what advances the observed clock, and dropping the call
+	* on quiet frames would mean a parcel that was taken away is never reported
+	* as picked up.
+	*/
+	runPackageStillness(input) {
+		if (this.packageDropDetector === null) return;
+		const sightings = [];
+		for (const t of input.tracked) {
+			if (!input.packageClasses.has(t.className)) continue;
+			const keyFrameMediaKey = this.residents.keyFrameKey(t.trackId);
+			sightings.push({
+				className: t.className,
+				bbox: { ...t.bbox },
+				trackId: t.trackId,
+				confidence: t.confidence,
+				...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {}
+			});
+		}
+		const outcome = this.packageStillness.observe({
+			deviceId: input.deviceId,
+			sightings,
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight,
+			timestamp: input.timestamp,
+			minDwellMs: input.dwellSec * 1e3
+		});
+		for (const entry of outcome.promoted) {
+			this.ctx.logger.info("package promoted to stationary (dedicated path)", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					entryId: entry.id,
+					className: entry.className,
+					bbox: entry.bbox,
+					dwellMs: entry.becameStationaryAt - entry.firstSeenAt,
+					...entry.sourceTrackId !== void 0 ? { trackId: entry.sourceTrackId } : {},
+					...entry.confidence !== void 0 ? { confidence: entry.confidence } : {}
+				}
+			});
+			this.packageDropDetector.onStationaryChange({
+				phase: "appeared",
+				entry,
+				timestamp: entry.becameStationaryAt
+			});
+		}
+		for (const entry of outcome.departed) {
+			this.ctx.logger.info("package no longer observed (dedicated path)", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					entryId: entry.id,
+					className: entry.className,
+					unseenForMs: input.timestamp - entry.lastConfirmedAt
+				}
+			});
+			this.packageDropDetector.onStationaryChange({
+				phase: "departed",
+				entry,
+				timestamp: input.timestamp
+			});
+		}
+	}
 	promoteToStationary(input) {
 		const { deviceId, key, processor, track, firstSeen, label, frameWidth, frameHeight, timestamp } = input;
 		const keyFrameMediaKey = this.residents.keyFrameKey(track.trackId);