@camstack/addon-post-analysis 1.2.181 → 1.2.183

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-BB70nZUm.js");
+const require_dist = require("../dist-_fedHYU3.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -27835,6 +27835,7 @@ var StoragePressureTracker = class {
 var OWNER_KINDS = [
 	"event",
 	"track",
+	"summary",
 	"face",
 	"identity",
 	"plate",
@@ -28418,7 +28419,8 @@ var MediaStore = class {
 					relativePath: path
 				})).toString("base64"),
 				sizeBytes,
-				timestamp
+				timestamp,
+				deviceId: Number(data["deviceId"])
 			};
 		} catch {
 			return null;
@@ -30693,7 +30695,7 @@ async function mapWithConcurrency(items, limit, mapper) {
 * all-signals-maxed track scores exactly 1.0 (the clamp is then a no-op) and an
 * all-zero track scores 0.
 */
-var WEIGHT_CONFIDENCE = .3;
+var WEIGHT_CONFIDENCE$1 = .3;
 var WEIGHT_CLASS = .2;
 var WEIGHT_DWELL = .2;
 var WEIGHT_PROXIMITY = .12;
@@ -30731,7 +30733,7 @@ var ANIMAL_CLASSES = new Set([
 	"cat"
 ]);
 /** Clamp to [0,1]. */
-function clamp01$1(x) {
+function clamp01$2(x) {
 	if (Number.isNaN(x)) return 0;
 	if (x < 0) return 0;
 	if (x > 1) return 1;
@@ -30765,7 +30767,7 @@ function computeImportance(input) {
 	const terms = [
 		{
 			reason: "confidence",
-			value: WEIGHT_CONFIDENCE * clamp01$1(input.peakConfidence)
+			value: WEIGHT_CONFIDENCE$1 * clamp01$2(input.peakConfidence)
 		},
 		{
 			reason: "class",
@@ -30773,15 +30775,15 @@ function computeImportance(input) {
 		},
 		{
 			reason: "dwell",
-			value: WEIGHT_DWELL * clamp01$1(input.durationMs / DWELL_FULL_MS)
+			value: WEIGHT_DWELL * clamp01$2(input.durationMs / DWELL_FULL_MS)
 		},
 		{
 			reason: "proximity",
-			value: WEIGHT_PROXIMITY * clamp01$1(input.peakBboxAreaFrac / SIZE_FULL)
+			value: WEIGHT_PROXIMITY * clamp01$2(input.peakBboxAreaFrac / SIZE_FULL)
 		},
 		{
 			reason: "travel",
-			value: WEIGHT_TRAVEL * clamp01$1(input.totalDistance / 2)
+			value: WEIGHT_TRAVEL * clamp01$2(input.totalDistance / 2)
 		},
 		{
 			reason: "zone",
@@ -30800,11 +30802,11 @@ function computeImportance(input) {
 	}
 	const identified = input.identityLabel !== void 0 && input.identityLabel.length > 0;
 	if (input.netDisplacementFrac !== void 0 && input.pathSpanFrac !== void 0 && input.netDisplacementFrac < .02 && input.pathSpanFrac < .04 && !identified) return {
-		importance: clamp01$1(sum * STATIC_IMPORTANCE_MULTIPLIER),
+		importance: clamp01$2(sum * STATIC_IMPORTANCE_MULTIPLIER),
 		reason: best.reason
 	};
 	return {
-		importance: clamp01$1(sum),
+		importance: clamp01$2(sum),
 		reason: best.reason
 	};
 }
@@ -33504,7 +33506,7 @@ function isEdgeAwareNewBest(current, candidate, hysteresis) {
 * it, so it can be loose enough to see the near misses.
 */
 var CO_MOVING_MIN_CONTAINMENT = .6;
-function intersectionArea$3(a, b) {
+function intersectionArea$4(a, b) {
 	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
 }
 /**
@@ -33524,7 +33526,7 @@ function findCoMovingPairs(born, live, minContainment = CO_MOVING_MIN_CONTAINMEN
 			if (o.className === b.className) continue;
 			const areaO = o.bbox.w * o.bbox.h;
 			if (areaO <= 0) continue;
-			const inter = intersectionArea$3(b.bbox, o.bbox);
+			const inter = intersectionArea$4(b.bbox, o.bbox);
 			if (inter <= 0) continue;
 			const union = areaB + areaO - inter;
 			const containment = inter / Math.min(areaB, areaO);
@@ -33956,7 +33958,7 @@ function pairRiders(detections) {
 * diagonal = 2.085) with the same ~10% headroom the old 1.35 gave it.
 */
 var GROWTH_CENTROID_FACTOR = 2.3;
-function intersectionArea$2(a, b) {
+function intersectionArea$3(a, b) {
 	const x1 = Math.max(a.x, b.x);
 	const y1 = Math.max(a.y, b.y);
 	const x2 = Math.min(a.x + a.w, b.x + b.w);
@@ -33994,7 +33996,7 @@ function growthAdjacentMatch(track, det, ctx) {
 	const larger = Math.max(trackArea, detArea);
 	const smaller = Math.min(trackArea, detArea);
 	if (larger / smaller < 1.5) return false;
-	if (intersectionArea$2(track, det) / smaller >= .5) return false;
+	if (intersectionArea$3(track, det) / smaller >= .5) return false;
 	const tc = bboxCentroid(track);
 	const dc = bboxCentroid(det);
 	return Math.hypot(tc.x - dc.x, tc.y - dc.y) <= GROWTH_CENTROID_FACTOR * Math.hypot(track.w, track.h);
@@ -35980,6 +35982,7 @@ var EMPTY_CASCADE_TALLY = {
 	faces: 0,
 	plates: 0,
 	embeddings: 0,
+	summaries: 0,
 	bytesReclaimed: 0
 };
 /** Fold a leaf store's receipts into a running tally. */
@@ -36023,6 +36026,13 @@ function addLeafCounts(tally, counts) {
 					bytesReclaimed
 				};
 				break;
+			case "summaries":
+				next = {
+					...next,
+					summaries: next.summaries + c.rows,
+					bytesReclaimed
+				};
+				break;
 		}
 	}
 	return next;
@@ -36036,6 +36046,7 @@ function mergeCascadeTallies(a, b) {
 		faces: a.faces + b.faces,
 		plates: a.plates + b.plates,
 		embeddings: a.embeddings + b.embeddings,
+		summaries: a.summaries + b.summaries,
 		bytesReclaimed: a.bytesReclaimed + b.bytesReclaimed
 	};
 }
@@ -36098,6 +36109,7 @@ function absentCascadeLegs(stores) {
 	if (!stores.faceStore) absent.push("faces");
 	if (!stores.plateStore) absent.push("plates");
 	if (!stores.objectEmbeddingStore) absent.push("embeddings");
+	if (!stores.summaryStore) absent.push("summaries");
 	return absent;
 }
 function buildAnalyticsCascadeRegistry(stores) {
@@ -36105,6 +36117,7 @@ function buildAnalyticsCascadeRegistry(stores) {
 	if (stores.faceStore) registry.push(stores.faceStore);
 	if (stores.plateStore) registry.push(stores.plateStore);
 	if (stores.objectEmbeddingStore) registry.push(stores.objectEmbeddingStore);
+	if (stores.summaryStore) registry.push(stores.summaryStore);
 	return registry;
 }
 /**
@@ -46793,6 +46806,15 @@ var CACHE_CONTROL = "public, max-age=31536000, immutable";
 var THUMB_DEFAULT_SIZE = 160;
 var THUMB_MIN_SIZE = 64;
 var THUMB_MAX_SIZE = 320;
+/** Set by the HUB for a `csv_*` share token admitted on this plane; never by a client. */
+var SHARE_DEVICES_HEADER = "x-camstack-share-devices";
+/** The device ids a share scope allows, or `null` when the request carries no scope. */
+function shareScopeDevices(headers) {
+	const raw = headers[SHARE_DEVICES_HEADER];
+	const value = Array.isArray(raw) ? raw.join(",") : raw;
+	if (value === void 0) return null;
+	return new Set(value.split(",").map((part) => Number.parseInt(part.trim(), 10)).filter((id) => Number.isInteger(id) && id >= 0));
+}
 /**
 * Parse the `?kind=…` query into a preferred stored media kind. Returns null
 * when unset. The value is a free-form kind token (e.g. `crop`); the resolver
@@ -46865,6 +46887,14 @@ function createEventMediaHandler(deps) {
 			res.writeHead(404, { "server-timing": `resolve;dur=${(performance.now() - resolveStartedAt).toFixed(1)}` }).end();
 			return;
 		}
+		const scope = shareScopeDevices(req.headers);
+		if (scope !== null) {
+			const owner = media.deviceId ?? null;
+			if (owner === null || !scope.has(owner)) {
+				res.writeHead(403).end();
+				return;
+			}
+		}
 		const etag = "\"" + media.key + "\"";
 		const serverTiming = `resolve;dur=${(performance.now() - resolveStartedAt).toFixed(1)}`;
 		if (req.headers["if-none-match"] === etag) {
@@ -48335,7 +48365,7 @@ var RetrainAnnotationStore = class {
 };
 //#endregion
 //#region src/pipeline-analytics/retrain/retrain-geometry.ts
-function clamp01(v) {
+function clamp01$1(v) {
 	return v < 0 ? 0 : v > 1 ? 1 : v;
 }
 /** Is this a usable rectangle at all? A zero-area box is not a subject. */
@@ -48411,10 +48441,10 @@ function deriveZoneCropRect(bbox, zone) {
 function deriveSubjectCropRect(bbox, padding) {
 	if (!isUsableRect(bbox)) return null;
 	const pad = Number.isFinite(padding) && padding > 0 ? padding : 0;
-	const cropX = clamp01(bbox.x - bbox.w * pad);
-	const cropY = clamp01(bbox.y - bbox.h * pad);
-	const cropRight = clamp01(bbox.x + bbox.w * (1 + pad));
-	const cropBottom = clamp01(bbox.y + bbox.h * (1 + pad));
+	const cropX = clamp01$1(bbox.x - bbox.w * pad);
+	const cropY = clamp01$1(bbox.y - bbox.h * pad);
+	const cropRight = clamp01$1(bbox.x + bbox.w * (1 + pad));
+	const cropBottom = clamp01$1(bbox.y + bbox.h * (1 + pad));
 	const cropW = cropRight - cropX;
 	const cropH = cropBottom - cropY;
 	if (!(cropW > 0) || !(cropH > 0)) return null;
@@ -52665,7 +52695,7 @@ function isSceneSizedBox(bbox, frameWidth, frameHeight) {
 	const frame = frameWidth * frameHeight;
 	return frame > 0 && bbox.w * bbox.h / frame >= .55;
 }
-function intersectionArea$1(a, b) {
+function intersectionArea$2(a, b) {
 	const ix1 = Math.max(a.x, b.x);
 	const iy1 = Math.max(a.y, b.y);
 	const ix2 = Math.min(a.x + a.w, b.x + b.w);
@@ -52678,7 +52708,7 @@ function detectionSwallowsEntry(det, parked) {
 	const detArea = det.w * det.h;
 	if (entryArea <= 0 || detArea < entryArea * 1.35) return false;
 	if (!centroidInside(det, centroid(parked))) return false;
-	return intersectionArea$1(parked, det) / entryArea >= SWALLOW_MIN_COVERAGE;
+	return intersectionArea$2(parked, det) / entryArea >= SWALLOW_MIN_COVERAGE;
 }
 function parkedEntryHoldsDetection(entry, detBbox, config) {
 	const overlap = iou(entry.bbox, detBbox);
@@ -53510,7 +53540,7 @@ var VEHICLE_CLASSES = [
 	"vehicle"
 ];
 /** Area of the intersection of two boxes. `0` when they do not overlap. */
-function intersectionArea(a, b) {
+function intersectionArea$1(a, b) {
 	const left = Math.max(a.x, b.x);
 	const right = Math.min(a.x + a.w, b.x + b.w);
 	const top = Math.max(a.y, b.y);
@@ -53527,7 +53557,7 @@ function intersectionArea(a, b) {
 function containedFraction(person, vehicle) {
 	const area = person.w * person.h;
 	if (area <= 0) return 0;
-	return intersectionArea(person, vehicle) / area;
+	return intersectionArea$1(person, vehicle) / area;
 }
 /**
 * Is this person box contained in any vehicle box in the same frame?
@@ -56314,6 +56344,359 @@ async function reconcileGallerySamples(deps, options) {
 		stoppedByCeiling
 	};
 }
+//#endregion
+//#region src/pipeline-analytics/summary/summary-store.ts
+var SUMMARIES_COLLECTION = "pipeline-analytics:summaries";
+var SUMMARY_MEMBERS_COLLECTION = "pipeline-analytics:summary-members";
+var SUMMARIES_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "openedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "lastActiveAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "sealedAt",
+		type: "INTEGER"
+	},
+	(
+	/** `deviceId` while open, NULL once sealed — the unique "one open per camera". */
+	{
+		name: "openDeviceId",
+		type: "INTEGER"
+	}),
+	{
+		name: "memberCount",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var SUMMARIES_INDEXES = [{
+	name: "summaries_open_device",
+	columns: ["openDeviceId"],
+	unique: true
+}, {
+	name: "summaries_device_opened",
+	columns: ["deviceId", "openedAt"]
+}];
+var SUMMARY_MEMBERS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "summaryId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "trackId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** When the track joined — named `timestamp` so the orphan audit's declared-owner scope reads it. */
+	{
+		name: "timestamp",
+		type: "INTEGER",
+		notNull: true
+	})
+];
+var SUMMARY_MEMBERS_INDEXES = [{
+	name: "summary_members_summary",
+	columns: ["summaryId"]
+}, {
+	name: "summary_members_track",
+	columns: ["trackId"]
+}];
+function summaryId(deviceId, openedAt) {
+	return `sum-${deviceId}-${openedAt}`;
+}
+function memberRowId(summaryIdValue, trackId) {
+	return `${summaryIdValue}:${trackId}`;
+}
+function num$1(value, fallback = 0) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toRow$1(id, data) {
+	return {
+		id,
+		deviceId: num$1(data["deviceId"]),
+		openedAt: num$1(data["openedAt"]),
+		lastActiveAt: num$1(data["lastActiveAt"]),
+		sealedAt: typeof data["sealedAt"] === "number" ? data["sealedAt"] : null,
+		memberCount: num$1(data["memberCount"])
+	};
+}
+function isUniqueViolation(err) {
+	return err instanceof Error && /UNIQUE constraint failed/i.test(err.message);
+}
+var SummaryStore = class {
+	store;
+	logger;
+	onEvict;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.onEvict = deps.onEvict;
+	}
+	static async declare(store) {
+		await Promise.all([store.declareCollection.mutate({
+			collection: SUMMARIES_COLLECTION,
+			columns: [...SUMMARIES_COLUMNS],
+			indexes: [...SUMMARIES_INDEXES]
+		}), store.declareCollection.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			columns: [...SUMMARY_MEMBERS_COLUMNS],
+			indexes: [...SUMMARY_MEMBERS_INDEXES]
+		})]);
+	}
+	/** The camera's OPEN summary, from the row — `null` when none. */
+	async findOpen(deviceId) {
+		const first = (await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { openDeviceId: deviceId },
+				limit: 1
+			}
+		}))[0];
+		return first === void 0 ? null : toRow$1(first.id, first.data);
+	}
+	async listOpen() {
+		return (await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { sealedAt: null },
+				limit: 1e4
+			}
+		})).filter((r) => r.data["openDeviceId"] !== null).map((r) => toRow$1(r.id, r.data));
+	}
+	async membersOf(summaryIdValue) {
+		return (await this.store.query.query({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: {
+				where: { summaryId: summaryIdValue },
+				limit: 1e4
+			}
+		})).map((r) => ({
+			summaryId: summaryIdValue,
+			trackId: String(r.data["trackId"] ?? ""),
+			deviceId: num$1(r.data["deviceId"]),
+			joinedAt: num$1(r.data["timestamp"])
+		}));
+	}
+	/**
+	* Put a track into the camera's open summary, opening one when there is
+	* none. Racing opens are settled by the store: the loser's insert hits the
+	* unique `openDeviceId` and is re-read as an absorb.
+	*/
+	async openOrAbsorb(input) {
+		const existing = await this.findOpen(input.deviceId);
+		if (existing !== null) return this.absorb(existing, input);
+		const id = summaryId(input.deviceId, input.at);
+		try {
+			await this.store.set.mutate({
+				collection: SUMMARIES_COLLECTION,
+				key: id,
+				value: {
+					deviceId: input.deviceId,
+					openedAt: input.at,
+					lastActiveAt: input.at,
+					sealedAt: null,
+					openDeviceId: input.deviceId,
+					memberCount: 1
+				}
+			});
+		} catch (err) {
+			if (!isUniqueViolation(err)) throw err;
+			const winner = await this.findOpen(input.deviceId);
+			if (winner === null) throw err;
+			return this.absorb(winner, input);
+		}
+		await this.addMember(id, input);
+		return {
+			id,
+			deviceId: input.deviceId,
+			openedAt: input.at,
+			lastActiveAt: input.at,
+			sealedAt: null,
+			memberCount: 1
+		};
+	}
+	async absorb(summary, input) {
+		const members = await this.membersOf(summary.id);
+		if (members.some((m) => m.trackId === input.trackId)) return summary;
+		await this.addMember(summary.id, input);
+		const memberCount = members.length + 1;
+		const lastActiveAt = Math.max(summary.lastActiveAt, input.at);
+		await this.store.updateWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: { where: {
+				openDeviceId: summary.deviceId,
+				openedAt: summary.openedAt
+			} },
+			data: {
+				memberCount,
+				lastActiveAt
+			}
+		});
+		return {
+			...summary,
+			memberCount,
+			lastActiveAt
+		};
+	}
+	async addMember(summaryIdValue, input) {
+		await this.store.insertMany.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			records: [{
+				id: memberRowId(summaryIdValue, input.trackId),
+				data: {
+					summaryId: summaryIdValue,
+					trackId: input.trackId,
+					deviceId: input.deviceId,
+					timestamp: input.at
+				}
+			}]
+		});
+	}
+	/**
+	* Seal in place. `true` when THIS call sealed it; `false` when the row was
+	* already sealed (or gone) — the second sealer learns, it does not write.
+	*/
+	async seal(summary, sealedAt) {
+		const { updated } = await this.store.updateWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: { where: {
+				openDeviceId: summary.deviceId,
+				openedAt: summary.openedAt
+			} },
+			data: {
+				sealedAt,
+				openDeviceId: null
+			}
+		});
+		if (updated > 1) this.logger.error("summary seal touched more than one row — the open key is not unique", {
+			tags: { deviceId: summary.deviceId },
+			meta: {
+				summaryId: summary.id,
+				updated
+			}
+		});
+		return updated >= 1;
+	}
+	/**
+	* Track cascade leaf: a member row whose track is gone is gone too, and
+	* the summary's count follows. The envelope itself outlives its members
+	* — it is an age-keyed root (`RETENTION_ROOTS`, `summary`).
+	*/
+	async deleteByTracks(trackIds) {
+		if (trackIds.length === 0) return [{
+			family: "summaries",
+			rows: 0,
+			bytes: 0
+		}];
+		const members = await this.store.query.query({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: {
+				whereIn: { trackId: [...trackIds] },
+				limit: 1e4
+			}
+		});
+		if (members.length === 0) return [{
+			family: "summaries",
+			rows: 0,
+			bytes: 0
+		}];
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: { whereIn: { trackId: [...trackIds] } }
+		});
+		const touched = new Set(members.map((m) => String(m.data["summaryId"] ?? "")));
+		for (const summaryIdValue of touched) {
+			const remaining = await this.membersOf(summaryIdValue);
+			const raw = await this.store.get.query({
+				collection: SUMMARIES_COLLECTION,
+				key: summaryIdValue
+			});
+			if (typeof raw !== "object" || raw === null) continue;
+			const row = raw;
+			await this.store.updateWhere.mutate({
+				collection: SUMMARIES_COLLECTION,
+				filter: { where: {
+					deviceId: num$1(row["deviceId"]),
+					openedAt: num$1(row["openedAt"])
+				} },
+				data: { memberCount: remaining.length }
+			});
+		}
+		return [{
+			family: "summaries",
+			rows: deleted,
+			bytes: 0
+		}];
+	}
+	/** The subset of `ids` that still have a row — the orphan audit's probe. Throws on a failed read. */
+	async existingIds(ids) {
+		const found = /* @__PURE__ */ new Set();
+		await Promise.all(ids.map(async (id) => {
+			const raw = await this.store.get.query({
+				collection: SUMMARIES_COLLECTION,
+				key: id
+			});
+			if (typeof raw === "object" && raw !== null) found.add(id);
+		}));
+		return found;
+	}
+	/** Age sweep on the device window: everything opened before `cutoffMs`, members included. */
+	async evictBefore(deviceId, cutoffMs) {
+		const rows = await this.store.query.query({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { deviceId },
+				whereBetween: { openedAt: [0, cutoffMs - 1] },
+				limit: 1e4
+			}
+		});
+		if (rows.length === 0) return 0;
+		const ids = rows.map((r) => r.id);
+		await this.onEvict?.(ids);
+		await this.store.deleteWhere.mutate({
+			collection: SUMMARY_MEMBERS_COLLECTION,
+			filter: { whereIn: { summaryId: ids } }
+		});
+		const { deleted } = await this.store.deleteWhere.mutate({
+			collection: SUMMARIES_COLLECTION,
+			filter: {
+				where: { deviceId },
+				whereBetween: { openedAt: [0, cutoffMs - 1] }
+			}
+		});
+		return deleted;
+	}
+};
 /**
 * Where the completion marker lives.
 *
@@ -58609,6 +58992,10 @@ var ANALYTICS_COLLECTIONS = [
 		collection: PLATES_COLLECTION,
 		classification: derived(PLATE_COLUMNS)
 	},
+	{
+		collection: SUMMARY_MEMBERS_COLLECTION,
+		classification: derived(SUMMARY_MEMBERS_COLUMNS)
+	},
 	{
 		collection: MEDIA_COLLECTION,
 		classification: {
@@ -58652,6 +59039,13 @@ var ANALYTICS_COLLECTIONS = [
 			rootId: "ops-log"
 		}
 	},
+	{
+		collection: SUMMARIES_COLLECTION,
+		classification: {
+			kind: "retention-root",
+			rootId: "summary"
+		}
+	},
 	{
 		collection: IDENTITIES_COLLECTION,
 		classification: {
@@ -58811,6 +59205,10 @@ function resolveMediaOwner(row) {
 			kind: "event",
 			eventId: ownerId
 		};
+		case "summary": return {
+			kind: "summary",
+			summaryId: ownerId
+		};
 		case "face": return ownerId.startsWith("face-") ? {
 			kind: "track",
 			trackId: ownerId.slice(FACE_MEDIA_OWNER_PREFIX.length)
@@ -58897,11 +59295,14 @@ var DEFAULT_ORPHAN_LIMITS = {
 function questionsFor(refs) {
 	const trackIds = /* @__PURE__ */ new Set();
 	const eventIds = /* @__PURE__ */ new Set();
