@camstack/addon-post-analysis 1.2.182 → 1.2.183

package/dist/pipeline-analytics/index.js

@@ -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);
@@ -46804,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
@@ -46876,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) {
@@ -48346,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. */
@@ -48422,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;
@@ -52676,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);
@@ -52689,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);
@@ -53521,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);
@@ -53538,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?
@@ -56437,9 +56456,11 @@ function isUniqueViolation(err) {
 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({
@@ -56637,6 +56658,18 @@ var SummaryStore = class {
 			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({
@@ -56649,6 +56682,7 @@ var SummaryStore = class {
 		});
 		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 } }
@@ -59171,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)
@@ -59257,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]
 	};
 }
 /**
@@ -59293,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,
@@ -59322,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;
@@ -65274,6 +65317,196 @@ 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);
@@ -65281,16 +65514,33 @@ function errMsg(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 {
-			await this.deps.summaries.openOrAbsorb({
+			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 },
@@ -65346,13 +65596,19 @@ var SummarySealer = class {
 		if (!quiet) return;
 		const sealedAt = this.deps.now();
 		try {
-			if (await this.deps.summaries.seal(summary, sealedAt)) this.deps.logger.info("summary sealed", {
-				tags: { deviceId },
-				meta: {
-					summaryId,
-					sealedAt
-				}
-			});
+			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 },
@@ -66681,6 +66937,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	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;
@@ -68183,14 +68448,21 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		});
 		this.summaryStore = new SummaryStore({
 			store: api.settingsStore,
-			logger: this.ctx.logger.child("summary")
+			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")
+			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,
@@ -69039,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;
@@ -70625,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 = [];
@@ -71507,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;
@@ -71651,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({
@@ -73889,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);
@@ -75523,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
 		};
 	}
 	/**
@@ -75537,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: {
@@ -75567,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);