@camstack/addon-post-analysis 1.2.297 → 1.2.299

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-BTpYUJzK.js");
+const require_clip_model_registry = require("../clip-model-registry-hTbsQ-z7.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -12,6 +12,8 @@ let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
 let _camstack_system_addon_utils = require("@camstack/system/addon-utils");
 let node_stream_promises = require("node:stream/promises");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_clip_model_registry.__toESM(node_fs_promises, 1);
 let sharp = require("sharp");
 sharp = require_clip_model_registry.__toESM(sharp);
 let node_os = require("node:os");
@@ -2715,8 +2717,8 @@ var NC_ARTIFACTS_INDEXES = [
 	}
 ];
 /** Upper bound for a half-open `whereBetween` — the store has no `>=`. */
-var TIME_MAX$1 = 864e13;
-var TIME_MIN$1 = -864e13;
+var TIME_MAX = 864e13;
+var TIME_MIN = -864e13;
 /** Prune scan ceiling — the index is bounded by the shelf it mirrors (2000
 *  entries by default), so this only has to be comfortably above it. */
 var NC_ARTIFACT_PRUNE_SCAN_LIMIT = 2e4;
@@ -2956,7 +2958,7 @@ var NcArtifactIndex = class {
 		try {
 			const expired = await this.store.deleteWhere.mutate({
 				collection: NC_ARTIFACTS_COLLECTION,
-				filter: { whereBetween: { expiresAt: [TIME_MIN$1, this.now() - 1] } }
+				filter: { whereBetween: { expiresAt: [TIME_MIN, this.now() - 1] } }
 			});
 			removed += expired.deleted;
 			if (keptIds === null) {
@@ -2998,8 +3000,8 @@ var NcArtifactIndex = class {
 		whereIn["kind"] = query.kinds !== void 0 && query.kinds.length > 0 ? [...query.kinds] : [...NC_GALLERY_ARTIFACT_KINDS];
 		if (query.deviceIds !== void 0 && query.deviceIds.length > 0) whereIn["deviceId"] = [...query.deviceIds];
 		const whereBetween = {
-			capturedAt: [query.fromMs ?? TIME_MIN$1, query.toMs ?? TIME_MAX$1],
-			expiresAt: [this.now(), TIME_MAX$1]
+			capturedAt: [query.fromMs ?? TIME_MIN, query.toMs ?? TIME_MAX],
+			expiresAt: [this.now(), TIME_MAX]
 		};
 		return {
 			...query.ruleId !== void 0 ? { where: { ruleId: query.ruleId } } : {},
@@ -9980,14 +9982,25 @@ function occupancySubjectFromEdge(edge) {
 		threshold: edge.threshold
 	};
 }
-/** Build the subject for a `package-event` evaluation (a persisted `package`
-*  object-event; `phase` derives from the event `state` at the call site). */
+/**
+* Build the subject for a `package-event` evaluation (a persisted `package`
+* object-event; `phase` derives from the event `state` at the call site).
+*
+* `observedAt` (D682, D684): a pick-up row's `timestamp` is when the departure
+* was CONCLUDED — five minutes of unseen observed time after the parcel went —
+* so the detector STORES the instant it happened on the row, and the footage is
+* cut around that (`media-anchor.ts`). Read from the row HERE, the one place
+* every path builds a package subject (live hook, boot reconcile, dry-run), so
+* none of them can anchor differently. `timestamp` keeps its meaning; a row
+* written before D684 has none, which the anchor reads as unknown, out loud.
+*/
 function subjectFromPackageEvent(ev, phase) {
 	return {
 		kind: "package-event",
 		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		timestamp: ev.timestamp,
+		...ev.observedAt !== void 0 ? { observedAt: ev.observedAt } : {},
 		classNames: [ev.className],
 		...displayLabel(ev) !== void 0 ? { label: displayLabel(ev) } : {},
 		...recognitionPatch(ev.subLabelMeta),
@@ -10918,7 +10931,11 @@ function incomingFromAudioEvent(event, stillOwnerId) {
 		})
 	};
 }
-/** Package object-event persist (delivered / picked-up). */
+/**
+* Package object-event persist (delivered / picked-up) — the live hook and the
+* boot reconcile alike. A pick-up's instant is read from the row
+* (`event.observedAt`, D684) inside `subjectFromPackageEvent`.
+*/
 function incomingFromPackageEvent(event, phase) {
 	return {
 		subject: subjectFromPackageEvent(event, phase),
@@ -10928,7 +10945,8 @@ function incomingFromPackageEvent(event, phase) {
 			tags: { deviceId: event.deviceId },
 			meta: {
 				eventId: event.id,
-				phase
+				phase,
+				...event.observedAt !== void 0 ? { observedAt: event.observedAt } : {}
 			}
 		})
 	};
@@ -15441,21 +15459,6 @@ var NcSummaryRuleInputSchema = require_clip_model_registry.object({
 	deviceIds: DeviceIdsField,
 	window: NcSummaryWindowSchema,
 	filters: NcSummaryFiltersSchema.optional(),
-	/**
-	* What ONE line of this digest is: a subject, or a group of subjects that
-	* arrived together.
-	*
-	* `tracks` is what the digest has always done and stays the default — the
-	* operator's instruction when groups were added was that the first behaviour
-	* remains. `groups` collapses the members of each session summary to one
-	* entry, so a family walking in is one line and not four
-	* (`summary-group-collapse.ts`).
-	*
-	* `.default('tracks')` is safe here where `NcSummaryFiltersSchema` fields are
-	* not: this is a field of the RULE, not of the partial `filters` object that
-	* a patch materialises wholesale.
-	*/
-	subject: require_clip_model_registry._enum(["tracks", "groups"]).default("tracks"),
 	maxTiles: MaxTilesField.default(12),
 	maxAiImages: MaxAiImagesField.default(6),
 	rank: NcSummaryRankSchema.default("importance"),
@@ -15490,7 +15493,6 @@ var NcSummaryRulePatchSchema = require_clip_model_registry.object({
 	maxTiles: MaxTilesField.optional(),
 	maxAiImages: MaxAiImagesField.optional(),
 	rank: NcSummaryRankSchema.optional(),
-	subject: require_clip_model_registry._enum(["tracks", "groups"]).optional(),
 	barrierSeconds: BarrierSecondsField.optional(),
 	targets: TargetsField.optional(),
 	template: NcSummaryTemplateSchema.nullable().optional(),
@@ -19352,9 +19354,14 @@ function mediaAnchor(subject) {
 		lagMs: subject.timestamp - observedAt
 	};
 }
+function selfDatingKindOf(subject) {
+	if (subject.occupancy !== void 0) return "occupancy";
+	if (subject.packagePhase === "picked-up") return "package pick-up";
+	return null;
+}
 /**
 * True when this anchor is the conclusion instant AND the subject was one that
-* should have been able to date itself — today, an occupancy row.
+* should have been able to date itself — see {@link selfDatingKindOf}.
 *
 * Split from {@link mediaAnchor} because the anchor must stay pure of any
 * notion of subject KIND, while the log line that matters is exactly the one
@@ -20458,7 +20465,8 @@ var NcDispatcher = class {
 		};
 		const preRollSec = entry.payload.mediaClipPreRollSec ?? 4;
 		const anchor = mediaAnchor(entry.payload.subject);
-		if (anchorFellBack(anchor, entry.payload.subject.occupancy !== void 0)) this.deps.logger.warn("occupancy footage anchored on the conclusion — moment unknown", {
+		const selfDating = selfDatingKindOf(entry.payload.subject);
+		if (anchorFellBack(anchor, selfDating !== null)) this.deps.logger.warn(`${selfDating ?? "occupancy"} footage anchored on the conclusion — moment unknown`, {
 			tags: { deviceId: entry.payload.subject.deviceId },
 			meta: {
 				ruleId: entry.ruleId,
@@ -20486,7 +20494,7 @@ var NcDispatcher = class {
 					preRollSec,
 					retentionSec: this.ringRetentionSec(entry.payload.subject.deviceId),
 					wanted: [...wantGif ? ["gif"] : [], ...wantMp4 ? ["video"] : []],
-					next: this.deps.cutRecordedClip !== void 0 ? "recorded-clip-follow-up" : "no-clip"
+					next: this.recordedFollowUp(entry).kinds.length > 0 ? "recorded-clip-follow-up" : "no-clip"
 				}
 			});
 			return {
@@ -20540,6 +20548,13 @@ var NcDispatcher = class {
 	* alert for a complete one, which is precisely the wrong trade for the
 	* notification that tells an operator someone is at the door.
 	*
+	* A GIF rule is served here too (D682): a package pick-up is concluded five
+	* minutes after it happened, so a gif anchored on the pick-up is always
+	* outside the ring. The gif is derived from THIS cut's bytes
+	* (`deriveGifFromClip`) — one cut, never a second renderer — and a moment the
+	* recordings cannot serve ships NO gif, by named reason, rather than a gif of
+	* the wrong time.
+	*
 	* So the alert's latency is UNCHANGED, and **the clip is attached later**, as
 	* a follow-up send to the same target carrying the same `tag` — a phone
 	* collapses the two, so what the operator sees is the notification gaining
@@ -20562,7 +20577,9 @@ var NcDispatcher = class {
 	*/
 	startRecordedFootage(entry, target, notification) {
 		const cut = this.deps.cutRecordedClip;
-		if (cut === void 0 || entry.payload.mediaClip !== true) return;
+		const plan = this.recordedFollowUp(entry);
+		const wanted = plan.kinds;
+		if (cut === void 0 || wanted.length === 0 && plan.gifRefused === void 0 && plan.videoRefused === void 0) return;
 		const preRollSec = entry.payload.mediaClipPreRollSec ?? 4;
 		const anchor = mediaAnchor(entry.payload.subject);
 		if (footageSourceFor({
@@ -20572,34 +20589,70 @@ var NcDispatcher = class {
 			ringRetentionSec: this.ringRetentionSec(entry.payload.subject.deviceId)
 		}) !== "recordings") return;
 		const deviceId = entry.payload.subject.deviceId;
+		if (plan.gifRefused !== void 0) this.deps.logger.info("recorded gif follow-up: none — the gif is not cut from the recordings", {
+			tags: { deviceId },
+			meta: {
+				ruleId: entry.ruleId,
+				eventId: entry.recordId,
+				targetId: target.id,
+				reason: plan.gifRefused,
+				anchoredOn: anchor.source,
+				...anchor.fallback !== void 0 ? { anchorFallback: anchor.fallback } : {},
+				next: wanted
+			}
+		});
+		if (plan.videoRefused !== void 0) this.deps.logger.info("recorded video follow-up: none — the video is not cut from the recordings", {
+			tags: { deviceId },
+			meta: {
+				ruleId: entry.ruleId,
+				eventId: entry.recordId,
+				targetId: target.id,
+				reason: plan.videoRefused,
+				anchoredOn: anchor.source,
+				...anchor.fallback !== void 0 ? { anchorFallback: anchor.fallback } : {},
+				next: wanted
+			}
+		});
+		if (wanted.length === 0) return;
+		const videoSpeed = entry.payload.mediaClipSpeed;
 		const pending = (async () => {
 			const result = await cut({
 				deviceId,
 				aroundMs: anchor.atMs,
 				preRollSec,
 				postRollSec: entry.payload.mediaClipPostRollSec ?? 6,
-				...entry.payload.mediaClipSpeed !== void 0 ? { speed: entry.payload.mediaClipSpeed } : {},
+				...videoSpeed !== void 0 ? { speed: videoSpeed } : {},
 				ruleId: entry.ruleId,
 				recordId: entry.recordId
 			});
 			if (!result.ok) {
-				this.deps.logger.info("recorded clip follow-up: none — this delivery keeps no clip", {
+				this.deps.logger.info("recorded footage follow-up: none — the recorded cut failed", {
 					tags: { deviceId },
 					meta: {
 						ruleId: entry.ruleId,
 						eventId: entry.recordId,
 						targetId: target.id,
-						reason: result.reason
+						reason: result.reason,
+						wanted
 					}
 				});
 				return;
 			}
-			const withUrls = await this.withArtifactUrls(entry, [{
-				mediaType: "video",
-				bytes: result.mp4,
-				mime: "video/mp4",
-				name: "event.mp4"
-			}]);
+			const attachments = await this.recordedAttachments(entry, wanted, result.mp4);
+			if (attachments.length === 0) {
+				this.deps.logger.info("recorded clip follow-up: none — the gif could not be derived", {
+					tags: { deviceId },
+					meta: {
+						ruleId: entry.ruleId,
+						eventId: entry.recordId,
+						targetId: target.id,
+						reason: "gif-derive-failed",
+						wanted
+					}
+				});
+				return;
+			}
+			const withUrls = await this.withArtifactUrls(entry, attachments);
 			const sent = await this.deps.send({
 				addonId: target.addonId,
 				targetId: target.id,
@@ -20628,6 +20681,8 @@ var NcDispatcher = class {
 					target: target.name,
 					profile: result.profile,
 					bytes: result.mp4.byteLength,
+					attachments: attachments.map((a) => a.mediaType),
+					anchoredOn: anchor.source,
 					lagMs: this.now() - entry.updatedAt
 				}
 			});
@@ -20647,6 +20702,84 @@ var NcDispatcher = class {
 		});
 	}
 	/**
+	* What a recorded follow-up for this row would CARRY — the one answer both
+	* the refusal line (`next`) and the follow-up read, so the log cannot promise
+	* a follow-up the dispatcher will not send.
+	*
+	* A video when the rule asked for one. A gif only for a package PICK-UP
+	* whose moment is KNOWN (D682): the gif is derived from the recorded cut's
+	* own bytes, the same way the broker derives it from a ring cut — one cut,
+	* two containers, never a second renderer.
+	*
+	* Narrow on purpose. A pick-up is the one kind whose moment is ALWAYS outside
+	* the ring; every other kind keeps the gif behaviour it had (the ring's, or
+	* none) rather than silently gaining a recorder export per notification. And
+	* a pick-up that fell back to its conclusion gets no recorded footage at all,
+	* gif OR video — cutting the recordings there is exactly the doormat D682
+	* removed (see {@link NcRecordedGifRefusal}, {@link NcRecordedVideoRefusal}).
+	*/
+	recordedFollowUp(entry) {
+		if (this.deps.cutRecordedClip === void 0) return { kinds: [] };
+		const gifRefused = this.recordedGifRefusal(entry);
+		const videoRefused = this.recordedVideoRefusal(entry);
+		const kinds = [];
+		if (entry.payload.mediaGif === true && gifRefused === void 0) kinds.push("gif");
+		if (entry.payload.mediaClip === true && videoRefused === void 0) kinds.push("video");
+		return {
+			kinds,
+			...gifRefused !== void 0 ? { gifRefused } : {},
+			...videoRefused !== void 0 ? { videoRefused } : {}
+		};
+	}
+	/** Why this row's video is not cut from the recordings, or `undefined` when
+	*  it is (or when the rule asked for no video). */
+	recordedVideoRefusal(entry) {
+		if (entry.payload.mediaClip !== true) return void 0;
+		const subject = entry.payload.subject;
+		if (selfDatingKindOf(subject) !== "package pick-up") return void 0;
+		if (anchorFellBack(mediaAnchor(subject), true)) return "moment-unknown";
+	}
+	/** Why this row's gif is not cut from the recordings, or `undefined` when it
+	*  is (or when the rule asked for no gif). */
+	recordedGifRefusal(entry) {
+		if (entry.payload.mediaGif !== true) return void 0;
+		if (this.deps.deriveGifFromClip === void 0) return "no-derive";
+		const subject = entry.payload.subject;
+		if (selfDatingKindOf(subject) !== "package pick-up") return "not-a-pick-up";
+		if (anchorFellBack(mediaAnchor(subject), true)) return "moment-unknown";
+	}
+	/**
+	* The follow-up's attachments, gif first and video second — the order the
+	* ring path ships them in. A gif that could not be derived is left out (its
+	* reason already logged); the video, when asked for, still ships.
+	*/
+	async recordedAttachments(entry, wanted, mp4) {
+		const out = [];
+		const derive = this.deps.deriveGifFromClip;
+		if (wanted.includes("gif") && derive !== void 0) {
+			const gif = await derive({
+				deviceId: entry.payload.subject.deviceId,
+				mp4,
+				...entry.payload.mediaClipSpeed !== void 0 ? { videoSpeed: entry.payload.mediaClipSpeed } : {},
+				ruleId: entry.ruleId,
+				recordId: entry.recordId
+			});
+			if (gif.ok) out.push({
+				mediaType: "gif",
+				bytes: gif.gif,
+				mime: "image/gif",
+				name: "event.gif"
+			});
+		}
+		if (wanted.includes("video")) out.push({
+			mediaType: "video",
+			bytes: mp4,
+			mime: "video/mp4",
+			name: "event.mp4"
+		});
+		return out;
+	}
+	/**
 	* Settle every recorded-clip follow-up this dispatcher has in flight.
 	*
 	* A TEST SEAM, and the honest kind: the follow-up is detached by design, so
@@ -26299,52 +26432,6 @@ function buildSummaryOutboxInputs(input) {
 	});
 }
 //#endregion
-//#region src/notification-center/summary/summary-group-collapse.ts
-function collapseToGroups(candidates, groups) {
-	const claim = /* @__PURE__ */ new Map();
-	for (const group of groups) for (const trackId of group.memberTrackIds) if (!claim.has(trackId)) claim.set(trackId, group);
-	const survivorsByGroup = /* @__PURE__ */ new Map();
-	for (const candidate of candidates) {
-		const group = claim.get(candidate.trackId);
-		if (group === void 0) continue;
-		const bucket = survivorsByGroup.get(group.summaryId);
-		if (bucket === void 0) survivorsByGroup.set(group.summaryId, [candidate]);
-		else bucket.push(candidate);
-	}
-	const representative = /* @__PURE__ */ new Map();
-	for (const [summaryId, survivors] of survivorsByGroup) {
-		const group = groups.find((g) => g.summaryId === summaryId);
-		if (group === void 0) continue;
-		const chosen = survivors.find((c) => c.trackId === group.primaryTrackId) ?? survivors[0];
-		if (chosen === void 0) continue;
-		representative.set(summaryId, {
-			...chosen,
-			groupSize: survivors.length,
-			...group.groupShotMediaId !== null ? { groupShotMediaId: group.groupShotMediaId } : {}
-		});
-	}
-	const kept = [];
-	let collapsed = 0;
-	for (const candidate of candidates) {
-		const group = claim.get(candidate.trackId);
-		if (group === void 0) {
-			kept.push(candidate);
-			continue;
-		}
-		const chosen = representative.get(group.summaryId);
-		if (chosen === void 0) {
-			kept.push(candidate);
-			continue;
-		}
-		if (chosen.trackId === candidate.trackId) kept.push(chosen);
-		else collapsed += 1;
-	}
-	return {
-		kept,
-		collapsed
-	};
-}
-//#endregion
 //#region src/notification-center/summary/summary-selection.ts
 /**
 * Which tracks become tiles — filter, rank, and the per-camera quota.
@@ -26938,8 +27025,7 @@ var NcSummaryProducer = class {
 		try {
 			const candidates = await this.collectCandidates(rule, window);
 			const filtered = filterSummaryCandidates(candidates, rule.filters, this.deps.zoneOwner);
-			const grouped = await this.collapseIfGrouping(rule, window, filtered.kept);
-			const selection = selectSummaryTiles(grouped.kept, {
+			const selection = selectSummaryTiles(filtered.kept, {
 				maxTiles: rule.maxTiles,
 				rank: rule.rank
 			});
@@ -26968,7 +27054,7 @@ var NcSummaryProducer = class {
 			const tileLoad = await this.loadTiles({
 				rule,
 				preferred: selection.tiles,
-				refill: remainingSummaryCandidates(grouped.kept, selection.tiles, rule.rank),
+				refill: remainingSummaryCandidates(filtered.kept, selection.tiles, rule.rank),
 				maxTiles: rule.maxTiles
 			});
 			const loaded = tileLoad.tiles;
@@ -27009,7 +27095,7 @@ var NcSummaryProducer = class {
 				priority: rule.priority,
 				tileCount: loaded.length,
 				cameraCount: new Set(loaded.map((t) => t.candidate.deviceId)).size,
-				matchedCount: grouped.kept.length,
+				matchedCount: filtered.kept.length,
 				detections,
 				...mosaic.ref !== null ? { mosaic: mosaic.ref } : {},
 				generatedAt: this.deps.now(),
@@ -27021,7 +27107,7 @@ var NcSummaryProducer = class {
 			this.deps.logger.info("summary produced", { meta: {
 				...meta,
 				scanned: candidates.length,
-				matched: grouped.kept.length,
+				matched: filtered.kept.length,
 				droppedStationary: filtered.droppedStationary,
 				droppedUnconfirmed: filtered.droppedUnconfirmed,
 				unknownConfirmation: filtered.unknownConfirmation,
@@ -27044,7 +27130,7 @@ var NcSummaryProducer = class {
 				window,
 				tiles: loaded.length,
 				cameras: new Set(loaded.map((t) => t.candidate.deviceId)).size,
-				matched: grouped.kept.length,
+				matched: filtered.kept.length,
 				droppedStationary: filtered.droppedStationary,
 				enqueued,
 				...mosaic.bytes > 0 ? { mosaicBytes: mosaic.bytes } : {},
@@ -27065,54 +27151,6 @@ var NcSummaryProducer = class {
 			};
 		}
 	}
-	/**
-	* Fold each session summary's surviving members into one entry — or do
-	* nothing at all, which is what `tracks` (the default) means.
-	*
-	* A failure to read the groups does NOT fail the digest: it falls back to
-	* subjects and says so. A digest of four lines instead of one is a worse
-	* reading, not a lost one, and losing the night's record over a store read
-	* is the wrong trade.
-	*/
-	async collapseIfGrouping(rule, window, kept) {
-		if (rule.subject !== "groups") return {
-			kept,
-			collapsed: 0
-		};
-		const listGroups = this.deps.listSummaryGroups;
-		if (listGroups === void 0) {
-			this.deps.logger.warn("summary rule asks for groups but this node cannot read them", { meta: { ruleId: rule.id } });
-			return {
-				kept,
-				collapsed: 0
-			};
-		}
-		const groups = [];
-		for (const deviceId of rule.deviceIds) try {
-			groups.push(...await listGroups({
-				deviceId,
-				sinceMs: window.startMs,
-				untilMs: window.endMs
-			}));
-		} catch (err) {
-			this.deps.logger.warn("summary could not read a camera’s groups — read as subjects", {
-				tags: { deviceId },
-				meta: {
-					ruleId: rule.id,
-					error: String(err)
-				}
-			});
-		}
-		const outcome = collapseToGroups(kept, groups);
-		this.deps.logger.info("summary read as groups", { meta: {
-			ruleId: rule.id,
-			groups: groups.length,
-			subjects: kept.length,
-			lines: outcome.kept.length,
-			collapsed: outcome.collapsed
-		} });
-		return outcome;
-	}
 	/** Every camera's tracks in the window, capped per camera and counted. */
 	async collectCandidates(rule, window) {
 		const all = [];
@@ -27163,25 +27201,6 @@ var NcSummaryProducer = class {
 			seenIds.add(candidate.trackId);
 			const tags = { deviceId: candidate.deviceId };
 			try {
-				const groupShot = candidate.groupShotMediaId;
-				if (groupShot !== void 0) {
-					const jpeg = await this.deps.readMedia(groupShot);
-					if (jpeg !== null && jpeg.byteLength > 0) {
-						tiles.push({
-							candidate,
-							jpeg
-						});
-						continue;
-					}
-					this.deps.logger.info("summary tile: group shot unreadable — using a member", {
-						tags,
-						meta: {
-							ruleId: input.rule.id,
-							trackId: candidate.trackId,
-							mediaId: groupShot
-						}
-					});
-				}
 				const rows = await this.deps.listMediaInfo(candidate.trackId);
 				const picked = pickSummaryMedia(rows, (candidate.firstSeen + candidate.lastSeen) / 2);
 				if (picked === null) {
@@ -32688,6 +32707,9 @@ var NotificationCenter = class NotificationCenter {
 	* delivered/picked-up), in the SAME moment as the durable insert. Feeds the
 	* `package-event` trigger. Package events ARE object-event rows, so the boot
 	* crash-gap reconcile re-covers them (routed by className in {@link reconcile}).
+	*
+	* When a pick-up HAPPENED is on the row (`event.observedAt`, D684), so this
+	* hook and the reconcile read it from the same place.
 	*/
 	onPackageEventPersisted(event, phase) {
 		this.consumeEvent(incomingFromPackageEvent(event, phase));
@@ -35457,7 +35479,6 @@ var StoragePressureTracker = class {
 */
 var OWNER_KINDS = [
 	"track",
-	"summary",
 	"face",
 	"identity",
 	"plate",
@@ -35519,10 +35540,19 @@ function isWriterBoundedOwnerKind(value) {
 * `{ kind: 'retired-owner' }` and the orphan audit reclaims it under the same
 * grace window and ceilings as any other orphan.
 *
+* `'summary'` is the same case one entity later: the session summary (the
+* proximity group, D489/D490) was deleted on 2026-09-29 (D680) with
+* `pipeline-analytics:summaries` / `:summary-members`. Its group shots were
+* `summary`-owned media rows; they are reclaimed the same way.
+*
 * Deliberately NOT a member of {@link OWNER_KINDS}: the type is what stops a
 * new writer, and this list is only what the READ side must still recognise.
 */
-var RETIRED_OWNER_KINDS = ["group", "event"];
+var RETIRED_OWNER_KINDS = [
+	"group",
+	"summary",
+	"event"
+];
 /** Is this an owner kind whose owning code is gone? See {@link RETIRED_OWNER_KINDS}. */
 function isRetiredMediaOwnerKind(value) {
 	return RETIRED_OWNER_KINDS.includes(value);
@@ -42892,6 +42922,33 @@ var FaceSourceStats = class {
 };
 //#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-capture.ts
+/**
+* Pure helpers for the per-track NATIVE-resolution `keyFrame` capture
+* (Design B — one native full-frame per track at its best-detection moment).
+*
+* ## Why this exists (the missing native keyFrame)
+*
+* `keyFrame` was historically captured ONLY inside the CLIP object-embedding
+* best path (`persistObjectEmbeddingBests`, gated by `isClipObjectEmbedding`).
+* Under the two-plane pipeline the root frame carries NO CLIP embedding (clip is
+* a per-track DETAIL served via `runDetailSubtree`, and is disabled cluster-
+* wide), so that gate was never satisfied and the native `keyFrame` was NEVER
+* produced — every stored frame stayed at the ≤640×360 detection resolution.
+*
+* The fix decouples the `keyFrame` from the clip path: it is selected on the
+* GENERAL best-frame signal (the same `bestThumbnail` decision that drives the
+* `thumbnail`) by {@link selectKeyFrameCaptures}.
+*
+* ## How the pixels arrive, since D422
+*
+* Not by handle. At the best instant the owning node PARKS the whole frame at
+* {@link KEYFRAME_NATIVE_MAX_WIDTH} (`track-park.ts` orders it; the runner
+* refuses a ≤640 `ram-fullframe` answer at park time), and `persistKeyFrames`
+* stores that parcel verbatim as `keyFrame` (`key-frame-persist.ts`). The web
+* companion is {@link deriveKeyFrameSmall} of the same bytes — never a second
+* fetch. A retrieval keyed by a track never falls back to a handle
+* (`scripts/check-parked-frame-no-handle-fallback.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
 *  resize, 3840 ≤ 4096); an 8K cam is bounded to 4096 (still far past the retired
@@ -42917,47 +42974,10 @@ function selectKeyFrameCaptures(targets) {
 	return selected;
 }
 /**
-* Gate for the clean best-shot native `keyFrame` (design 2026-07-21): the keyFrame
-* is the track's CLEAN native best frame and MUST NEVER be persisted from the
-* ≤640 RAM fallback (`tier: 'ram-fullframe'`) — that would pin the stored keyFrame
-* at detection resolution. On a `ram-fullframe` tier the caller drops the write
-* and the per-frame re-fire retries a real native surface later.
-*
-* An ABSENT tier (`undefined`, from a pre-tier runner on a mixed-version cluster)
-* is ACCEPTED exactly as before the tier field existed — back-compat, never break
-* mixed-version clusters. Only an explicit `ram-fullframe` is rejected.
-*
-* NOTE: this gates the native `keyFrame` ONLY. The 960 boxed TIMELINE tiles keep
-* accepting the ≤640 fallback (an honest low-res timeline is acceptable there).
-*/
-function keyFrameAcceptsTier(tier) {
-	return tier !== "ram-fullframe";
-}
-/**
-* Encode BOTH key-frame variants from a single decoded native full frame. No box
-* is drawn (the `keyFrame` is the clean best full frame); `drawBoxedFrame([])`
-* is used purely as the raw-rgb → JPEG (+ optional downscale) encoder so the two
-* variants share one code path. The caller has ALREADY fetched the native frame
-* at {@link KEYFRAME_NATIVE_MAX_WIDTH}, so `keyFrame` re-encodes it verbatim
-* (no resize) and `keyFrameSmall` downscales the same buffer to ≤960 —
-* `withoutEnlargement` never upscales a sub-960 native frame.
-*/
-async function encodeKeyFrameVariants(native) {
-	return {
-		keyFrame: await drawBoxedFrame(native.data, native.width, native.height, [], { quality: 88 }),
-		keyFrameSmall: await drawBoxedFrame(native.data, native.width, native.height, [], {
-			quality: 88,
-			maxWidth: 960
-		})
-	};
-}
-/**
 * The web companion from the PARKED key frame's own JPEG (D422): the parcel is
 * stored verbatim as `keyFrame`, and `keyFrameSmall` is this — the same bytes
 * downscaled to {@link KEYFRAME_SMALL_MAX_WIDTH}. One decode, one encode,
 * never a second fetch; `withoutEnlargement` never upscales a sub-960 frame.
-* The by-handle twin ({@link encodeKeyFrameVariants}) remains for the
-* summary group shot, which still fetches a native surface by handle.
 */
 async function deriveKeyFrameSmall(keyFrameJpeg) {
 	return (0, sharp.default)(keyFrameJpeg).resize(960, null, { withoutEnlargement: true }).jpeg({ quality: 88 }).toBuffer();
@@ -43180,7 +43200,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$1 = .3;
+var WEIGHT_CONFIDENCE = .3;
 var WEIGHT_CLASS = .2;
 var WEIGHT_DWELL = .2;
 var WEIGHT_PROXIMITY = .12;
@@ -43218,7 +43238,7 @@ var ANIMAL_CLASSES = new Set([
 	"cat"
 ]);
 /** Clamp to [0,1]. */
-function clamp01$2(x) {
+function clamp01$1(x) {
 	if (Number.isNaN(x)) return 0;
 	if (x < 0) return 0;
 	if (x > 1) return 1;
@@ -43252,7 +43272,7 @@ function computeImportance(input) {
 	const terms = [
 		{
 			reason: "confidence",
-			value: WEIGHT_CONFIDENCE$1 * clamp01$2(input.peakConfidence)
+			value: WEIGHT_CONFIDENCE * clamp01$1(input.peakConfidence)
 		},
 		{
 			reason: "class",
@@ -43260,15 +43280,15 @@ function computeImportance(input) {
 		},
 		{
 			reason: "dwell",
-			value: WEIGHT_DWELL * clamp01$2(input.durationMs / DWELL_FULL_MS)
+			value: WEIGHT_DWELL * clamp01$1(input.durationMs / DWELL_FULL_MS)
 		},
 		{
 			reason: "proximity",
-			value: WEIGHT_PROXIMITY * clamp01$2(input.peakBboxAreaFrac / SIZE_FULL)
+			value: WEIGHT_PROXIMITY * clamp01$1(input.peakBboxAreaFrac / SIZE_FULL)
 		},
 		{
 			reason: "travel",
-			value: WEIGHT_TRAVEL * clamp01$2(input.totalDistance / 2)
+			value: WEIGHT_TRAVEL * clamp01$1(input.totalDistance / 2)
 		},
 		{
 			reason: "zone",
@@ -43287,11 +43307,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$2(sum * STATIC_IMPORTANCE_MULTIPLIER),
+		importance: clamp01$1(sum * STATIC_IMPORTANCE_MULTIPLIER),
 		reason: best.reason
 	};
 	return {
-		importance: clamp01$2(sum),
+		importance: clamp01$1(sum),
 		reason: best.reason
 	};
 }
@@ -46283,7 +46303,7 @@ var ClosedRowMediaGate = class {
 * it, so it can be loose enough to see the near misses.
 */
 var CO_MOVING_MIN_CONTAINMENT = .6;
-function intersectionArea$4(a, b) {
+function intersectionArea$3(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));
 }
 /**
@@ -46303,7 +46323,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$4(b.bbox, o.bbox);
+			const inter = intersectionArea$3(b.bbox, o.bbox);
 			if (inter <= 0) continue;
 			const union = areaB + areaO - inter;
 			const containment = inter / Math.min(areaB, areaO);
@@ -47303,7 +47323,7 @@ var LooseBindSampler = class {
 * diagonal = 2.085) with the same ~10% headroom the old 1.35 gave it.
 */
 var GROWTH_CENTROID_FACTOR = 2.3;
-function intersectionArea$3(a, b) {
+function intersectionArea$2(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);
@@ -47342,7 +47362,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$3(track, det) / smaller >= .5) return false;
+	if (intersectionArea$2(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);
@@ -50466,7 +50486,6 @@ var EMPTY_CASCADE_TALLY = {
 	faces: 0,
 	plates: 0,
 	embeddings: 0,
-	summaries: 0,
 	bytesReclaimed: 0
 };
 /** Fold a leaf store's receipts into a running tally. */
@@ -50510,13 +50529,6 @@ function addLeafCounts(tally, counts) {
 					bytesReclaimed
 				};
 				break;
-			case "summaries":
-				next = {
-					...next,
-					summaries: next.summaries + c.rows,
-					bytesReclaimed
-				};
-				break;
 		}
 	}
 	return next;
@@ -50530,7 +50542,6 @@ 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
 	};
 }
@@ -50593,7 +50604,6 @@ 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) {
@@ -50601,7 +50611,6 @@ 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;
 }
 /**
@@ -53198,7 +53207,9 @@ var MOTION_EVENTS_COLLECTION = "pipeline-analytics:motion-events";
 * @durable class=ledger owner=pipeline-analytics
 *   write="one row per detected object per processed frame — every tracked
 *     detection the frame processor emits, plus the appearance events and the
-*     synthetic package-drop events. Every row carries the trackId it belongs to."
+*     synthetic package-drop events. Every row carries the trackId it belongs to.
+*     A package PICK-UP row also carries observedAt, when the parcel went,
+*     beside its timestamp, when the departure was concluded (D684)."
 *   retention="TRACK-OWNED: it has no clock of its own. Rows go only when their
 *     track goes, through EventStore.deleteByTracks — which folds in the deletion
 *     of the event's child crops so a caller cannot take the events and leave the
@@ -53405,7 +53416,21 @@ var OBJECT_COLUMNS = [
 	{
 		name: "importance",
 		type: "REAL"
-	}
+	},
+	(
+	/**
+	* When a package PICK-UP happened, beside `timestamp` (when it was
+	* CONCLUDED, five minutes later) — see `ObjectEvent.observedAt` (D684).
+	*
+	* DECLARED, or the backend drops it on write (see `frameId`). Additive: the
+	* collection gains the column in place (`ALTER TABLE … ADD COLUMN`), and every
+	* row written before it reads SQL NULL → absent after `stripNulls`, which is
+	* the truth about it: the moment is unknown. Only the package detector sets it.
+	*/
+	{
+		name: "observedAt",
+		type: "INTEGER"
+	})
 ];
 var AUDIO_COLUMNS = [
 	...COMMON_BASE_COLUMNS,
@@ -55122,10 +55147,6 @@ function trackColumnsFor(projection, needsPositions = false) {
 * whatever order the engine felt like and a cursor that cannot resume.
 */
 var RECENT_IDS_COLUMNS = ["lastSeen"];
-/** How many track ids one filter pass may collect per tier. Bounded for the
-*  same reason every bulk read here is: an unbounded scan of this table is
-*  what D447 measured holding the settings thread for seconds. */
-var TRACK_MATCH_SCAN_LIMIT = 2e4;
 /** Spreadable `columns` for a store query — omitted entirely for `full`. */
 function projectionArg(projection, needsPositions = false) {
 	const columns = trackColumnsFor(projection, needsPositions);
@@ -56242,42 +56263,6 @@ var TrackStore = class {
 	* current subject out from under it. The orphan audit's grace window would
 	* hide this for an hour and then stop hiding it.
 	*/
-	/**
-	* Track ids whose CLASS, sub-class or instance matches any of `terms`.
-	*
-	* The summaries' filter asks its question here rather than on a copy: a
-	* label is a fact about the TRACK, it is decided while the track lives and
-	* can still be re-decided afterwards (class voting, a late face match, an
-	* operator enrolling a face and renaming that person). A copy stamped onto
-	* the summary would answer with whatever was true at one instant and never
-	* learn — which is the whole reason this lookup exists instead.
-	*
-	* Three queries because the filter compiler has no OR across fields, and one
-	* term can be any of the three tiers: `animal` is a class, `dog` is a
-	* sub-class, `Roberta` is an instance. Bounded, like every other bulk read
-	* here.
-	*/
-	async trackIdsMatching(terms) {
-		const wanted = terms.filter((t) => t.length > 0);
-		if (wanted.length === 0) return [];
-		const ids = /* @__PURE__ */ new Set();
-		for (const field of [
-			"className",
-			"label",
-			"subLabel"
-		]) {
-			const rows = await this.store.query.query({
-				collection: TRACKS_COLLECTION,
-				filter: {
-					whereIn: { [field]: [...wanted] },
-					limit: TRACK_MATCH_SCAN_LIMIT
-				},
-				columns: ["id"]
-			});
-			for (const row of rows) ids.add(row.id);
-		}
-		return [...ids];
-	}
 	async existingTrackIds(trackIds) {
 		const PAGE = 500;
 		const found = /* @__PURE__ */ new Set();
@@ -59284,6 +59269,180 @@ function decodeBase64(base64) {
 	}
 }
 //#endregion
+//#region src/notification-center/recorded-gif.ts
+/**
+* The notification GIF for a moment only the RECORDINGS still hold — derived
+* from the recorded clip's own bytes (D682).
+*
+* ## Why this exists
+*
+* A package pick-up is concluded five minutes after the parcel went
+* (`PACKAGE_STILLNESS_TTL_MS`). Once its footage is anchored on the pick-up
+* itself rather than on the conclusion (`media-anchor.ts`), the window is far
+* older than any clip ring (≤ 60 s, `NC_CLIP_RETENTION_MAX_SEC`), so the ring
+* refuses it. A gif-only rule then had NOTHING: the recorded follow-up served
+* only a rule that asked for a video. The honest fix for "the gif shows the
+* empty doormat" is not "no gif" — it is the gif of the pick-up, from the
+* recordings.
+*
+* ## One cut, and the gif is DERIVED from it
+*
+* The recorded clip (`recorded-clip.ts`, one `recordingExport` render) is the
+* only cut. The gif is derived from ITS bytes with the SAME filter chain the
+* broker uses on a ring cut (`gifFromMp4Args` in `@camstack/types`), so a gif
+* of an old moment and a gif of a live one look the same, and a rule that asks
+* for both a gif and a video gets two containers of ONE window — the guarantee
+* `NcEventMediaRequest` exists for.
+*
+* ## Never throws, every miss named
+*
+* `derive-failed` (ffmpeg could not produce it) and `stage-failed` (the clip
+* could not be written where ffmpeg can read it) are logged with
+* `tags: { deviceId }` (D400: a missing attachment names its reason).
+*/
+/** Bound on one derive: a ~10 s window encodes in well under a second; a
+*  derive that has not finished in 20 s is wedged. Same bound as the broker's. */
+var NC_RECORDED_GIF_TIMEOUT_MS = 2e4;
+/** A notification gif is a few hundred KB; this is headroom, not a budget. */
+var RECORDED_GIF_MAX_BUFFER = 32 * 1024 * 1024;
+/**
+* Derive the gif. Never throws; every `ok: false` has logged its reason.
+*/
+async function deriveRecordedGif(ports, req) {
+	const tags = { deviceId: req.deviceId };
+	const common = {
+		ruleId: req.ruleId,
+		eventId: req.recordId,
+		sourceBytes: req.mp4.byteLength
+	};
+	let file;
+	try {
+		file = await ports.writeTemp(req.mp4);
+	} catch (err) {
+		ports.logger.warn("recorded gif: could not stage the recorded clip — no gif", {
+			tags,
+			meta: {
+				...common,
+				reason: "stage-failed",
+				error: String(err)
+			}
+		});
+		return {
+			ok: false,
+			reason: "stage-failed"
+		};
+	}
+	try {
+		const speed = require_clip_model_registry.gifDeriveSpeed(4, req.videoSpeed ?? 1);
+		const args = require_clip_model_registry.gifFromMp4Args({
+			maxWidth: 640,
+			fps: 12,
+			speed,
+			input: file
+		});
+		const startedAt = Date.now();
+		let ran;
+		try {
+			ran = await ports.run(await ports.resolveFfmpeg(), args);
+		} catch (err) {
+			ran = {
+				ok: false,
+				error: String(err)
+			};
+		}
+		const out = ran.ok ? ran.stdout : null;
+		if (out === null || out.byteLength === 0) {
+			ports.logger.warn("recorded gif: the derive failed — the follow-up carries no gif", {
+				tags,
+				meta: {
+					...common,
+					reason: "derive-failed",
+					error: ran.ok ? "ffmpeg produced no bytes" : ran.error.slice(-400)
+				}
+			});
+			return {
+				ok: false,
+				reason: "derive-failed"
+			};
+		}
+		const gif = new Uint8Array(new ArrayBuffer(out.byteLength));
+		gif.set(out);
+		ports.logger.info("recorded gif: derived from the recorded clip", {
+			tags,
+			meta: {
+				...common,
+				gifBytes: gif.byteLength,
+				width: 640,
+				fps: 12,
+				speed,
+				encodeMs: Date.now() - startedAt
+			}
+		});
+		return {
+			ok: true,
+			gif
+		};
+	} finally {
+		await ports.removeTemp(file).catch((err) => {
+			ports.logger.warn("recorded gif: could not remove the staged clip", {
+				tags,
+				meta: {
+					...common,
+					file,
+					error: String(err)
+				}
+			});
+		});
+	}
+}
+/** The production ports: the pinned ffmpeg, a temp file, a bounded child. */
+function buildRecordedGifPorts(input) {
+	return {
+		logger: input.logger,
+		resolveFfmpeg: input.resolveFfmpeg,
+		run: (cmd, args) => new Promise((resolve) => {
+			(0, node_child_process.execFile)(cmd, [...args], {
+				encoding: "buffer",
+				maxBuffer: RECORDED_GIF_MAX_BUFFER,
+				timeout: NC_RECORDED_GIF_TIMEOUT_MS,
+				killSignal: "SIGKILL"
+			}, (err, stdout) => resolve(err !== null ? {
+				ok: false,
+				error: String(err)
+			} : {
+				ok: true,
+				stdout
+			}));
+		}),
+		writeTemp: (bytes) => stageTempClip(node_path.default.join(node_os.default.tmpdir(), `camstack-nc-gif-${(0, node_crypto.randomUUID)()}.mp4`), bytes, {
+			write: (file, data) => node_fs_promises.default.writeFile(file, data),
+			remove: (file) => node_fs_promises.default.rm(file, { force: true })
+		}),
+		removeTemp: (file) => node_fs_promises.default.rm(file, { force: true })
+	};
+}
+/**
+* Write the clip to `file`, and on a failed write remove whatever landed.
+*
+* The path is named BEFORE the write, because a write can create the file and
+* then fail (ENOSPC half-way): the caller's `finally` only knows a path the
+* write RETURNED, so a partial `camstack-nc-gif-*.mp4` used to stay in the temp
+* directory for good. The write's error is re-thrown — the caller names it
+* (`stage-failed`, tagged per camera). A removal that ALSO fails is a real leak
+* and rides in that same error's message, so it reaches that one line rather
+* than a second, untagged one.
+*/
+async function stageTempClip(file, bytes, io) {
+	try {
+		await io.write(file, bytes);
+		return file;
+	} catch (err) {
+		const leaked = await io.remove(file).then(() => null, (removeErr) => String(removeErr));
+		if (leaked === null) throw err;
+		throw new Error(`${String(err)}; the partial file ${file} was NOT removed: ${leaked}`);
+	}
+}
+//#endregion
 //#region src/shared/frame/crop-extractor.ts
 /**
 * The ONE reading of a normalized box against a frame: round, then clamp so
@@ -65216,7 +65375,7 @@ var RetrainAnnotationStore = class {
 };
 //#endregion
 //#region src/pipeline-analytics/retrain/retrain-geometry.ts
-function clamp01$1(v) {
+function clamp01(v) {
 	return v < 0 ? 0 : v > 1 ? 1 : v;
 }
 /** Is this a usable rectangle at all? A zero-area box is not a subject. */
@@ -65292,10 +65451,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$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 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 cropW = cropRight - cropX;
 	const cropH = cropBottom - cropY;
 	if (!(cropW > 0) || !(cropH > 0)) return null;
@@ -69872,7 +70031,7 @@ function isOversizeBox(bbox, frameWidth, frameHeight) {
 	const frame = frameWidth * frameHeight;
 	return frame > 0 && bbox.w * bbox.h / frame >= .3;
 }
-function intersectionArea$2(a, b) {
+function intersectionArea$1(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);
@@ -69885,7 +70044,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$2(parked, det) / entryArea >= SWALLOW_MIN_COVERAGE;
+	return intersectionArea$1(parked, det) / entryArea >= SWALLOW_MIN_COVERAGE;
 }
 /**
 * True when `det` is a FRAGMENT of the parked object — much smaller than the
@@ -69908,7 +70067,7 @@ function entrySwallowsDetection(parked, det) {
 	const detArea = det.w * det.h;
 	if (entryArea <= 0 || detArea <= 0) return false;
 	if (detArea > entryArea / 1.35) return false;
-	return intersectionArea$2(parked, det) / detArea >= FRAGMENT_MIN_CONTAINMENT;
+	return intersectionArea$1(parked, det) / detArea >= FRAGMENT_MIN_CONTAINMENT;
 }
 function parkedEntryHoldsDetection(entry, detBbox, config) {
 	const overlap = iou(entry.bbox, detBbox);
@@ -70757,10 +70916,12 @@ var PackageDropDetector = class {
 				pickupAt: entry.lastConfirmedAt
 			}
 		});
+		const observedAt = collector?.observedAt ?? pickupInstantOf(entry);
 		const draft = {
 			kind: "object",
 			deviceId: entry.deviceId,
 			timestamp,
+			observedAt,
 			source: "pipeline",
 			idempotencyKey: pickedUpKey,
 			trackId: mediaTrackId,
@@ -70812,6 +70973,8 @@ var PackageDropDetector = class {
 				idempotencyKey: pickedUpKey,
 				deliveredEventId: delivered.id,
 				mediaTrackId,
+				observedAt,
+				concludedLagMs: timestamp - observedAt,
 				...collector !== void 0 ? {
 					collectorTrackId: collector.trackId,
 					collectorClassName: collector.className,
@@ -70849,7 +71012,7 @@ var VEHICLE_CLASSES = [
 	"vehicle"
 ];
 /** Area of the intersection of two boxes. `0` when they do not overlap. */
-function intersectionArea$1(a, b) {
+function intersectionArea(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);
@@ -70866,7 +71029,7 @@ function intersectionArea$1(a, b) {
 function containedFraction(person, vehicle) {
 	const area = person.w * person.h;
 	if (area <= 0) return 0;
-	return intersectionArea$1(person, vehicle) / area;
+	return intersectionArea(person, vehicle) / area;
 }
 /**
 * Is this person box contained in any vehicle box in the same frame?
@@ -74462,895 +74625,6 @@ async function reconcileGallerySamples(deps, options) {
 		stoppedByCeiling
 	};
 }
-//#endregion
-//#region src/pipeline-analytics/summary/summary-membership.ts
-/**
-* Who belongs to a summary, and which member is its primary.
-*
-* ## What this corrects
-*
-* `openOrAbsorb` absorbed ANY track born while a summary was open on the
-* camera, and `primary` went to whoever opened it. Both were measured wrong on
-* the live hub on 2026-09-13: synthetic sensor tracks (`pa-synth-…`) sat inside
-* summaries describing "who was here together", and a dog that walked in ahead
-* of its owner outranked the person behind it.
-*
-* The operator's rule: "persona animale veicolo la priorità. Gli eventi extra
-* sono sempre separati come eventi sintetici di sensori e pacchi."
-*
-* ## Why exclusion and priority live together
-*
-* They are the same question asked twice — "what is a subject in a group" —
-* and answering it in two files is how the two drift. A class that stops being
-* a member must not keep a rank, and a class that gains a rank must be a
-* member.
-*
-* Pure, so the surprising cases are pinned rather than discovered: the dog that
-* arrives first, the tie between two people, and the member whose class is not
-* known yet.
-*/
-/** The synthetic marker. `synthetic-track.ts` mints these and nothing parses it
-*  except this — which is the one place it must be parsed. */
-var SYNTHETIC_TRACK_PREFIX = "pa-synth-";
-/**
-* Classes the operator keeps OUT of a group, by name.
-*
-* A delivered package is an event about a PLACE, not a member of something that
-* arrived together — the operator named it alongside the sensors.
-*/
-var NON_MEMBER_CLASSES = new Set(["package"]);
-/**
-* Is this track a member of a group at all?
-*
-* An unknown class is NOT a reason to refuse. The grouping is the point and the
-* label is decoration, and nothing revisits this decision — a member dropped
-* here is dropped for the life of the summary.
-*/
-function isSummaryEligible(trackId, className) {
-	if (trackId.startsWith(SYNTHETIC_TRACK_PREFIX)) return false;
-	return className === null || className === void 0 || !NON_MEMBER_CLASSES.has(className);
-}
-/**
-* The operator's order: person › animal › vehicle › everything else.
-*
-* Higher is more important. Everything unnamed — including a class that has not
-* resolved yet — sits below all three rather than above them: promoting an
-* unknown would let a momentary mis-read take the group's identity, and the
-* group shot with it.
-*/
-var CLASS_RANK = new Map([
-	["person", 3],
-	["animal", 2],
-	["vehicle", 1]
-]);
-function classPriority(className) {
-	if (className === null || className === void 0) return 0;
-	return CLASS_RANK.get(className) ?? 0;
-}
-/**
-* Which member is the primary: highest class rank, ties broken by EARLIEST
-* arrival.
-*
-* The tie-break matters more than it looks. Two people are equal, so without it
-* the primary would flip on every join between equals — and the primary is what
-* a consumer reads to name the group, so it would rename itself for no reason
-* an operator could see.
-*
-* `null` for no members, never a fabricated id.
-*/
-function primaryTrackId(members) {
-	let best = null;
-	for (const m of members) {
-		if (best === null) {
-			best = m;
-			continue;
-		}
-		const rank = classPriority(m.className);
-		const bestRank = classPriority(best.className);
-		if (rank > bestRank || rank === bestRank && m.joinedAt < best.joinedAt) best = m;
-	}
-	return best?.trackId ?? null;
-}
-//#endregion
-//#region src/pipeline-analytics/summary/summary-store.ts
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per SUMMARY — a window of co-present tracks on one camera
-*     group. Opened by `openOrAbsorb` when the first member arrives, updated
-*     in place while the window absorbs more, and finalised by `seal` when the
-*     window closes. Per WINDOW, never per frame or per track: the sealed
-*     summary is what a notification rule reads."
-*   retention="age-keyed on `sealedAt`, swept with the rest of the analytics
-*     retention. An unsealed row belongs to a window still open and is never
-*     swept by age — it is closed or cascaded away with its members."
-*/
-var SUMMARIES_COLLECTION = "pipeline-analytics:summaries";
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per (summary, track) membership, written as a window
-*     absorbs a track. The join that lets a sealed summary name its subjects
-*     without re-reading the track store."
-*   retention="cascaded — a member dies with its summary (`delete-track-cascade`
-*     counts them as leaves) or with the track it names. It carries no clock of
-*     its own: an age sweep here could outlive or predecease the summary the
-*     row only means anything inside of."
-*/
-var SUMMARY_MEMBERS_COLLECTION$1 = "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 = [(
-/**
-* NOT unique since 2026-09-13. A summary is a GROUP, not a camera session, so
-* one camera can hold several open at once — a family at the door while
-* somebody else crosses the far end of the drive, or a group that split and
-* whose halves are now two groups.
-*
-* The uniqueness was D359's third guarantee, and the other two survive it in
-* a stricter form: an open is still idempotent, now keyed on the BIRTH
-* (`deviceId`, `openedAt`, founding track) rather than on the camera and the
-* millisecond — two subjects detected in one frame are two groups, not one —
-* and sealing is still a conditional transition, addressed by id because
-* `(openDeviceId, openedAt)` no longer names one row. Those are what stopped
-* the 2026-08-24 incident of eleven sealed rows for one group; "one open per
-* camera" was the part that also forbade the model the operator asked for.
-*
-* The index itself is create-only in this system — `declareCollection` emits
-* `CREATE ... IF NOT EXISTS` and nothing anywhere drops an index — so on a
-* database that already has the UNIQUE version this declaration changes
-* nothing until that index is dropped by hand. Until then `openOrAbsorb`
-* degrades to exactly the old behaviour (the unique violation is caught and
-* the newcomer joins the winner), which is why the drop is a switch and not a
-* prerequisite.
-*/
-{
-	name: "summaries_open_device",
-	columns: ["openDeviceId"]
-}), {
-	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
-	}),
-	(
-	/**
-	* What this member IS to the summary: see {@link SummaryMemberRole}.
-	*
-	* NULLABLE, and not because a role is optional. `declareCollection` is
-	* additive — it ALTERs the column in — and SQLite refuses to add a `NOT NULL`
-	* column with no default to a table that already has rows. A default would be
-	* worse than null: it would stamp `primary` onto every member written before
-	* roles existed, including the siblings, and nothing downstream could tell
-	* the fabricated ones from the real ones.
-	*/
-	{
-		name: "role",
-		type: "TEXT"
-	}),
-	(
-	/**
-	* The member's subject class, so "which classes were present" is answerable
-	* without joining `tracks`. Nullable for the same additive reason, AND
-	* because a birth genuinely may not know a class yet — the membership is the
-	* point, the label is decoration.
-	*/
-	{
-		name: "className",
-		type: "TEXT"
-	})
-];
-var SUMMARY_MEMBERS_INDEXES = [
-	{
-		name: "summary_members_summary",
-		columns: ["summaryId"]
-	},
-	{
-		name: "summary_members_track",
-		columns: ["trackId"]
-	},
-	(
-	/** The filter's own index: "which groups hold an `animal`" walks members by
-	*  class, never summaries by hope. */
-	{
-		name: "summary_members_class",
-		columns: ["className"]
-	})
-];
-/**
-* A stored role, or `null`. An unrecognised value reads as `null` rather than
-* being passed through: a consumer switching on this must not receive a string
-* outside the union just because a row was hand-edited or written by a newer
-* release.
-*/
-function readRole(raw) {
-	return raw === "primary" || raw === "sibling" || raw === "child" ? raw : null;
-}
-function readClassName(raw) {
-	return typeof raw === "string" && raw.length > 0 ? raw : null;
-}
-/**
-* The key of an open, derived from the birth that founded it.
-*
-* The founding TRACK is part of it, and that is the whole point: the key used
-* to be `(deviceId, openedAt)`, which made an open idempotent — a retry writes
-* the same row — but also made two subjects detected in the SAME frame one
-* group, because they are born in the same millisecond. That is the ordinary
-* case on a gate camera, not a race. With the track in the key a retry still
-* collapses (same birth, same track) and two births stay two groups.
-*/
-/** The widest a JS Date can name — the open end of a half-bounded window. */
-var TIME_MIN = -864e13;
-var TIME_MAX = 864e13;
-/**
-* How many rows one paged read may materialise before the merge.
-*
-* The page is cut AFTER ordering, so the read must be able to serve any cursor
-* position — but it must also be bounded, because an unbounded read of this
-* table on a busy hub is the shape D447 measured holding the settings thread
-* for seconds. Summaries are far fewer than tracks by construction (14 940
-* against 30 583 on this hub), so this ceiling is generous.
-*/
-var RECENT_SUMMARY_SCAN_LIMIT = 5e3;
-/** How many member rows one filter pass may read per tier. Bounded for the same
-*  reason as the scan above, and generous: members are one row per subject. */
-var MEMBER_MATCH_SCAN_LIMIT = 2e4;
-function summaryId(deviceId, openedAt, foundingTrackId) {
-	return `sum-${deviceId}-${openedAt}-${foundingTrackId}`;
-}
-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;
-	trackIdsMatching;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.onEvict = deps.onEvict;
-		this.trackIdsMatching = deps.trackIdsMatching;
-	}
-	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$1,
-			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);
-	}
-	/**
-	* Every OPEN group, or just one camera's when `deviceId` is given.
-	*
-	* Plural per camera since 2026-09-13: a summary is a group, not a camera
-	* session, so "the open summary of this camera" stopped being a question with
-	* an answer. Ordered oldest-first, so a caller with no better rule takes the
-	* one that has been there longest — which is what `openOrAbsorb` does, and is
-	* byte-for-byte what shipped when only one could exist.
-	*/
-	async listOpen(deviceId) {
-		return (await this.store.query.query({
-			collection: SUMMARIES_COLLECTION,
-			filter: {
-				where: deviceId === void 0 ? { sealedAt: null } : { openDeviceId: deviceId },
-				limit: 1e4
-			}
-		})).filter((r) => r.data["openDeviceId"] !== null).map((r) => toRow$1(r.id, r.data)).toSorted((a, b) => a.openedAt - b.openedAt);
-	}
-	async membersOf(summaryIdValue) {
-		return (await this.store.query.query({
-			collection: SUMMARY_MEMBERS_COLLECTION$1,
-			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"]),
-			role: readRole(r.data["role"]),
-			className: readClassName(r.data["className"])
-		}));
-	}
-	/**
-	* 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.
-	*/
-	/**
-	* Open a NEW group for this track.
-	*
-	* The unique-violation branch is kept even though `summaries_open_device` is
-	* no longer UNIQUE: the id is `f(deviceId, openedAt)`, so two births in the
-	* SAME millisecond still collide on the primary key, and the right answer
-	* there is still "join the row that won" — it is the same group.
-	*/
-	async openNew(input) {
-		const id = summaryId(input.deviceId, input.at, input.trackId);
-		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.listOpen(input.deviceId)).find((s) => s.id === id);
-			if (winner === void 0) throw err;
-			return this.absorbInto(winner, input);
-		}
-		await this.addMember(id, input, "primary");
-		return {
-			id,
-			deviceId: input.deviceId,
-			openedAt: input.at,
-			lastActiveAt: input.at,
-			sealedAt: null,
-			memberCount: 1
-		};
-	}
-	/**
-	* Join the camera's oldest open group, or open one.
-	*
-	* The default policy, for callers with no better rule. The rule that DOES
-	* know better — proximity — lives with the caller that can see positions, and
-	* reaches the store through {@link listOpen} + {@link absorbInto} instead.
-	*/
-	async openOrAbsorb(input) {
-		const first = (await this.listOpen(input.deviceId))[0];
-		return first === void 0 ? this.openNew(input) : this.absorbInto(first, input);
-	}
-	async absorbInto(summary, input) {
-		const members = await this.membersOf(summary.id);
-		if (members.some((m) => m.trackId === input.trackId)) return summary;
-		const joined = {
-			trackId: input.trackId,
-			className: input.className ?? null,
-			joinedAt: input.at
-		};
-		const primary = primaryTrackId([...members.map((m) => ({
-			trackId: m.trackId,
-			className: m.className,
-			joinedAt: m.joinedAt
-		})), joined]);
-		await this.addMember(summary.id, input, primary === input.trackId ? "primary" : "sibling");
-		if (primary === input.trackId) await this.demoteOtherPrimaries(summary.id, input.trackId, members);
-		const memberCount = members.length + 1;
-		const lastActiveAt = Math.max(summary.lastActiveAt, input.at);
-		await this.store.updateWhere.mutate({
-			collection: SUMMARIES_COLLECTION,
-			filter: { where: {
-				id: summary.id,
-				openDeviceId: summary.deviceId
-			} },
-			data: {
-				memberCount,
-				lastActiveAt
-			}
-		});
-		return {
-			...summary,
-			memberCount,
-			lastActiveAt
-		};
-	}
-	/**
-	* Move a set of members out of an open group into a NEW open group.
-	*
-	* The two sides of a split. The departing members keep their join times, so
-	* the group that leaves opens at the moment its earliest member joined the
-	* old one — it existed then; what changed is that we can now tell.
-	*
-	* Order is deliberate: the new rows are written BEFORE the old ones are
-	* dropped. A failure between the two leaves a member in both groups, which a
-	* reader can see and a later pass can repair; the other order loses the
-	* membership, and a lost member is the one wrong this store exists to
-	* prevent (the same reasoning as {@link demoteOtherPrimaries}).
-	*
-	* `null` when there is nothing to do: no member matched, or ALL of them did.
-	* Moving everybody is not a split — it would leave an empty group behind and
-	* a new one holding exactly what the old one held.
-	*/
-	async splitOff(summary, departingTrackIds, at) {
-		const members = await this.membersOf(summary.id);
-		const leaving = members.filter((m) => departingTrackIds.includes(m.trackId));
-		const staying = members.filter((m) => !departingTrackIds.includes(m.trackId));
-		if (leaving.length === 0 || staying.length === 0) return null;
-		const openedAt = Math.min(...leaving.map((m) => m.joinedAt));
-		const founder = leaving.find((m) => m.joinedAt === openedAt) ?? leaving[0];
-		const id = summaryId(summary.deviceId, openedAt, founder.trackId);
-		await this.store.set.mutate({
-			collection: SUMMARIES_COLLECTION,
-			key: id,
-			value: {
-				deviceId: summary.deviceId,
-				openedAt,
-				lastActiveAt: summary.lastActiveAt,
-				sealedAt: null,
-				openDeviceId: summary.deviceId,
-				memberCount: leaving.length
-			}
-		});
-		const newPrimary = primaryTrackId(leaving);
-		await this.store.insertMany.mutate({
-			collection: SUMMARY_MEMBERS_COLLECTION$1,
-			records: leaving.map((m) => ({
-				id: memberRowId(id, m.trackId),
-				data: {
-					summaryId: id,
-					trackId: m.trackId,
-					deviceId: m.deviceId,
-					timestamp: m.joinedAt,
-					role: m.trackId === newPrimary ? "primary" : "sibling",
-					className: m.className
-				}
-			}))
-		});
-		await this.store.deleteWhere.mutate({
-			collection: SUMMARY_MEMBERS_COLLECTION$1,
-			filter: {
-				where: { summaryId: summary.id },
-				whereIn: { trackId: leaving.map((m) => m.trackId) }
-			}
-		});
-		const keptPrimary = primaryTrackId(staying);
-		for (const m of staying) {
-			const role = m.trackId === keptPrimary ? "primary" : "sibling";
-			if (m.role === role) continue;
-			await this.store.update.mutate({
-				collection: SUMMARY_MEMBERS_COLLECTION$1,
-				id: memberRowId(summary.id, m.trackId),
-				data: { role }
-			});
-		}
-		await this.store.updateWhere.mutate({
-			collection: SUMMARIES_COLLECTION,
-			filter: { where: {
-				id: summary.id,
-				openDeviceId: summary.deviceId
-			} },
-			data: { memberCount: staying.length }
-		});
-		this.logger.info("summary: a group walked apart", {
-			tags: { deviceId: summary.deviceId },
-			meta: {
-				summaryId: summary.id,
-				bornId: id,
-				left: leaving.map((m) => m.trackId),
-				stayed: staying.map((m) => m.trackId),
-				at
-			}
-		});
-		return {
-			id,
-			deviceId: summary.deviceId,
-			openedAt,
-			lastActiveAt: summary.lastActiveAt,
-			sealedAt: null,
-			memberCount: leaving.length
-		};
-	}
-	/**
-	* Put every OTHER member back to `sibling` after a new primary took the role.
-	*
-	* Best-effort per row and loud about a row it could not move: two primaries
-	* is a wrong a consumer can see, but it is smaller than a lost member, so a
-	* failure here never propagates to the join.
-	*/
-	async demoteOtherPrimaries(summaryIdValue, primaryTrack, previous) {
-		for (const m of previous) {
-			if (m.trackId === primaryTrack || m.role !== "primary") continue;
-			try {
-				await this.store.update.mutate({
-					collection: SUMMARY_MEMBERS_COLLECTION$1,
-					id: memberRowId(summaryIdValue, m.trackId),
-					data: { role: "sibling" }
-				});
-			} catch (err) {
-				this.logger.warn("summary: could not demote the previous primary — two remain", { meta: {
-					summaryId: summaryIdValue,
-					trackId: m.trackId,
-					error: String(err)
-				} });
-			}
-		}
-	}
-	async addMember(summaryIdValue, input, role) {
-		await this.store.insertMany.mutate({
-			collection: SUMMARY_MEMBERS_COLLECTION$1,
-			records: [{
-				id: memberRowId(summaryIdValue, input.trackId),
-				data: {
-					summaryId: summaryIdValue,
-					trackId: input.trackId,
-					deviceId: input.deviceId,
-					timestamp: input.at,
-					role,
-					className: input.className ?? null
-				}
-			}]
-		});
-	}
-	/**
-	* 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: {
-				id: summary.id,
-				openDeviceId: summary.deviceId
-			} },
-			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$1,
-			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$1,
-			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 surface's page (D359 phase 4): a camera set, newest first by
-	* `openedAt`, inside an optional window, bounded. Ordered and bounded HERE
-	* as well as in the query, so a store that ignores `orderBy` (the fake
-	* does) cannot hand the surface an unordered page.
-	*/
-	async listRecent(input) {
-		if (input.deviceIds.length === 0) return [];
-		const matching = await this.summaryIdsMatching(input.classes);
-		if (matching !== null && matching.size === 0) return [];
-		const limit = Math.max(1, input.limit);
-		return (await this.store.query.query({
-			collection: SUMMARIES_COLLECTION,
-			filter: {
-				whereIn: { deviceId: [...input.deviceIds] },
-				...input.since !== void 0 || input.until !== void 0 ? { whereBetween: { openedAt: [input.since ?? 0, input.until ?? Number.MAX_SAFE_INTEGER] } } : {},
-				orderBy: {
-					field: "openedAt",
-					direction: "desc"
-				},
-				limit
-			}
-		})).map((r) => toRow$1(r.id, r.data)).filter((row) => matching === null || matching.has(row.id)).sort((a, b) => b.openedAt - a.openedAt).slice(0, limit);
-	}
-	/** One summary with its members, or `null`. */
-	/**
-	* One PAGE of summaries across a camera set, newest activity first.
-	*
-	* The same contract as `listRecentTracks` and for the same consumers: the
-	* reel on the cameras page and the Events gallery both ride a cursor, so a
-	* feed that could only answer "the last N" would make groups available in the
-	* timeline and nowhere else. `recent-cursor.ts` is reused verbatim — the
-	* ordering is the stable total order (`lastActiveAt` DESC, id DESC), and a
-	* second implementation of that is a second place for two feeds to disagree
-	* about what "newest" means.
-	*
-	* The window is on LAST ACTIVITY, not on the open: a session that started
-	* before the window and ran into it belongs to the window, because it
-	* happened there.
-	*
-	* Members for the WHOLE page come back in one read. One query per row is how
-	* a page of two hundred becomes two hundred round trips — the shape that made
-	* the old digest read two thousand tracks a camera.
-	*/
-	async queryRecent(input) {
-		const deviceIds = [...new Set(input.deviceIds)];
-		if (deviceIds.length === 0) return {
-			summaries: [],
-			nextCursor: null
-		};
-		const cursor = input.cursor === void 0 ? null : decodeRecentCursor(input.cursor);
-		const matching = await this.summaryIdsMatching(input.classes);
-		if (matching !== null && matching.size === 0) return {
-			summaries: [],
-			nextCursor: null
-		};
-		const ordered = (await this.store.query.query({
-			collection: SUMMARIES_COLLECTION,
-			filter: {
-				whereIn: { deviceId: deviceIds },
-				...input.since !== void 0 || input.until !== void 0 ? { whereBetween: { lastActiveAt: [input.since ?? TIME_MIN, input.until ?? TIME_MAX] } } : {},
-				limit: RECENT_SUMMARY_SCAN_LIMIT
-			}
-		})).map((r) => toRow$1(r.id, r.data)).filter((row) => matching === null || matching.has(row.id)).map((row) => ({
-			row,
-			key: {
-				lastSeen: row.lastActiveAt,
-				id: row.id
-			}
-		})).filter((entry) => cursor === null || isAfterCursor(entry.key, cursor)).toSorted((a, b) => compareRecentDesc(a.key, b.key));
-		const page = ordered.slice(0, input.limit);
-		const last = page.at(-1);
-		const nextCursor = last !== void 0 && ordered.length > page.length ? encodeRecentCursor({
-			lastSeen: last.row.lastActiveAt,
-			trackId: last.row.id
-		}) : null;
-		const members = await this.membersOfMany(page.map((e) => e.row.id));
-		return {
-			summaries: page.map((e) => ({
-				summary: e.row,
-				members: members.get(e.row.id) ?? []
-			})),
-			nextCursor
-		};
-	}
-	/**
-	* The summaries whose MEMBERS match any of `classes`, or `null` for no filter.
-	*
-	* TRACKS first, then the members that name them, then the summaries. The
-	* label is a fact about the track and it is asked of the track — a summary
-	* that stored its own copy would answer with whatever was true when it
-	* sealed, and would never learn that a face was enrolled and a person named
-	* an hour later. The operator's rule: *a summary keeps the minimum
-	* information necessary*, and a duplicated label is not the minimum, it is a
-	* second truth with an expiry date.
-	*
-	* Narrows before the page is cut. Filtering the other way round — a page of
-	* summaries, then their members — returns a short or empty page while matches
-	* sit further down the list, and the operator reads that as "there were none".
-	*/
-	async summaryIdsMatching(classes) {
-		const wanted = (classes ?? []).filter((t) => t.length > 0);
-		if (wanted.length === 0) return null;
-		const matchTracks = this.trackIdsMatching;
-		if (matchTracks === void 0) {
-			this.logger.warn("summary filter: no track matcher wired — refusing to answer unfiltered", { meta: { classes: wanted.length } });
-			return /* @__PURE__ */ new Set();
-		}
-		const trackIds = await matchTracks(wanted);
-		if (trackIds.length === 0) return /* @__PURE__ */ new Set();
-		const ids = /* @__PURE__ */ new Set();
-		const PAGE = 500;
-		for (let i = 0; i < trackIds.length; i += PAGE) {
-			const chunk = trackIds.slice(i, i + PAGE);
-			const rows = await this.store.query.query({
-				collection: SUMMARY_MEMBERS_COLLECTION$1,
-				filter: {
-					whereIn: { trackId: [...chunk] },
-					limit: MEMBER_MATCH_SCAN_LIMIT
-				}
-			});
-			for (const row of rows) ids.add(String(row.data["summaryId"] ?? ""));
-		}
-		ids.delete("");
-		return ids;
-	}
-	/** Members of many summaries, in ONE read, grouped by summary id. */
-	async membersOfMany(summaryIds) {
-		const out = /* @__PURE__ */ new Map();
-		if (summaryIds.length === 0) return out;
-		const rows = await this.store.query.query({
-			collection: SUMMARY_MEMBERS_COLLECTION$1,
-			filter: {
-				whereIn: { summaryId: [...summaryIds] },
-				limit: 1e4
-			}
-		});
-		for (const r of rows) {
-			const summaryIdValue = String(r.data["summaryId"] ?? "");
-			const member = {
-				summaryId: summaryIdValue,
-				trackId: String(r.data["trackId"] ?? ""),
-				deviceId: num$1(r.data["deviceId"]),
-				joinedAt: num$1(r.data["timestamp"]),
-				role: readRole(r.data["role"]),
-				className: readClassName(r.data["className"])
-			};
-			const bucket = out.get(summaryIdValue);
-			if (bucket === void 0) out.set(summaryIdValue, [member]);
-			else bucket.push(member);
-		}
-		for (const bucket of out.values()) bucket.sort((a, b) => a.joinedAt - b.joinedAt);
-		return out;
-	}
-	async get(id) {
-		const raw = await this.store.get.query({
-			collection: SUMMARIES_COLLECTION,
-			key: id
-		});
-		if (typeof raw !== "object" || raw === null) return null;
-		return {
-			summary: toRow$1(id, raw),
-			members: await this.membersOf(id)
-		};
-	}
-	/** 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$1,
-			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.
 *
@@ -78624,10 +77898,6 @@ var ANALYTICS_COLLECTIONS = [
 		collection: PLATES_COLLECTION$1,
 		classification: derived(PLATE_COLUMNS)
 	},
-	{
-		collection: SUMMARY_MEMBERS_COLLECTION$1,
-		classification: derived(SUMMARY_MEMBERS_COLUMNS)
-	},
 	{
 		collection: MEDIA_COLLECTION,
 		classification: {
@@ -78671,13 +77941,6 @@ var ANALYTICS_COLLECTIONS = [
 			rootId: "ops-log"
 		}
 	},
-	{
-		collection: SUMMARIES_COLLECTION,
-		classification: {
-			kind: "retention-root",
-			rootId: "summary"
-		}
-	},
 	{
 		collection: IDENTITIES_COLLECTION,
 		classification: {
@@ -78866,10 +78129,6 @@ function resolveMediaOwner(row) {
 			table: ownerKind,
 			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)
@@ -78977,17 +78236,15 @@ var DEFAULT_ORPHAN_LIMITS = {
 function questionsFor(refs) {
 	const trackIds = /* @__PURE__ */ new Set();
 	const eventIds = /* @__PURE__ */ new Map();
-	const summaryIds = /* @__PURE__ */ new Set();
 	for (const ref of refs) if (ref.kind === "track") trackIds.add(ref.trackId);
 	else if (ref.kind === "event") {
 		const perTable = eventIds.get(ref.table) ?? /* @__PURE__ */ new Set();
 		perTable.add(ref.eventId);
 		eventIds.set(ref.table, perTable);
-	} else if (ref.kind === "summary") summaryIds.add(ref.summaryId);
+	}
 	return {
 		trackIds: [...trackIds],
-		eventIdsByTable: new Map([...eventIds].map(([table, ids]) => [table, [...ids]])),
-		summaryIds: [...summaryIds]
+		eventIdsByTable: new Map([...eventIds].map(([table, ids]) => [table, [...ids]]))
 	};
 }
 /**
@@ -79031,10 +78288,9 @@ async function auditScope(scope, deps, limits, cursor) {
 			break;
 		}
 		const refs = rows.map((row) => scope.resolve(row));
-		const { trackIds, eventIdsByTable, summaryIds } = questionsFor(refs);
+		const { trackIds, eventIdsByTable } = questionsFor(refs);
 		let liveTracks;
 		const liveEvents = /* @__PURE__ */ new Map();
-		let liveSummaries;
 		let keptMedia = /* @__PURE__ */ new Set();
 		try {
 			liveTracks = trackIds.length > 0 ? await deps.liveTrackIds(trackIds) : /* @__PURE__ */ new Set();
@@ -79043,7 +78299,6 @@ async function auditScope(scope, deps, limits, cursor) {
 				if (ids.length === 0) continue;
 				liveEvents.set(table, await deps.liveEventIds(table, ids));
 			}
-			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,
@@ -79071,7 +78326,7 @@ async function auditScope(scope, deps, limits, cursor) {
 				tally.unresolvable += 1;
 				continue;
 			}
-			if (ref.kind === "track" ? liveTracks.has(ref.trackId) || keptMedia.has(row.key) : ref.kind === "event" ? liveEvents.get(ref.table)?.has(ref.eventId) ?? false : ref.kind === "summary" ? liveSummaries.has(ref.summaryId) : false) continue;
+			if (ref.kind === "track" ? liveTracks.has(ref.trackId) || keptMedia.has(row.key) : ref.kind === "event" ? liveEvents.get(ref.table)?.has(ref.eventId) ?? false : false) continue;
 			const ts = num(row.data, scope.timestampField);
 			if (ts !== null && ts > graceFloor) {
 				tally.withinGrace += 1;
@@ -79241,11 +78496,7 @@ var ORPHAN_AUDIT_DEFAULTS = {
 	intervalHours: OrphanAuditIntervalHoursSchema.parse(void 0),
 	pageSize: OrphanAuditPageSizeSchema.parse(void 0)
 };
-var RAW_DELETE_COLLECTIONS = new Set([
-	"pipeline-analytics:object-events",
-	"pipeline-analytics:plates",
-	"pipeline-analytics:summary-members"
-]);
+var RAW_DELETE_COLLECTIONS = new Set(["pipeline-analytics:object-events", "pipeline-analytics:plates"]);
 function buildOrphanReclaimer(ports) {
 	return async (collection, key) => {
 		if (collection === "pipeline-analytics:media") {
@@ -79386,14 +78637,12 @@ 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,
-				summaries
+				sensor
 			};
-			if (evicted.motion.length + evicted.audio.length + evicted.sensor + evicted.summaries > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
+			if (evicted.motion.length + evicted.audio.length + evicted.sensor > 0) await deps.onEvicted(deviceId, evicted, cutoffs);
 		} catch (err) {
 			deps.onError(deviceId, err);
 		}
@@ -80170,11 +79419,12 @@ function isFullFrameBbox(bbox) {
 /** Throttle for the native-crop HIT/FALLBACK metric window line. */
 var NATIVE_CROP_METRIC_INTERVAL_MS = 3e4;
 /**
-* Above this `maxWidth`, a full-frame fetch is a NATIVE full frame (the
-* `keyFrame`/group-shot rung, ~1–1.5 MB on a 4K camera) rather than a boxed
-* timeline tile or a pinned ≤640 detection frame (tens of kB). The two belong
-* in different counters or the window line says "full frames" and means two
-* payload classes three orders of magnitude apart. (D470)
+* Above this `maxWidth`, a full-frame fetch is a NATIVE full frame (~1–1.5 MB
+* on a 4K camera) rather than a boxed timeline tile or a pinned ≤640 detection
+* frame (tens of kB). The two belong in different counters or the window line
+* says "full frames" and means two payload classes three orders of magnitude
+* apart. (D470) No caller asks for that rung since D422 (the key frame) and
+* D680 (the group shot); the counter stays so the next one is seen.
 */
 var FULL_FRAME_TILE_WIDTH_CEILING = 1920;
 function createNativeFrameTransport(deps) {
@@ -80251,8 +79501,8 @@ function createNativeFrameTransport(deps) {
 		};
 	};
 	const getRemoteFrame = async (handle) => closeWindowAfter(requestNativeCrop(handle, FULL_FRAME_BBOX, handle.width, replyToFullFrame));
+	const getNativeFullFrameRgb = async (handle, maxWidth) => closeWindowAfter(requestNativeCrop(handle, FULL_FRAME_BBOX, maxWidth, replyToFullFrame));
 	const fetchNativeFullFrameTiered = async (handle, maxWidth) => closeWindowAfter(requestNativeCrop(handle, FULL_FRAME_BBOX, maxWidth, replyToTieredFullFrame));
-	const getNativeFullFrameRgb = async (handle, maxWidth) => (await fetchNativeFullFrameTiered(handle, maxWidth))?.frame ?? null;
 	const cropMetricLogger = logger.child("NativeCrop");
 	let nativeHits = 0;
 	let nativeFallbacks = 0;
@@ -80268,8 +79518,8 @@ function createNativeFrameTransport(deps) {
 	/**
 	* Publish the window once `request` has SETTLED — never before, or the line
 	* carries a window whose own outcome has not been counted yet and throttles
-	* away the one that has. `finally`, so the deliberate throw of
-	* `fetchNativeFullFrameTiered` still reaches `persistTrackKeyFrame`.
+	* away the one that has. `finally`, so the deliberate throw of the
+	* full-frame fetches still reaches their callers.
 	*/
 	const closeWindowAfter = async (request) => {
 		try {
@@ -80340,7 +79590,7 @@ function createNativeFrameTransport(deps) {
 			bumpCropMetric(false);
 			return null;
 		}
-		if (!keyFrameAcceptsTier(native.tier)) {
+		if (native.tier === "ram-fullframe") {
 			bumpCropMetric(false);
 			cropMetricLogger.info("subject crop refused: sub-native tier (will retry, no masquerade)", {
 				...deviceId !== void 0 ? { tags: { deviceId } } : {},
@@ -80360,7 +79610,6 @@ function createNativeFrameTransport(deps) {
 	return {
 		getRemoteFrame,
 		getNativeFullFrameRgb,
-		getNativeKeyFrameRgb: fetchNativeFullFrameTiered,
 		getNativeCropJpeg,
 		captureCrop: createCaptureCrop({
 			tryNativeCrop,
@@ -86436,947 +85685,6 @@ var RawGlobalStoreMirror = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/summary/group-crop.ts
-/** Padding around the union, as a fraction of its own size. */
-var GROUP_CROP_PADDING = .12;
-/**
-* Smallest crop, per axis, as a fraction of the frame.
-*
-* A quarter. Below that a thumbnail stops being legible at the sizes the
-* gallery draws it, and the extra context costs nothing — the subjects stay the
-* dominant thing in the picture at this size.
-*/
-var MIN_CROP_FRACTION = .25;
-/**
-* The crop, or `null` when there is nothing to cut to — no visible member, or
-* a frame with no dimensions. `null` means the caller keeps the full frame,
-* which is the only honest answer when nobody could say where the group was.
-*/
-function groupCropRect(input) {
-	const { frameWidth: fw, frameHeight: fh } = input;
-	if (fw <= 0 || fh <= 0) return null;
-	const boxes = input.boxes.filter((b) => b.width > 0 && b.height > 0);
-	if (boxes.length === 0) return null;
-	let left = Number.POSITIVE_INFINITY;
-	let top = Number.POSITIVE_INFINITY;
-	let right = Number.NEGATIVE_INFINITY;
-	let bottom = Number.NEGATIVE_INFINITY;
-	for (const b of boxes) {
-		left = Math.min(left, b.x);
-		top = Math.min(top, b.y);
-		right = Math.max(right, b.x + b.width);
-		bottom = Math.max(bottom, b.y + b.height);
-	}
-	const padX = (right - left) * GROUP_CROP_PADDING;
-	const padY = (bottom - top) * GROUP_CROP_PADDING;
-	let x0 = left - padX;
-	let y0 = top - padY;
-	let x1 = right + padX;
-	let y1 = bottom + padY;
-	const minW = fw * MIN_CROP_FRACTION;
-	const minH = fh * MIN_CROP_FRACTION;
-	if (x1 - x0 < minW) {
-		const cx = (x0 + x1) / 2;
-		x0 = cx - minW / 2;
-		x1 = cx + minW / 2;
-	}
-	if (y1 - y0 < minH) {
-		const cy = (y0 + y1) / 2;
-		y0 = cy - minH / 2;
-		y1 = cy + minH / 2;
-	}
-	const width = Math.min(x1 - x0, fw);
-	const height = Math.min(y1 - y0, fh);
-	const x = Math.max(0, Math.min(x0, fw - width));
-	const y = Math.max(0, Math.min(y0, fh - height));
-	return {
-		x: Math.round(x),
-		y: Math.round(y),
-		width: Math.round(width),
-		height: Math.round(height)
-	};
-}
-/**
-* Carry a crop computed on the DETECTION frame onto the NATIVE surface.
-*
-* The two are different sizes by construction: detection runs on a downscaled
-* frame and the group shot is fetched at up to 4096 px. Applying the rectangle
-* raw would cut a corner of the picture and call it the group — the failure
-* mode is silent and looks like a framing bug.
-*
-* Scaled per axis rather than by one factor, because the two surfaces are not
-* guaranteed to share an aspect, and clamped to the native frame so rounding
-* can never ask for a pixel that is not there.
-*/
-function scaleCropToFrame(crop, from, to) {
-	if (from.width <= 0 || from.height <= 0 || to.width <= 0 || to.height <= 0) return null;
-	const sx = to.width / from.width;
-	const sy = to.height / from.height;
-	const x = Math.max(0, Math.min(Math.round(crop.x * sx), to.width - 1));
-	const y = Math.max(0, Math.min(Math.round(crop.y * sy), to.height - 1));
-	return {
-		x,
-		y,
-		width: Math.max(1, Math.min(Math.round(crop.width * sx), to.width - x)),
-		height: Math.max(1, Math.min(Math.round(crop.height * sy), to.height - y))
-	};
-}
-//#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,
-		crop: null
-	};
-	const quality = visible.reduce((sum, d) => sum + memberQuality(d, input.frameWidth, input.frameHeight), 0) / visible.length;
-	const crop = groupCropRect({
-		boxes: visible.map((d) => ({
-			x: d.bbox.x,
-			y: d.bbox.y,
-			width: d.bbox.width,
-			height: d.bbox.height
-		})),
-		frameWidth: input.frameWidth,
-		frameHeight: input.frameHeight
-	});
-	return {
-		visible: visible.length,
-		quality,
-		crop
-	};
-}
-/**
-* 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;
-}
-var GroupShotTracker = class {
-	states = /* @__PURE__ */ new Map();
-	offered = 0;
-	materialised = 0;
-	byGap = 0;
-	byMargin = 0;
-	byWorse = 0;
-	/**
-	* Offer a frame. Returns `true` when it is worth materialising NOW — the
-	* caller's cue to fetch the pixels for THIS frame, while its handle is
-	* still leased.
-	*
-	* The clock is `frame.timestamp`; the caller injects no second one.
-	*/
-	offer(summaryId, score, frame) {
-		if (score.visible === 0) return false;
-		this.offered += 1;
-		const state = this.states.get(summaryId);
-		if (state === void 0) {
-			this.states.set(summaryId, {
-				delivered: null,
-				lastAttemptAt: frame.timestamp,
-				unlanded: 1
-			});
-			this.materialised += 1;
-			return true;
-		}
-		if (state.lastAttemptAt !== void 0 && frame.timestamp - state.lastAttemptAt < 2e3) {
-			this.byGap += 1;
-			return false;
-		}
-		if (!this.isWorthPixels(state, score)) return false;
-		state.lastAttemptAt = frame.timestamp;
-		state.unlanded += 1;
-		this.materialised += 1;
-		return true;
-	}
-	/**
-	* Nothing has landed yet → keep trying (D58) until the budget is spent.
-	* Something has landed → beat it, by the margin on the quality tiebreak.
-	*/
-	isWorthPixels(state, score) {
-		const delivered = state.delivered;
-		if (delivered === null) {
-			if (state.unlanded >= 4) {
-				this.byMargin += 1;
-				return false;
-			}
-			return true;
-		}
-		if (compareSummaryScores(score, delivered.score) <= 0) {
-			this.byWorse += 1;
-			return false;
-		}
-		if (score.visible === delivered.score.visible && score.quality - delivered.score.quality < .05) {
-			this.byMargin += 1;
-			return false;
-		}
-		return true;
-	}
-	/**
-	* A materialisation LANDED. Only this advances the baseline the next
-	* candidate must beat — a fetch that missed leaves the summary exactly as
-	* picture-less as it was, and the next frame may be worse and still worth
-	* taking.
-	*/
-	noteLanded(summaryId, score, frame) {
-		const state = this.states.get(summaryId);
-		if (state === void 0) return;
-		state.delivered = {
-			score,
-			frame
-		};
-		state.unlanded = 0;
-	}
-	/** The shot on disk for this summary, as this process last saw it land. */
-	deliveredOf(summaryId) {
-		return this.states.get(summaryId)?.delivered ?? null;
-	}
-	/** A sealed or evicted summary takes no more frames; drop its state. */
-	forget(summaryId) {
-		this.states.delete(summaryId);
-	}
-	/**
-	* What the gate did since the last read. Shipped WITH the gate: without it
-	* the only evidence for a fetch that did NOT happen is hub-main's byte
-	* counter, which answers a different question a minute later.
-	*/
-	drainCounts() {
-		const counts = {
-			offered: this.offered,
-			materialised: this.materialised,
-			byGap: this.byGap,
-			byMargin: this.byMargin,
-			byWorse: this.byWorse
-		};
-		this.offered = 0;
-		this.materialised = 0;
-		this.byGap = 0;
-		this.byMargin = 0;
-		this.byWorse = 0;
-		return counts;
-	}
-	get size() {
-		return this.states.size;
-	}
-};
-//#endregion
-//#region src/pipeline-analytics/summary/group-shot-materialiser.ts
-/**
-* Apply the group crop to the native surface, or hand it back untouched.
-*
-* Every reason to skip is a reason NOT to guess: no rectangle, no detection
-* geometry to scale from, or a cropper this deployment does not have. The full
-* frame is worse than a crop and far better than a wrong crop.
-*/
-async function cropNative(native, input, deps) {
-	const crop = input.crop;
-	if (!crop || !deps.cropFrame) return native;
-	const fw = input.cropFrameWidth;
-	const fh = input.cropFrameHeight;
-	if (fw === void 0 || fh === void 0) return native;
-	const scaled = scaleCropToFrame(crop, {
-		width: fw,
-		height: fh
-	}, native);
-	if (scaled === null) return native;
-	if (scaled.width >= native.width && scaled.height >= native.height) return native;
-	try {
-		const cut = await deps.cropFrame(native, scaled);
-		if (cut === null) return native;
-		const expected = cut.width * cut.height * 3;
-		if (cut.format === "rgb" && cut.data.length !== expected) {
-			deps.logger.warn("group shot crop returned a surface that is not its geometry", {
-				tags: { deviceId: input.deviceId },
-				meta: {
-					summaryId: input.summaryId,
-					width: cut.width,
-					height: cut.height,
-					expectedBytes: expected,
-					gotBytes: cut.data.length
-				}
-			});
-			return native;
-		}
-		return cut;
-	} catch (err) {
-		deps.logger.warn("group shot crop failed — storing the full frame", {
-			tags: { deviceId: input.deviceId },
-			meta: {
-				summaryId: input.summaryId,
-				error: require_clip_model_registry.errMsg(err)
-			}
-		});
-		return native;
-	}
-}
-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 surface = await cropNative(native, input, deps);
-		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(surface);
-		const keyFrameMediaId = 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_clip_model_registry.errMsg(err)
-				}
-			});
-		}
-		return {
-			kind: "landed",
-			keyFrameMediaId
-		};
-	} catch (err) {
-		const error = require_clip_model_registry.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-composition.ts
-function summaryComposition(members) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const member of members) counts.set(member.className, (counts.get(member.className) ?? 0) + 1);
-	return { classes: [...counts].map(([className, count]) => ({
-		className,
-		count
-	})).toSorted((a, b) => a.count !== b.count ? b.count - a.count : (a.className ?? "").localeCompare(b.className ?? "")) };
-}
-//#endregion
-//#region src/pipeline-analytics/summary/summary-member-labels.ts
-function present(value) {
-	return typeof value === "string" && value.length > 0;
-}
-function withMemberLabels(members, tracks) {
-	const byId = new Map(tracks.map((t) => [t.trackId, t]));
-	return members.map((member) => {
-		const track = byId.get(member.trackId);
-		return {
-			...member,
-			className: member.className ?? (present(track?.className) ? track.className : null),
-			...present(track?.label) ? { label: track.label } : {},
-			...present(track?.subLabel) ? { subLabel: track.subLabel } : {}
-		};
-	});
-}
-//#endregion
-//#region src/pipeline-analytics/summary/summary-proximity.ts
-/**
-* The measured gap, in fractions of the frame's diagonal-free normalisation
-* (x by width, y by height). See the arithmetic above before moving it.
-*/
-var DEFAULT_TOGETHER_FRACTION = .15;
-/**
-* Distance between two points as a fraction of the frame, or `null` when the
-* frame is unknown. Each axis is normalised by its OWN dimension, so the answer
-* does not change when a camera's aspect does.
-*/
-function normalisedDistance(a, b, frame) {
-	if (!(frame.width > 0) || !(frame.height > 0)) return null;
-	const dx = (a.x - b.x) / frame.width;
-	const dy = (a.y - b.y) / frame.height;
-	return Math.sqrt(dx * dx + dy * dy);
-}
-//#endregion
-//#region src/pipeline-analytics/summary/summary-join.ts
-/**
-* Which open group a newborn track joins — or none, and it opens its own.
-*
-* ## Why this is a separate decision from the store
-*
-* The store knows rows; only the caller can see where subjects ARE. Keeping the
-* choice here means the store's `listOpen` + `absorbInto` stay a mechanism and
-* this stays the policy, which is what let the policy change without the store
-* changing underneath it.
-*
-* ## The two cases this exists for
-*
-* A summary used to be one per camera, so a subject at the far end of the drive
-* was absorbed into the group at the door — a group it was never part of — and
-* the halves of a group that split had nowhere to go. Both are the same need:
-* a summary is a GROUP, not a camera session.
-*
-* ## Nearest, not first
-*
-* When two groups are within reach the closest wins. `listOpen` orders by
-* `openedAt`, and which group opened first has nothing to do with who this
-* subject is walking with — taking the first would make the answer depend on
-* list order, which is the kind of tie-break that reads as random in a log.
-*
-* ## Knowing nothing is not a reason to take somebody in
-*
-* A group whose members have no position in RAM — one open across a restart —
-* is skipped rather than joined. Joining on absent evidence is exactly how a
-* far subject ends up in the wrong group, and nothing revisits that decision.
-*/
-/**
-* The id of the group to join, or `null` to open a new one.
-*
-* `null` on an unknown frame too: refusing is the recoverable direction, since
-* the subject then gets its own group, while a wrong join merges two strangers.
-*/
-function chooseGroupToJoin(subject, groups, frame, maxFraction) {
-	let bestId = null;
-	let bestDistance = Number.POSITIVE_INFINITY;
-	for (const g of groups) for (const m of g.memberPositions) {
-		const d = normalisedDistance(subject, m, frame);
-		if (d === null || d > maxFraction) continue;
-		if (d < bestDistance) {
-			bestDistance = d;
-			bestId = g.id;
-		}
-	}
-	return bestId;
-}
-//#endregion
-//#region src/pipeline-analytics/summary/summary-split.ts
-/**
-* A group that walked apart — who leaves, and who keeps the summary.
-*
-* ## The case
-*
-* Membership is decided ONCE, at birth, by proximity (D489). That answers "who
-* arrived together" and says nothing about what happens next: two people who
-* meet at the gate and then go separate ways stay one group until the camera
-* falls quiet, and the summary then claims they were together for the whole
-* session. The operator asked for this case by name alongside the concurrent
-* ones — "un gruppo che si divide" — and they are the same need, because the
-* halves of a split have to be able to BE groups.
-*
-* ## Single linkage, deliberately
-*
-* A family in single file is a chain: the last of them is nowhere near the
-* first, and requiring every pair to be close would tear the group apart the
-* moment it grew past two. So two members are together when a chain of
-* within-threshold hops connects them — the same "any, not all" rule
-* {@link isTogetherWith} uses at birth, applied to the whole set.
-*
-* ## What an absent position means
-*
-* Nothing. A member whose track has closed has no live position, and that is
-* not evidence it walked off — it is the ordinary end of a track. Unplaced
-* members are never candidates to leave; they stay with whoever keeps the
-* summary. Likewise an unknown frame yields a `null` distance, and a null is
-* not "far": it produces ONE cluster, never a split (D393).
-*
-* ## Which side keeps the row
-*
-* The primary's cluster, because the summary's identity and its group shot are
-* already the primary's. When the primary cannot be placed — its track closed —
-* the largest cluster keeps it instead; refusing to split there would freeze
-* every group the moment its primary left the frame, which is the common way
-* for a group to break up in the first place.
-*/
-/**
-* Members grouped by single-linkage proximity. One cluster when nothing can be
-* measured — an unknown frame is not a reason to tear a group in half.
-*/
-function clusterByProximity(members, frame, maxFraction) {
-	const parent = members.map((_, i) => i);
-	const find = (i) => {
-		let root = i;
-		while (parent[root] !== root) root = parent[root];
-		return root;
-	};
-	const union = (a, b) => {
-		const ra = find(a);
-		const rb = find(b);
-		if (ra !== rb) parent[rb] = ra;
-	};
-	let measured = false;
-	for (let i = 0; i < members.length; i++) for (let j = i + 1; j < members.length; j++) {
-		const d = normalisedDistance(members[i].position, members[j].position, frame);
-		if (d === null) continue;
-		measured = true;
-		if (d <= maxFraction) union(i, j);
-	}
-	if (!measured && members.length > 1) return [members.map((m) => m.trackId)];
-	const byRoot = /* @__PURE__ */ new Map();
-	for (let i = 0; i < members.length; i++) {
-		const root = find(i);
-		const bucket = byRoot.get(root);
-		const trackId = members[i].trackId;
-		if (bucket === void 0) byRoot.set(root, [trackId]);
-		else bucket.push(trackId);
-	}
-	return [...byRoot.values()];
-}
-/**
-* The departures, or `null` when the group is still whole.
-*
-* Order is the input's: the clusters come out in the order their first member
-* appears, so a caller logging a split reads the same order twice running.
-*/
-function planSplit(subject, frame, maxFraction) {
-	if (subject.placed.length < 2) return null;
-	const clusters = clusterByProximity(subject.placed, frame, maxFraction);
-	if (clusters.length < 2) return null;
-	const keeper = clusters.find((c) => subject.primaryTrackId !== null && c.includes(subject.primaryTrackId)) ?? largest(clusters);
-	return { departures: clusters.filter((c) => c !== keeper) };
-}
-/** The biggest cluster; ties go to the one that appeared first. */
-function largest(clusters) {
-	let best = clusters[0];
-	for (const c of clusters) if (c.length > best.length) best = c;
-	return best;
-}
-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: EVERY open group of a camera,
-	* with the members it has seen THIS process open. Fed only by this class's
-	* own writes, never the authority (D224): a fresh process answers an empty
-	* list 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.
-	*
-	* Keyed by summary id INSIDE the camera, because a camera holds as many
-	* groups as it has (D489). It was one entry per camera for one release, and
-	* that silently threw away the group shot of every group but the last to
-	* open — the frame path scored the newest group's members and no other.
-	*/
-	openMirror = /* @__PURE__ */ new Map();
-	/**
-	* When each open group was FIRST seen divided, by summary id. Cleared the
-	* moment it is whole again, so a separation has to hold without interruption
-	* — a group that oscillates never accumulates its window.
-	*
-	* RAM only, and deliberately: after a restart a group that is still apart
-	* simply waits {@link SPLIT_CONFIRM_MS} again. Persisting it would buy one
-	* earlier split and cost a column nothing else reads.
-	*/
-	apartSince = /* @__PURE__ */ new Map();
-	constructor(deps) {
-		this.deps = deps;
-	}
-	/** See {@link SUMMARY_GROUPS_ENABLED}; production never overrides it. */
-	get groupsEnabled() {
-		return this.deps.groupsEnabled ?? false;
-	}
-	/**
-	* The camera's open groups, oldest entry first. Empty when none is mirrored —
-	* which means "this process has opened none", not "the camera has none".
-	*/
-	openGroupsFor(deviceId) {
-		const groups = this.openMirror.get(deviceId);
-		if (groups === void 0) return [];
-		return [...groups].map(([id, members]) => ({
-			id,
-			members
-		}));
-	}
-	/**
-	* Join the open group this subject is walking WITH, or open its own.
-	*
-	* Falls back to the store's own policy (the camera's oldest open group)
-	* whenever the evidence is missing — no birth position, no frame size, no
-	* member positions. That fallback is today's behaviour, so an unknowable
-	* case degrades to what shipped rather than to nothing.
-	*/
-	async joinOrOpen(input, position) {
-		const frame = this.deps.frameSize(input.deviceId);
-		if (position === void 0 || frame === null) return await this.deps.summaries.openOrAbsorb(input);
-		const open = await this.deps.summaries.listOpen(input.deviceId);
-		if (open.length === 0) return await this.deps.summaries.openNew(input);
-		const groups = [];
-		for (const summary of open) {
-			const members = await this.deps.summaries.membersOf(summary.id);
-			const positions = await this.deps.latestPositions(members.map((m) => m.trackId));
-			groups.push({
-				id: summary.id,
-				memberPositions: [...positions.values()]
-			});
-		}
-		const chosenId = chooseGroupToJoin(position, groups, frame, this.deps.togetherFraction(input.deviceId));
-		const chosen = open.find((s) => s.id === chosenId);
-		if (chosen === void 0) {
-			this.deps.logger.debug("summary: nobody to walk with — opening a group", {
-				tags: { deviceId: input.deviceId },
-				meta: {
-					trackId: input.trackId,
-					openGroups: open.length
-				}
-			});
-			return await this.deps.summaries.openNew(input);
-		}
-		return await this.deps.summaries.absorbInto(chosen, input);
-	}
-	async onTrackOpened(input) {
-		if (!this.groupsEnabled) return;
-		try {
-			if (!isSummaryEligible(input.trackId, input.className)) {
-				this.deps.logger.debug("summary: track is not a group member — left standalone", {
-					tags: { deviceId: input.deviceId },
-					meta: {
-						trackId: input.trackId,
-						className: input.className ?? null
-					}
-				});
-				return;
-			}
-			const at = this.deps.now();
-			const open = {
-				deviceId: input.deviceId,
-				trackId: input.trackId,
-				at,
-				className: input.className
-			};
-			const row = await this.joinOrOpen(open, input.position);
-			this.rememberMember(input.deviceId, row.id, 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 mine = this.deps.analysedDeviceIds();
-			const open = [];
-			for (const deviceId of mine) open.push(...await this.deps.summaries.listOpen(deviceId));
-			for (const summary of open) {
-				const born = await this.splitIfApart(summary);
-				await this.sealIfDone(summary);
-				if (born !== null) await this.sealIfDone(born);
-			}
-		} catch (err) {
-			this.deps.logger.warn("summary sweep: could not list open summaries", { meta: { error: errMsg(err) } });
-		} finally {
-			this.sweepInFlight = false;
-		}
-	}
-	/**
-	* Split an open group whose members have walked apart and STAYED apart.
-	*
-	* Returns the last group born, so the sweep can consider it for sealing in
-	* the same pass — a group that divided as everybody left would otherwise sit
-	* open until the next tick with nothing alive in it.
-	*
-	* Every failure here is swallowed into a log: a split is an improvement to a
-	* record that is already correct about WHO was present, and losing it is
-	* never worth losing the seal that follows.
-	*/
-	async splitIfApart(summary) {
-		const { id: summaryId, deviceId } = summary;
-		try {
-			const frame = this.deps.frameSize(deviceId);
-			if (frame === null) {
-				this.apartSince.delete(summaryId);
-				return null;
-			}
-			const members = await this.deps.summaries.membersOf(summaryId);
-			if (members.length < 2) {
-				this.apartSince.delete(summaryId);
-				return null;
-			}
-			const positions = await this.deps.latestPositions(members.map((m) => m.trackId));
-			const placed = [];
-			for (const m of members) {
-				const position = positions.get(m.trackId);
-				if (position !== void 0) placed.push({
-					trackId: m.trackId,
-					position
-				});
-			}
-			const plan = planSplit({
-				placed,
-				primaryTrackId: members.find((m) => m.role === "primary")?.trackId ?? null
-			}, frame, this.deps.togetherFraction(deviceId));
-			if (plan === null) {
-				this.apartSince.delete(summaryId);
-				return null;
-			}
-			const firstSeen = this.apartSince.get(summaryId);
-			const now = this.deps.now();
-			if (firstSeen === void 0) {
-				this.apartSince.set(summaryId, now);
-				return null;
-			}
-			if (now - firstSeen < 0) return null;
-			let last = null;
-			let row = summary;
-			for (const departing of plan.departures) {
-				const born = await this.deps.summaries.splitOff(row, departing, now);
-				if (born === null) continue;
-				this.moveMirrorMembers(deviceId, summaryId, born.id, departing);
-				row = {
-					...row,
-					memberCount: row.memberCount - departing.length
-				};
-				last = born;
-			}
-			this.apartSince.delete(summaryId);
-			return last;
-		} catch (err) {
-			this.deps.logger.warn("summary: could not divide a group that walked apart", {
-				tags: { deviceId },
-				meta: {
-					summaryId,
-					error: errMsg(err)
-				}
-			});
-			return null;
-		}
-	}
-	/**
-	* Is this group finished?
-	*
-	* Both questions are about THIS group's members, not about the camera. A
-	* camera holds as many groups as it has (D489), so a camera-wide gate means
-	* no group seals until every subject on the camera has gone — and on a busy
-	* camera they never all go at once. Measured: eight summaries open on one
-	* camera over seventeen minutes, none sealed, each new subject opening a
-	* ninth because a group whose members have closed has no positions left for
-	* the proximity rule to judge.
-	*
-	* `null` means "could not find out", and the caller treats that as NOT done —
-	* a read that failed must never seal a live session (D49).
-	*/
-	async isGroupFinished(summary, members) {
-		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 null;
-		}
-		const stillOpen = new Set(openTracks);
-		if (members.some((m) => stillOpen.has(m))) return false;
-		let parked;
-		try {
-			parked = await this.deps.parkedTrackIds(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 null;
-		}
-		return !members.some((m) => parked.has(m));
-	}
-	async sealIfDone(summary) {
-		const { id: summaryId, deviceId } = summary;
-		let members;
-		try {
-			members = (await this.deps.summaries.membersOf(summaryId)).map((m) => m.trackId);
-		} catch (err) {
-			this.deps.logger.warn("summary sweep: could not read members — seal aborted this sweep", {
-				tags: { deviceId },
-				meta: {
-					summaryId,
-					error: errMsg(err)
-				}
-			});
-			return;
-		}
-		if (await this.isGroupFinished(summary, members) !== true) return;
-		const sealedAt = this.deps.now();
-		try {
-			if (await this.deps.summaries.seal(summary, sealedAt)) {
-				const members = this.forgetGroup(deviceId, summaryId);
-				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)
-				}
-			});
-		}
-	}
-	rememberMember(deviceId, summaryIdValue, trackId) {
-		let groups = this.openMirror.get(deviceId);
-		if (groups === void 0) {
-			groups = /* @__PURE__ */ new Map();
-			this.openMirror.set(deviceId, groups);
-		}
-		const members = groups.get(summaryIdValue);
-		if (members === void 0) groups.set(summaryIdValue, new Set([trackId]));
-		else members.add(trackId);
-	}
-	/** Follows a split in the mirror, so the frame path scores each half on its
-	*  own members from the very next frame. */
-	moveMirrorMembers(deviceId, fromId, toId, trackIds) {
-		const groups = this.openMirror.get(deviceId);
-		const from = groups?.get(fromId);
-		for (const trackId of trackIds) {
-			from?.delete(trackId);
-			this.rememberMember(deviceId, toId, trackId);
-		}
-		if (from !== void 0 && from.size === 0) groups?.delete(fromId);
-	}
-	/** Drops one group from the mirror and returns the members it held. */
-	forgetGroup(deviceId, summaryIdValue) {
-		this.apartSince.delete(summaryIdValue);
-		const groups = this.openMirror.get(deviceId);
-		const members = groups?.get(summaryIdValue) ?? /* @__PURE__ */ new Set();
-		groups?.delete(summaryIdValue);
-		if (groups !== void 0 && groups.size === 0) this.openMirror.delete(deviceId);
-		return members;
-	}
-};
-//#endregion
-//#region src/pipeline-analytics/summary-settings.ts
-/**
-* Per-device summary (group) settings. Cascade: a per-device override on top of
-* the global default, resolved per field — an invalid or missing value falls
-* back to its default and parsing never throws. Mirrors `stationary-settings` /
-* `media-settings`.
-*
-* The default IS the constant the proximity rule shipped with, imported and not
-* copied, so an unset value and a reset value both resolve to exactly today's
-* behaviour. It is per camera because a threshold belongs to whoever generates
-* the event: a gate camera framing three metres of path and a drive camera
-* framing twenty disagree about what "walking together" looks like in a
-* fraction of the frame, and the fleet measurement behind the default is a
-* median across both kinds.
-*/
-var SummarySettingsSchema = require_clip_model_registry.object({ 
-/**
-* How close two subjects must be to count as one group, as a fraction of the
-* frame. The floor is not zero: zero means "only at the identical pixel",
-* which ends grouping on that camera while looking like a tuning choice.
-* See `summary/summary-proximity.ts` for where the default came from.
-*/
-summaryTogetherFraction: require_clip_model_registry.number().min(.02).max(1).default(DEFAULT_TOGETHER_FRACTION) });
-var SUMMARY_DEFAULTS = { togetherFraction: SummarySettingsSchema.parse({}).summaryTogetherFraction };
-function resolveSummarySettings(raw) {
-	const parsed = SummarySettingsSchema.shape.summaryTogetherFraction.safeParse(raw["summaryTogetherFraction"]);
-	return { togetherFraction: parsed.success ? parsed.data : SUMMARY_DEFAULTS.togetherFraction };
-}
-//#endregion
 //#region src/pipeline-analytics/track-retention-sweep.ts
 /**
 * Sweep every device with persisted tracks: skip retention-disabled devices,
@@ -88382,8 +86690,6 @@ var TTL_SWEEP_INTERVAL_MS = 5e3;
 * the others) — a longer drain would be killed mid-way and log nothing.
 */
 var SENSOR_HANDLER_DRAIN_MS = 2700;
-/** Throttle for the group-shot gate's window line (D470). */
-var GROUP_SHOT_METRIC_INTERVAL_MS = 3e4;
 /**
 * How often the addon asks "is a gallery sample outside the cluster face
 * space?". A flip is rare and the check is two cheap reads — a minute keeps
@@ -88661,21 +86967,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	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 materialisation gate on every open summary's group shot (D359 phase 3, D470). RAM only. */
-	groupShots = new GroupShotTracker();
-	/** Throttle for the group-shot gate's window line (D470). */
-	lastGroupShotMetricAt = 0;
-	/**
-	* 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;
@@ -89197,11 +87488,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	*  the partition + promotion + sweep call sites — an operator change takes
 	*  effect within one SETTINGS_CACHE_TTL_MS tick without an addon restart. */
 	stationarySettingsCache = this.settingsCaches.registerDeviceCache("stationary", SETTINGS_CACHE_TTL_MS);
-	/** Per-device summary (group) settings — the proximity threshold. Read
-	*  SYNCHRONOUSLY by the sealer's birth and split paths, so it is warmed on
-	*  the frame path like the stationary one and a cold miss answers the
-	*  measured default. */
-	summarySettingsCache = this.settingsCaches.registerDeviceCache("summary", SETTINGS_CACHE_TTL_MS);
 	/** Per-device STILLNESS SCALE cache — the measured "how slow is settled" bar
 	*  (`stillness-settings.ts`). Read once per FrameProcessor build, so this is
 	*  a cold-path cache; it exists so a calibration applied through
@@ -89331,9 +87617,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	*  line/min/device instead of one per §5 cadence tick, see media-capture-log.ts). */
 	mediaCaptureLog = new MediaCaptureLogAggregator();
 	/** Per-device hit/miss window for the native `keyFrame` path (2026-08-06).
-	*  Before it there was NO metric here at all — `fetchNativeFullFrameTiered`
-	*  never touched `bumpCropMetric` — so whether a key-frame fix worked could
-	*  only be answered by hand-counting Loki lines. See `key-frame-metrics.ts`. */
+	*  Before it there was NO metric here at all — the by-handle key-frame fetch
+	*  in `runtime/native-frame-transport.ts` (retired by D422) never touched
+	*  `bumpCropMetric` — so whether a key-frame fix worked could only be
+	*  answered by hand-counting Loki lines. See `key-frame-metrics.ts`. */
 	keyFrameCaptureLog = new KeyFrameCaptureLog();
 	/** The registry's own liveness answer, mirrored off `ClusterTopologySnapshot`,
 	*  so a capture is never dispatched at a node the hub already called dead.
@@ -89467,12 +87754,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 	}
 	captureCrop = null;
-	/** Full NATIVE frame by handle (downscaled worker-side to `maxWidth`), routed
-	*  to the owning runner, PLUS the source `tier`. Captured in the async init
-	*  block so `persistKeyFrames` can fetch the native full frame for the
-	*  `keyFrame` + `keyFrameSmall` writes in the same live-frame window AND reject
-	*  a ≤640 RAM fallback (`tier: 'ram-fullframe'`). Null until init completes. */
-	getNativeKeyFrameRgb = null;
 	shuttingDown = false;
 	/**
 	* Sensor handlers the bus dispatched under `void` that have not finished.
@@ -89972,7 +88253,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			logger,
 			noteCropOutcome: (deviceId, reason) => this.failureReport.noteEnrichmentCrop(deviceId, reason)
 		});
-		this.getNativeKeyFrameRgb = transport.getNativeKeyFrameRgb;
 		this.parkedFrames = createParkedFrameClient({
 			api: api.pipelineRunner,
 			logger: logger.child("ParkedFrames"),
@@ -90309,7 +88589,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			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),
@@ -90617,49 +88896,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			store: api.settingsStore,
 			logger: logger.child("SensorEventStore")
 		});
-		this.summaryStore = new SummaryStore({
-			trackIdsMatching: async (terms) => await this.trackStore?.trackIdsMatching(terms) ?? [],
-			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,
-			analysedDeviceIds: () => [...this.lastFrameDimsByDevice.keys()],
-			openTrackIds: async (deviceId) => this.residents.trackIdsForDevice(deviceId),
-			parkedTrackIds: async (deviceId) => {
-				const ids = /* @__PURE__ */ new Set();
-				for (const entry of this.stationaryRegistry?.list(deviceId) ?? []) if (entry.sourceTrackId !== void 0) ids.add(entry.sourceTrackId);
-				return ids;
-			},
-			now: () => Date.now(),
-			logger: this.ctx.logger.child("summary-sealer"),
-			frameSize: (deviceId) => {
-				const d = this.lastFrameDimsByDevice.get(deviceId);
-				return d === void 0 ? null : {
-					width: d.w,
-					height: d.h
-				};
-			},
-			latestPositions: async (trackIds) => {
-				const out = /* @__PURE__ */ new Map();
-				for (const id of trackIds) {
-					const last = (this.trackStore?.peekActive(id))?.positions.at(-1);
-					if (last !== void 0) out.set(id, {
-						x: last.x,
-						y: last.y
-					});
-				}
-				return out;
-			},
-			togetherFraction: (deviceId) => this.summarySettingsFromCache(deviceId).togetherFraction,
-			onSealed: (summaryId, members) => {
-				this.groupShots.forget(summaryId);
-				for (const trackId of members) this.recognizedTrackIds.delete(trackId);
-			}
-		});
 		this.packageDropDetector = new PackageDropDetector({
 			events: eventStore,
 			emit: {
@@ -90859,7 +89095,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				score: face.matchScore ?? face.confidence,
 				confidence: face.confidence,
 				...face.frameHandle !== void 0 ? { frameHandle: face.frameHandle } : {}
-			}, face.identityId !== void 0 ? "identified" : "evidence"),
+			}),
 			onLiveHierarchy: (input) => this.requestTrackHierarchy(input),
 			faceSourceFrames: new FaceSourceFrameKeeper({
 				port: createFaceSourceParkPort({
@@ -91253,6 +89489,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					readExportBytes: (input) => api.recordingExport.readExportBytes.query(input),
 					deleteExport: (input) => api.recordingExport.deleteExport.mutate(input)
 				}, req),
+				deriveGifFromClip: (req) => deriveRecordedGif(buildRecordedGifPorts({
+					logger: logger.child("RecordedGif"),
+					resolveFfmpeg: () => this.ctx.deps.ensureFfmpeg()
+				}), req),
 				publishArtifact: async (bytes, mime, deviceId) => await this.ncArtifactPlane?.publish(bytes, mime, deviceId) ?? null,
 				viewerUrlBase: async () => pickArtifactBaseUrl(await this.ncEndpoints()),
 				indexArtifact: async (bytes, mime, meta) => await this.ncArtifactPlane?.publishIndexed(bytes, mime, meta) ?? {
@@ -91387,30 +89627,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					confirmed: t.observations !== void 0 && t.observations >= minHits
 				}));
 			},
-			listSummaryGroups: async ({ deviceId, sinceMs, untilMs }) => {
-				const summaryStore = this.summaryStore;
-				if (!summaryStore) return [];
-				const rows = await summaryStore.listRecent({
-					deviceIds: [deviceId],
-					since: sinceMs,
-					until: untilMs,
-					limit: 500
-				});
-				const out = [];
-				for (const row of rows) {
-					const members = await summaryStore.membersOf(row.id);
-					const files = await this.mediaStore?.listInfoByOwner("summary", row.id) ?? [];
-					const shot = files.find((f) => f.kind === "keyFrameSmall") ?? files.find((f) => f.kind === "keyFrame");
-					out.push({
-						summaryId: row.id,
-						deviceId: row.deviceId,
-						memberTrackIds: members.map((m) => m.trackId),
-						primaryTrackId: members.find((m) => m.role === "primary")?.trackId ?? null,
-						groupShotMediaId: shot?.mediaId ?? null
-					});
-				}
-				return out;
-			},
 			listMediaInfo: async (id) => {
 				return (await stores.mediaStore.listInfoByOwner("track", id)).map((r) => ({
 					mediaId: r.mediaId,
@@ -92834,7 +91050,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		if (planeRunsStationary(source) && this.stationaryRegistry) {
 			await this.resolveDeviceStationarySettings(deviceId);
 			await this.resolveDevicePackageDropSettings(deviceId);
-			await this.resolveDeviceSummarySettings(deviceId);
 		}
 		const processor = await this.getOrCreateProcessor(deviceId, source);
 		const proxy = await this.ensureProxy(deviceId);
@@ -93210,15 +91425,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					className: t.className
 				}
 			});
-			this.summarySealer?.onTrackOpened({
-				deviceId,
-				trackId: id,
-				className: t.className,
-				position: {
-					x: t.bbox.x + t.bbox.w / 2,
-					y: t.bbox.y + t.bbox.h / 2
-				}
-			});
 			const startPayload = buildTrackLifecyclePayload({
 				deviceId,
 				trackId: id,
@@ -93454,7 +91660,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			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, frameHandle);
-			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 = [];
@@ -94170,15 +92375,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	stationarySettingsFromCache(deviceId) {
 		return this.stationarySettingsCache.peek(deviceId) ?? STATIONARY_DEFAULTS;
 	}
-	/** Synchronous read of the per-device summary settings — warmed by
-	*  `processFrame`. A cold miss is today's constant, never a zero: a zero
-	*  threshold would quietly end grouping on that camera. */
-	summarySettingsFromCache(deviceId) {
-		return this.summarySettingsCache.peek(deviceId) ?? SUMMARY_DEFAULTS;
-	}
-	async resolveDeviceSummarySettings(deviceId) {
-		return this.summarySettingsCache.get(deviceId, (id) => this.readDeviceSettings(id, resolveSummarySettings));
-	}
 	/** Synchronous read of the per-device package-drop settings — warmed by
 	*  `processFrame` before the promotion loop, exactly like the stationary one. */
 	packageDropSettingsFromCache(deviceId) {
@@ -94262,12 +92458,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 							} } : {}
 						});
 					}
-					if (detailSemanticTrigger(d.className) === "recognition") this.promoteSemanticRecognition(semanticFrameForDetailAttribution(deviceId, trackId, d, frame), "identified");
+					if (detailSemanticTrigger(d.className) === "recognition") this.promoteSemanticRecognition(semanticFrameForDetailAttribution(deviceId, trackId, d, frame));
 				}
 				const resolved = d.className === "plate" ? this.plateRecognizer?.resolveLabelWithVehicle(d.label, d.score) ?? null : { text: d.label };
 				if (resolved !== null && resolved.text !== void 0) {
 					const applied = await this.applyTrackEnrichmentLabel(deviceId, trackId, resolved.text, d, frame.timestamp, resolved.vehicleId);
-					if (detailSemanticTrigger(d.className) === "label-write" && applied.trackWritten) this.promoteSemanticRecognition(semanticFrameForDetailAttribution(deviceId, trackId, d, frame), "identified");
+					if (detailSemanticTrigger(d.className) === "label-write" && applied.trackWritten) this.promoteSemanticRecognition(semanticFrameForDetailAttribution(deviceId, trackId, d, frame));
 				}
 			} else if (d.className === "plate") this.failureReport.notePlateRead(deviceId, d.bbox === void 0 ? REASON_NO_BBOX : REASON_EMPTY_READ);
 		} catch (err) {
@@ -94460,139 +92656,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 	}
 	/**
-	* Capture the CLEAN best full frame per given track at this best-detection
-	* moment and store BOTH variants (`putReplacing` → one row per track, per
-	* kind): the native `keyFrame` (full frame fetched at `KEYFRAME_NATIVE_MAX_WIDTH`
-	* — true native on a 4K cam) plus its 960 companion `keyFrameSmall`, encoded
-	* from the SAME native surface (no second fetch). No box is drawn — these are
-	* the clean hero images (`keyFrameSmall` is the web-friendly one).
-	*
-	* NATIVE-OR-NOTHING: a miss writes nothing (no upscale, no ≤640 stand-in) and
-	* the track's BOUNDED catch-up retry re-fires on a later frame. Until
-	* 2026-08-06 the only re-fire was the next genuine new-best PEAK, which for
-	* 80% of the tracks that missed never came — see `key-frame-retry.ts`. The
-	* `keyFrame` key is recorded on the track's resident state so the face /
-	* plate / object-embedding rows LINK the SAME native key frame (Design B).
-	* Issued in the live-frame window so the native lease is still held.
-	* Best-effort (D8) — a per-track failure is logged and never thrown.
-	*
-	* The capture BODY lives in `pipeline/key-frame-persist.ts`; what stays here
-	* 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) {
-		if (frameHandle === void 0) return;
-		const groups = this.summarySealer?.openGroupsFor(deviceId) ?? [];
-		for (const open of groups) this.offerGroupShotTo(deviceId, open, result, frameHandle);
-		if (groups.length > 0) this.logGroupShotWindow(deviceId);
-	}
-	/** One group's turn at the frame. Split out of {@link offerGroupShot} so the
-	*  scoring reads the members of the group it is about, and nothing else. */
-	offerGroupShotTo(deviceId, open, result, frameHandle) {
-		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)
-			}))
-		});
-		const frameRef = { timestamp: result.timestamp };
-		if (!this.groupShots.offer(open.id, score, frameRef)) 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,
-				cropFrame: async (frame, rect) => {
-					const out = await extractCropRaw(frame.data, frame.width, frame.height, {
-						x: rect.x / frame.width,
-						y: rect.y / frame.height,
-						w: rect.width / frame.width,
-						h: rect.height / frame.height
-					});
-					return {
-						...frame,
-						data: out.data,
-						width: out.width,
-						height: out.height
-					};
-				}
-			}, {
-				deviceId,
-				summaryId,
-				timestamp: result.timestamp,
-				frameHandle,
-				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH,
-				crop: score.crop,
-				cropFrameWidth: result.frameWidth,
-				cropFrameHeight: result.frameHeight
-			})
-		}).then((outcome) => {
-			if (outcome?.kind === "landed") {
-				this.groupShots.noteLanded(summaryId, score, frameRef);
-				this.ctx.logger.debug("summary group shot landed", {
-					tags: { deviceId },
-					meta: {
-						summaryId,
-						visible: score.visible,
-						quality: Number(score.quality.toFixed(3))
-					}
-				});
-			}
-		}).catch(() => {});
-	}
-	/**
-	* The group-shot gate's window, throttled to one line per
-	* {@link GROUP_SHOT_METRIC_INTERVAL_MS}. Process-global counts, tagged with
-	* the device that happened to close the window — the counters are the
-	* gate's, not the camera's, and the tag is there because every line about a
-	* device carries one.
-	*
-	* `materialised` is the number of 4096-px native full-frame fetches this
-	* path actually spent; `byGap` + `byMargin` + `byWorse` is what it did not.
-	*/
-	logGroupShotWindow(deviceId) {
-		const now = Date.now();
-		if (now - this.lastGroupShotMetricAt < GROUP_SHOT_METRIC_INTERVAL_MS) return;
-		this.lastGroupShotMetricAt = now;
-		const counts = this.groupShots.drainCounts();
-		if (counts.offered === 0) return;
-		this.ctx.logger.info("group shot window", {
-			tags: { deviceId },
-			meta: {
-				offered: counts.offered,
-				materialised: counts.materialised,
-				suppressedByGap: counts.byGap,
-				suppressedByMargin: counts.byMargin,
-				suppressedByWorse: counts.byWorse,
-				openSummaries: this.groupShots.size
-			}
-		});
-	}
-	/**
 	* Order the parcels a best-frame decision wants (D422). Skipped entirely at
 	* a node the registry already called offline (D58) — logged on the
 	* transition by `noteCapturesGated`, counted in the key-frame window.
@@ -94629,6 +92692,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			timestamp: parcel.timestamp
 		};
 	}
+	/**
+	* Store each given track's clean native `keyFrame` + `keyFrameSmall` from its
+	* PARKED parcel (D422) — never a by-handle fetch. The body is
+	* `pipeline/key-frame-persist.ts`; what stays here is the scheduling
+	* (coalescing, priority, budget) and the bookkeeping the retry gate reads.
+	* Best-effort (D8): a per-track failure is logged and never thrown.
+	*/
 	async persistKeyFrames(deviceId, timestamp, captures) {
 		const mediaStore = this.mediaStore;
 		if (this.parkedFrames === null || !mediaStore) return;
@@ -94796,8 +92866,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	*  when it wins and the frame's pixels are still reachable. Callers: the
 	*  FaceRecognizer's per-frame auto-match, and `routeDetailResults`' plate /
 	*  fine-classification attribution. */
-	promoteSemanticRecognition(input, origin) {
-		if (origin === "identified") this.recognizedTrackIds.add(input.trackId);
+	promoteSemanticRecognition(input) {
 		const ctx = this.ctxIfReady;
 		if (ctx === null) return;
 		promoteSemanticBestFrame({
@@ -95694,7 +93763,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
 		await this.trackCloser.sweep();
-		await this.summarySealer?.sweep();
 	}
 	/**
 	* The follow-recordings floor per camera, read from the ARCHIVE's hour ledger
@@ -95781,7 +93849,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			await this.runTrackRetentionSweep(deviceIds, now);
 			const eventStore = this.eventStore;
 			const sensorEventStore = this.sensorEventStore;
-			const summaryStore = this.summaryStore;
 			await sweepTracklessRoots({
 				deviceIds,
 				nowMs: now,
@@ -95791,16 +93858,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					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 + evicted.summaries;
+					const total = evicted.motion.length + evicted.audio.length + evicted.sensor;
 					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, ${evicted.summaries} summaries`
+						detail: `trackless age sweep (${cutoffs.effectiveMode}): ${evicted.motion.length} motion, ${evicted.audio.length} audio, ${evicted.sensor} sensor`
 					});
 					this.ctx.logger.info("analytics trackless event eviction (age sweep)", {
 						tags: { deviceId },
@@ -95808,7 +93874,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 							motion: evicted.motion.length,
 							audio: evicted.audio.length,
 							sensor: evicted.sensor,
-							summaries: evicted.summaries,
 							mode: cutoffs.effectiveMode,
 							cutoffMs: cutoffs.cutoffMs
 						}
@@ -96762,118 +94827,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async listRecentTracks(input) {
 		return this.queryFacade.listRecentTracks(input);
 	}
-	/** Newest first for a camera set; each row carries its group-shot media key. */
-	async listSummaries(input) {
-		const store = this.summaryStore;
-		if (!store) return { summaries: [] };
-		const rows = await store.listRecent({
-			deviceIds: input.deviceIds,
-			...input.since !== void 0 ? { since: input.since } : {},
-			...input.until !== void 0 ? { until: input.until } : {},
-			limit: input.limit ?? 50,
-			...input.classes !== void 0 ? { classes: input.classes } : {}
-		});
-		return { summaries: await this.listItemsFor(rows) };
-	}
-	/**
-	* Rows → what a LIST draws: the envelope plus the composition.
-	*
-	* Two bulk reads for the whole page, never per row: the members in one, their
-	* tracks (for the names) in one. The MEMBERS themselves stay off the list —
-	* a page of two hundred groups would otherwise carry a thousand records so
-	* the client could count them. `getSummary` is where the links live.
-	*/
-	async listItemsFor(rows) {
-		const store = this.summaryStore;
-		if (!store || rows.length === 0) return [];
-		const members = await store.membersOfMany(rows.map((r) => r.id));
-		return await Promise.all(rows.map(async (row) => ({
-			summary: await this.toSummary(row),
-			...summaryComposition(members.get(row.id) ?? [])
-		})));
-	}
-	/** The members of a page of summaries, with the labels a card can show —
-	*  in ONE read of the members and ONE of their tracks. */
-	async labelledMembersFor(rows) {
-		const out = /* @__PURE__ */ new Map();
-		const store = this.summaryStore;
-		if (!store || rows.length === 0) return out;
-		const membersBySummary = await store.membersOfMany(rows.map((r) => r.id));
-		const trackIds = [...new Set([...membersBySummary.values()].flatMap((ms) => ms.map((m) => m.trackId)))];
-		let tracks = [];
-		try {
-			tracks = await this.trackStore?.getPersistedByTrackIds(trackIds) ?? [];
-		} catch (err) {
-			this.ctx.logger.warn("summary members: labels unavailable for this page", { meta: {
-				summaries: rows.length,
-				members: trackIds.length,
-				error: require_clip_model_registry.errMsg(err)
-			} });
-		}
-		for (const row of rows) out.set(row.id, withMemberLabels(membersBySummary.get(row.id) ?? [], tracks));
-		return out;
-	}
-	/**
-	* Rows → the shape every summary surface answers with: the envelope, its
-	* members, and what a thumbnail can render for each of them.
-	*
-	* THREE reads for the whole page, never per row: the members in one, their
-	* tracks in one, and the group shots through `toSummary`. A read per member
-	* is what made a sixty-group page take twenty seconds on the events feed.
-	*/
-	/** ONE summary, with every member and the link each of them carries. */
-	async detailFor(row) {
-		const labelled = (await this.labelledMembersFor([row])).get(row.id) ?? [];
-		return {
-			summary: await this.toSummary(row),
-			members: labelled.map((m) => ({
-				trackId: m.trackId,
-				className: m.className,
-				role: m.role,
-				joinedAt: m.joinedAt,
-				...m.label !== void 0 ? { label: m.label } : {},
-				...m.subLabel !== void 0 ? { subLabel: m.subLabel } : {}
-			}))
-		};
-	}
-	async listRecentSummaries(input) {
-		const store = this.summaryStore;
-		if (!store) return {
-			summaries: [],
-			nextCursor: null
-		};
-		const page = await store.queryRecent({
-			deviceIds: input.deviceIds,
-			...input.since !== void 0 ? { since: input.since } : {},
-			...input.until !== void 0 ? { until: input.until } : {},
-			limit: input.limit,
-			...input.cursor !== void 0 ? { cursor: input.cursor } : {},
-			...input.classes !== void 0 ? { classes: input.classes } : {}
-		});
-		return {
-			summaries: await this.listItemsFor(page.summaries.map((d) => d.summary)),
-			nextCursor: page.nextCursor
-		};
-	}
-	async getSummary(input) {
-		const detail = await this.summaryStore?.get(input.id);
-		if (!detail) return null;
-		return await this.detailFor(detail.summary);
-	}
-	/** The row plus its group shot: the web companion when it landed, else the native key frame. */
-	async toSummary(row) {
-		const files = await this.mediaStore?.listInfoByOwner("summary", row.id) ?? [];
-		const shot = files.find((f) => f.kind === "keyFrameSmall") ?? files.find((f) => f.kind === "keyFrame");
-		return {
-			id: row.id,
-			deviceId: row.deviceId,
-			openedAt: row.openedAt,
-			lastActiveAt: row.lastActiveAt,
-			sealedAt: row.sealedAt,
-			memberCount: row.memberCount,
-			groupShotMediaId: shot?.mediaId ?? null
-		};
-	}
 	/**
 	* Every event kind the device can produce: built-ins (motion + audio), the
 	* detection classes its CONFIGURED pipeline can emit, and sensor kinds from
@@ -97657,11 +95610,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				},
 				liveTrackIds: (ids) => trackStore.existingTrackIds(ids),
 				liveEventIds: (table, ids) => eventStore.existingEventIdsIn(table, ids),
-				liveSummaryIds: (ids) => {
-					const summaries = this.summaryStore;
-					if (!summaries) throw new Error("summary store not built — probe unavailable");
-					return summaries.existingIds(ids);
-				},
 				keptMediaKeys: async (keys) => this.keptStationaryMediaKeys(keys),
 				reclaim: buildOrphanReclaimer({
 					deleteFace: async (faceId) => {
@@ -99350,8 +97298,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			mediaStore,
 			faceStore: this.faceStore,
 			plateStore: this.plateStore,
-			objectEmbeddingStore: this.objectEmbeddingStore,
-			summaryStore: this.summaryStore
+			objectEmbeddingStore: this.objectEmbeddingStore
 		};
 		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: {