+	const summaryIds = /* @__PURE__ */ new Set();
 	for (const ref of refs) if (ref.kind === "track") trackIds.add(ref.trackId);
 	else if (ref.kind === "event") eventIds.add(ref.eventId);
+	else if (ref.kind === "summary") summaryIds.add(ref.summaryId);
 	return {
 		trackIds: [...trackIds],
-		eventIds: [...eventIds]
+		eventIds: [...eventIds],
+		summaryIds: [...summaryIds]
 	};
 }
 /**
@@ -58933,12 +59334,14 @@ async function auditScope(scope, deps, limits, cursor) {
 			break;
 		}
 		const refs = rows.map((row) => scope.resolve(row));
-		const { trackIds, eventIds } = questionsFor(refs);
+		const { trackIds, eventIds, summaryIds } = questionsFor(refs);
 		let liveTracks;
 		let liveEvents;
+		let liveSummaries;
 		try {
 			liveTracks = trackIds.length > 0 ? await deps.liveTrackIds(trackIds) : /* @__PURE__ */ new Set();
 			liveEvents = eventIds.length > 0 ? await deps.liveEventIds(eventIds) : /* @__PURE__ */ new Set();
+			liveSummaries = summaryIds.length > 0 ? await deps.liveSummaryIds(summaryIds) : /* @__PURE__ */ new Set();
 		} catch (err) {
 			deps.logger.warn("orphan audit: liveness probe failed — scope abandoned for this run", { meta: {
 				collection: scope.collection,
@@ -58962,7 +59365,7 @@ async function auditScope(scope, deps, limits, cursor) {
 				tally.unresolvable += 1;
 				continue;
 			}
-			if (ref.kind === "track" ? liveTracks.has(ref.trackId) : ref.kind === "event" ? liveEvents.has(ref.eventId) : false) continue;
+			if (ref.kind === "track" ? liveTracks.has(ref.trackId) : ref.kind === "event" ? liveEvents.has(ref.eventId) : ref.kind === "summary" ? liveSummaries.has(ref.summaryId) : false) continue;
 			const ts = num(row.data, scope.timestampField);
 			if (ts !== null && ts > graceFloor) {
 				tally.withinGrace += 1;
@@ -59212,12 +59615,14 @@ async function sweepTracklessRoots(deps) {
 				cutoffMs
 			});
 			const sensor = deps.evictSensorEvents ? await deps.evictSensorEvents(deviceId, cutoffMs) : 0;
+			const summaries = deps.evictSummaries ? await deps.evictSummaries(deviceId, cutoffMs) : 0;
 			const evicted = {
 				motion: events.motion,
 				audio: events.audio,
-				sensor
+				sensor,
+				summaries
 			};
-			if (evicted.motion.length + evicted.audio.length + evicted.sensor > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
+			if (evicted.motion.length + evicted.audio.length + evicted.sensor + evicted.summaries > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
 		} catch (err) {
 			deps.onError(deviceId, err);
 		}
@@ -64912,6 +65317,310 @@ function rowFromMetadata(id, metadata) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/summary/summary-score.ts
+/** A member whose own box is covered this much by others is hidden. */
+var OCCLUDED_COVER_FRACTION = .5;
+/** A box covering this share of the frame scores full marks on area. */
+var FULL_AREA_SHARE = .25;
+var WEIGHT_CONFIDENCE = .3;
+var WEIGHT_AREA = .25;
+var WEIGHT_RECOGNITION = .25;
+var WEIGHT_PLACEMENT = .2;
+function intersectionArea(a, b) {
+	const w = Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x);
+	const h = Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y);
+	return w > 0 && h > 0 ? w * h : 0;
+}
+/**
+* Share of `own` covered by `others`, 0..1. Pairwise intersections summed and
+* capped at the own area: when two others overlap each other on top of this
+* box the sum over-counts, which only ever calls a member MORE hidden, never
+* less — the safe side for a shot meant to show everyone.
+*/
+function coveredFraction(own, others) {
+	const area = own.width * own.height;
+	if (area <= 0) return 1;
+	const covered = others.reduce((sum, other) => sum + intersectionArea(own, other), 0);
+	return Math.min(1, covered / area);
+}
+function clamp01(value) {
+	return Math.max(0, Math.min(1, value));
+}
+function placement(box, frameWidth, frameHeight) {
+	const cx = box.x + box.width / 2;
+	const cy = box.y + box.height / 2;
+	const dx = cx - frameWidth / 2;
+	const dy = cy - frameHeight / 2;
+	const halfDiagonal = Math.hypot(frameWidth, frameHeight) / 2;
+	return halfDiagonal <= 0 ? 0 : 1 - clamp01(Math.hypot(dx, dy) / halfDiagonal);
+}
+function memberQuality(d, frameWidth, frameHeight) {
+	const frameArea = frameWidth * frameHeight;
+	const cappedArea = clamp01((frameArea <= 0 ? 0 : d.bbox.width * d.bbox.height / frameArea) / FULL_AREA_SHARE);
+	return WEIGHT_CONFIDENCE * clamp01(d.confidence) + WEIGHT_AREA * cappedArea + WEIGHT_RECOGNITION * (d.recognized ? 1 : 0) + WEIGHT_PLACEMENT * placement(d.bbox, frameWidth, frameHeight);
+}
+/** Score one frame for one summary. Pure; never throws on empty input. */
+function scoreSummaryFrame(input) {
+	const present = input.detections.filter((d) => input.members.has(d.trackId));
+	const visible = present.filter((d) => coveredFraction(d.bbox, present.filter((o) => o !== d).map((o) => o.bbox)) < OCCLUDED_COVER_FRACTION);
+	if (visible.length === 0) return {
+		visible: 0,
+		quality: 0
+	};
+	const quality = visible.reduce((sum, d) => sum + memberQuality(d, input.frameWidth, input.frameHeight), 0) / visible.length;
+	return {
+		visible: visible.length,
+		quality
+	};
+}
+/**
+* Lexicographic: more visible members wins outright; only equal counts fall
+* through to quality. Positive when `a` is the better shot.
+*/
+function compareSummaryScores(a, b) {
+	if (a.visible !== b.visible) return a.visible - b.visible;
+	return a.quality - b.quality;
+}
+/** A candidate replaces the best only when it is STRICTLY better — a tie keeps
+*  the pixels already materialised (they cost a native round trip). */
+function isBetterSummaryScore(candidate, best) {
+	if (candidate.visible === 0) return false;
+	return best === null || compareSummaryScores(candidate, best) > 0;
+}
+//#endregion
+//#region src/pipeline-analytics/summary/group-shot.ts
+/**
+* The running argmax of one open summary's group shot.
+*
+* RAM only, on purpose: it decides WHEN pixels are worth a native round trip
+* (only when the maximum improves — D9/D18), it is not the record of the
+* shot. The record is the media row the caller writes under the summary's
+* id; after a restart an open summary simply starts its argmax again and
+* replaces the row the next time it beats what it can remember, which is
+* nothing. That is a weaker shot for one session, never a wrong one.
+*/
+var GroupShotTracker = class {
+	best = /* @__PURE__ */ new Map();
+	/**
+	* Offer a frame. Returns `true` when it beats the summary's best so far —
+	* the caller's cue to materialise the pixels for THIS frame, now, while its
+	* handle is still leased.
+	*/
+	offer(summaryId, score, frame) {
+		if (!isBetterSummaryScore(score, (this.best.get(summaryId) ?? null)?.score ?? null)) return false;
+		this.best.set(summaryId, {
+			score,
+			frame
+		});
+		return true;
+	}
+	bestOf(summaryId) {
+		return this.best.get(summaryId) ?? null;
+	}
+	/** A sealed or evicted summary takes no more frames; drop its state. */
+	forget(summaryId) {
+		this.best.delete(summaryId);
+	}
+	get size() {
+		return this.best.size;
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/summary/group-shot-materialiser.ts
+async function persistSummaryGroupShot(deps, input) {
+	const { deviceId, summaryId, frameHandle } = input;
+	const drop = {
+		tags: { deviceId },
+		meta: {
+			summaryId,
+			nodeId: frameHandle.nodeId
+		}
+	};
+	try {
+		const result = await deps.fetchNativeFullFrame(frameHandle, input.maxWidth);
+		const native = result?.frame;
+		if (!native || native.format !== "rgb" || native.width <= 0 || native.height <= 0) {
+			deps.logger.warn("group shot native miss — the previous shot stands", {
+				...drop,
+				meta: {
+					...drop.meta,
+					shmId: frameHandle.shmId
+				}
+			});
+			return { kind: "native-miss" };
+		}
+		if (!keyFrameAcceptsTier(result.tier)) {
+			deps.logger.warn("group shot RAM tier rejected — the previous shot stands", {
+				...drop,
+				meta: {
+					...drop.meta,
+					shmId: frameHandle.shmId,
+					tier: result.tier
+				}
+			});
+			return { kind: "ram-tier" };
+		}
+		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(native);
+		const keyFrameKey = await deps.media.putReplacing({
+			deviceId,
+			ownerKind: "summary",
+			ownerId: summaryId,
+			kind: "keyFrame",
+			timestamp: input.timestamp,
+			data: keyFrame
+		});
+		try {
+			await deps.media.putReplacing({
+				deviceId,
+				ownerKind: "summary",
+				ownerId: summaryId,
+				kind: "keyFrameSmall",
+				timestamp: input.timestamp,
+				data: keyFrameSmall
+			});
+		} catch (err) {
+			deps.logger.warn("group shot web companion write failed — the native shot is stored", {
+				...drop,
+				meta: {
+					...drop.meta,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+		return {
+			kind: "landed",
+			keyFrameKey
+		};
+	} catch (err) {
+		const error = require_dist.errMsg(err);
+		deps.logger.warn("group shot capture failed", {
+			...drop,
+			meta: {
+				...drop.meta,
+				error
+			}
+		});
+		return {
+			kind: "error",
+			error
+		};
+	}
+}
+//#endregion
+//#region src/pipeline-analytics/summary/summary-sealer.ts
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+var SummarySealer = class {
+	deps;
+	sweepInFlight = false;
+	/**
+	* What the FRAME path may ask at frame-rate: the open summary of a camera
+	* and the members it has seen THIS process open. Fed only by this class's
+	* own writes, never the authority (D224): a fresh process answers `null`
+	* until a track opens, and a summary open across a restart is scored on the
+	* members that open after it — a weaker shot, never a wrong one.
+	*/
+	openMirror = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	openFor(deviceId) {
+		return this.openMirror.get(deviceId) ?? null;
+	}
+	async onTrackOpened(input) {
+		try {
+			const row = await this.deps.summaries.openOrAbsorb({
+				deviceId: input.deviceId,
+				trackId: input.trackId,
+				at: this.deps.now()
+			});
+			const mirror = this.openMirror.get(input.deviceId);
+			if (mirror !== void 0 && mirror.id === row.id) mirror.members.add(input.trackId);
+			else this.openMirror.set(input.deviceId, {
+				id: row.id,
+				members: new Set([input.trackId])
+			});
+		} catch (err) {
+			this.deps.logger.warn("summary: could not open or absorb for a track", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					trackId: input.trackId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+	/** One sweep at a time (THE latch). A tick that finds one in flight returns. */
+	async sweep() {
+		if (this.sweepInFlight) return;
+		this.sweepInFlight = true;
+		try {
+			const open = await this.deps.summaries.listOpen();
+			for (const summary of open) await this.sealIfDone(summary);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not list open summaries", { meta: { error: errMsg(err) } });
+		} finally {
+			this.sweepInFlight = false;
+		}
+	}
+	async sealIfDone(summary) {
+		const { id: summaryId, deviceId } = summary;
+		let openTracks;
+		try {
+			openTracks = await this.deps.openTrackIds(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not read open tracks — seal aborted this sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+			return;
+		}
+		if (openTracks.length > 0) return;
+		let quiet;
+		try {
+			quiet = await this.deps.isCameraQuiet(deviceId);
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: could not read the stationary registry — seal aborted this sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+			return;
+		}
+		if (!quiet) return;
+		const sealedAt = this.deps.now();
+		try {
+			if (await this.deps.summaries.seal(summary, sealedAt)) {
+				const mirror = this.openMirror.get(deviceId);
+				const members = mirror?.id === summaryId ? mirror.members : /* @__PURE__ */ new Set();
+				if (mirror?.id === summaryId) this.openMirror.delete(deviceId);
+				this.deps.onSealed?.(summaryId, members);
+				this.deps.logger.info("summary sealed", {
+					tags: { deviceId },
+					meta: {
+						summaryId,
+						sealedAt
+					}
+				});
+			}
+		} catch (err) {
+			this.deps.logger.warn("summary sweep: seal failed — the row stays open for the next sweep", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					error: errMsg(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
 //#region src/pipeline-analytics/store/settings-raw-mirror.ts
 /** How long a mirrored entry is served before a refresh is started behind the
 *  next reader. See the module doc for why this matches the per-kind caches'
@@ -66224,6 +66933,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
 	sensorEventStore = null;
+	/** The per-camera session envelope (D359). Bound with the other stores at boot. */
+	summaryStore = null;
+	/** The ONLY writer of a summary's lifecycle (D359). */
+	summarySealer = null;
+	/** The running argmax of every open summary's group shot (D359 phase 3). RAM only. */
+	groupShots = new GroupShotTracker();
+	/**
+	* Tracks a gallery match has named, for the group-shot score's recognition
+	* term. "Recognised so far" rather than "at that instant": the match arrives
+	* on the detail plane, after the frame; the frames that follow carry it.
+	* Pruned when the track's summary seals, so it is bounded by open summaries.
+	*/
+	recognizedTrackIds = /* @__PURE__ */ new Set();
 	/** Ingest-side reverse index (sensor device → linked camera ids), TTL-cached
 	*  so the DeviceStateChanged handler stays cheap. */
 	linkedCamerasCache = null;
@@ -67462,6 +68184,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			MediaStore.declare(api.settingsStore),
 			EventStore.declare(api.settingsStore),
 			SensorEventStore.declare(api.settingsStore),
+			SummaryStore.declare(api.settingsStore),
 			IdentityStore.declare(api.settingsStore),
 			FaceStore.declare(api.settingsStore),
 			PlateStore.declare(api.settingsStore),
@@ -67723,6 +68446,24 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			store: api.settingsStore,
 			logger: logger.child("SensorEventStore")
 		});
+		this.summaryStore = new SummaryStore({
+			store: api.settingsStore,
+			logger: this.ctx.logger.child("summary"),
+			onEvict: async (ids) => {
+				await this.mediaStore?.deleteForOwner("summary", ids);
+			}
+		});
+		this.summarySealer = new SummarySealer({
+			summaries: this.summaryStore,
+			openTrackIds: async (deviceId) => this.residents.trackIdsForDevice(deviceId),
+			isCameraQuiet: async (deviceId) => (this.stationaryRegistry?.count(deviceId) ?? 0) === 0,
+			now: () => Date.now(),
+			logger: this.ctx.logger.child("summary-sealer"),
+			onSealed: (summaryId, members) => {
+				this.groupShots.forget(summaryId);
+				for (const trackId of members) this.recognizedTrackIds.delete(trackId);
+			}
+		});
 		this.packageDropDetector = new PackageDropDetector({
 			events: eventStore,
 			emit: {
@@ -68570,6 +69311,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			this.eventMediaDataPlane = await this.ctx.dataPlane?.serve({
 				prefix: "event-media",
 				access: planeAccess("event-media"),
+				share: ["events-view"],
 				handler
 			}) ?? null;
 			this.eventMediaBaseUrl = this.eventMediaDataPlane !== null ? `/addon/${this.ctx.id}/event-media` : null;
@@ -69935,6 +70677,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					className: t.className
 				}
 			});
+			this.summarySealer?.onTrackOpened({
+				deviceId,
+				trackId: id
+			});
 			const startPayload = buildTrackLifecyclePayload({
 				deviceId,
 				trackId: id,
@@ -70152,6 +70898,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			for (const crops of childCropsByEvent.values()) for (const c of crops) if (c.kind === "faceCrop") faceCrops += 1;
 			else plateCrops += 1;
 			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings, result.frameWidth, result.frameHeight);
+			this.offerGroupShot(deviceId, result, frameHandle);
 			for (const retry of this.collectFirstFrameRetries(deviceId, result.tracked, result.timestamp, firstFrameTargets)) firstFrameTargets.push(retry);
 			const targetedThisFrame = new Set([...firstFrameTargets.map((t) => t.trackId), ...snapshotTargets.map((s) => s.trackId)]);
 			const rasterFallbackCandidates = [];
@@ -71034,6 +71781,63 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* is the scheduling (coalescing, priority, budget) and the bookkeeping the
 	* retry gate reads.
 	*/
+	/**
+	* Offer one processed frame to the camera's OPEN summary (D359 phase 3).
+	* Metadata only, at frame-rate: the frame is scored against the members the
+	* sealer has mirrored, and the pixels are fetched — by handle, at the owning
+	* node, as a native key frame — only when this frame beats the best so far.
+	*/
+	offerGroupShot(deviceId, result, frameHandle) {
+		const open = this.summarySealer?.openFor(deviceId);
+		if (!open || frameHandle === void 0) return;
+		const score = scoreSummaryFrame({
+			members: open.members,
+			frameWidth: result.frameWidth,
+			frameHeight: result.frameHeight,
+			detections: result.tracked.map((t) => ({
+				trackId: t.trackId,
+				bbox: {
+					x: t.bbox.x,
+					y: t.bbox.y,
+					width: t.bbox.w,
+					height: t.bbox.h
+				},
+				confidence: t.confidence,
+				recognized: this.recognizedTrackIds.has(t.trackId)
+			}))
+		});
+		if (!this.groupShots.offer(open.id, score, { timestamp: result.timestamp })) return;
+		const getNative = this.getNativeKeyFrameRgb;
+		const mediaStore = this.mediaStore;
+		if (!getNative || !mediaStore) return;
+		const summaryId = open.id;
+		this.captureScheduler.request({
+			deviceId,
+			kind: "keyFrame",
+			coalesceKey: `summary:${summaryId}:keyFrame`,
+			exec: () => persistSummaryGroupShot({
+				fetchNativeFullFrame: getNative,
+				encodeVariants: encodeKeyFrameVariants,
+				media: mediaStore,
+				logger: this.ctx.logger
+			}, {
+				deviceId,
+				summaryId,
+				timestamp: result.timestamp,
+				frameHandle,
+				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
+			})
+		}).then((outcome) => {
+			if (outcome?.kind === "landed") this.ctx.logger.debug("summary group shot landed", {
+				tags: { deviceId },
+				meta: {
+					summaryId,
+					visible: score.visible,
+					quality: Number(score.quality.toFixed(3))
+				}
+			});
+		}).catch(() => {});
+	}
 	async persistKeyFrames(deviceId, timestamp, captures, frameHandle) {
 		const getNative = this.getNativeKeyFrameRgb;
 		const mediaStore = this.mediaStore;
@@ -71178,6 +71982,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  FaceRecognizer's per-frame auto-match, and `routeDetailResults`' plate /
 	*  fine-classification attribution. */
 	promoteSemanticRecognition(input) {
+		this.recognizedTrackIds.add(input.trackId);
 		const ctx = this.ctxIfReady;
 		if (ctx === null) return;
 		promoteSemanticBestFrame({
@@ -71959,6 +72764,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
 		await this.trackCloser.sweep();
+		await this.summarySealer?.sweep();
 	}
 	/** Unified retention (Phase 1): earliest retained footage per device — the
 	*  follow-recordings cutoff source. Cached 10 min: availability answers in
@@ -72055,6 +72861,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			await this.runTrackRetentionSweep(deviceIds, now);
 			const eventStore = this.eventStore;
 			const sensorEventStore = this.sensorEventStore;
+			const summaryStore = this.summaryStore;
 			await sweepTracklessRoots({
 				deviceIds,
 				nowMs: now,
@@ -72064,15 +72871,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					cutoffMs
 				}),
 				evictSensorEvents: sensorEventStore ? (deviceId, cutoffMs) => sensorEventStore.evictBefore(deviceId, cutoffMs) : null,
+				evictSummaries: summaryStore ? (deviceId, cutoffMs) => summaryStore.evictBefore(deviceId, cutoffMs) : null,
 				onEvicted: async (deviceId, evicted, cutoffs) => {
-					const total = evicted.motion.length + evicted.audio.length + evicted.sensor;
+					const total = evicted.motion.length + evicted.audio.length + evicted.sensor + evicted.summaries;
 					await this.eventsOpsLog?.append({
 						op: "prune",
 						reason: "retention",
 						deviceId,
 						itemsAffected: total,
 						bytesReclaimed: 0,
-						detail: `trackless age sweep (${cutoffs.effectiveMode}): ${evicted.motion.length} motion, ${evicted.audio.length} audio, ${evicted.sensor} sensor`
+						detail: `trackless age sweep (${cutoffs.effectiveMode}): ${evicted.motion.length} motion, ${evicted.audio.length} audio, ${evicted.sensor} sensor, ${evicted.summaries} summaries`
 					});
 					this.ctx.logger.info("analytics trackless event eviction (age sweep)", {
 						tags: { deviceId },
@@ -72080,6 +72888,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 							motion: evicted.motion.length,
 							audio: evicted.audio.length,
 							sensor: evicted.sensor,
+							summaries: evicted.summaries,
 							mode: cutoffs.effectiveMode,
 							cutoffMs: cutoffs.cutoffMs
 						}
@@ -73412,6 +74221,11 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				},
 				liveTrackIds: (ids) => trackStore.existingTrackIds(ids),
 				liveEventIds: (ids) => eventStore.existingEventIds(ids),
+				liveSummaryIds: (ids) => {
+					const summaries = this.summaryStore;
+					if (!summaries) throw new Error("summary store not built — probe unavailable");
+					return summaries.existingIds(ids);
+				},
 				reclaim: async (collection, key) => {
 					if (collection === "pipeline-analytics:media") {
 						await mediaStore.deleteByKey(key);
@@ -74559,7 +75373,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			mediaStore,
 			faceStore: this.faceStore,
 			plateStore: this.plateStore,
-			objectEmbeddingStore: this.objectEmbeddingStore
+			objectEmbeddingStore: this.objectEmbeddingStore,
+			summaryStore: this.summaryStore
 		};
 		const absent = absentCascadeLegs(stores);
 		if (absent.length > 0) this.ctx.logger.warn("track cascade is missing a leg — its rows will be left behind", { meta: {
@@ -75045,7 +75860,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		if (!file) return null;
 		return {
 			bytes: Buffer.from(file.base64, "base64"),
-			key: file.key
+			key: file.key,
+			deviceId: file.deviceId
 		};
 	}
 	/**
@@ -75059,7 +75875,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		try {
 			return {
 				bytes: await makeSquareThumb(media.bytes, variant.size),
-				key: `${media.key}|t${variant.size}`
+				key: `${media.key}|t${variant.size}`,
+				deviceId: media.deviceId
 			};
 		} catch (err) {
 			this.ctx.logger.debug("event media: thumb variant failed — serving full", { meta: {
@@ -75089,7 +75906,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			const file = await (this.mediaStore?.getByKey(key) ?? Promise.resolve(null));
 			return file === null ? null : {
 				bytes: Buffer.from(file.base64, "base64"),
-				key: file.key
+				key: file.key,
+				deviceId: file.deviceId
 			};
 		};
 		const eventFiles = await listInfo("event", id);