@camstack/addon-post-analysis 1.2.115 → 1.2.117

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-C0uPGtBv.js");
+const require_dist = require("../dist-Dk-BdVHw.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -15139,28 +15139,38 @@ function selectSummaryTiles(candidates, opts) {
 	};
 }
 /**
+* Ranked leftover after the quota pass — refill a mosaic that dropped
+* duplicate frames or missing crops without walking the same track twice.
+*/
+function remainingSummaryCandidates(kept, taken, rank) {
+	const takenIds = new Set(taken.map((c) => c.trackId));
+	return kept.filter((c) => !takenIds.has(c.trackId)).toSorted(byRankDesc(rank));
+}
+/**
 * The media a tile is drawn from, best first.
 *
-* `groupCrop` heads the ladder: it is the group's own clean wide-central-square
-* over the union bbox, and a drawn rectangle is a permanent lie in a digest
-* tile. Singletons have no groupCrop and fall through to the member ladder.
-* `fullFrameBoxed` and `firstFrame` stay absent for the same reason.
+* First-level group crop only (`groupCrop`), then the group's native-frame
+* pointer, then a member's clean full frame. Member `thumbnail` / plate /
+* face crops stay off this ladder: a successful plate read overwrites the
+* vehicle first-level crop under the same `thumbnail` kind, and a digest
+* tile of a targa is the wrong picture. Boxed frames stay absent: a drawn
+* rectangle is a permanent lie in a digest tile. Duplicate driveways from
+* tracker ID churn are collapsed by `frameDedupeKey`, not by hiding the
+* full-frame fallback.
 */
 var SUMMARY_MEDIA_LADDER = [
 	"groupCrop",
-	"keyFrameSmall",
+	"nativeFrame",
 	"keyFrame",
-	"snapshot",
-	"fullFrame",
-	"thumbnailSmall",
-	"thumbnail"
+	"keyFrameSmall",
+	"fullFrame"
 ];
 /**
 * Pick ONE media row for a track — the cheap question first (index rows only),
 * so exactly one blob is ever read.
 *
-* Within a rung the row CLOSEST to the track's peak is chosen; `snapshot` is a
-* filmstrip and its rows accumulate, so "the first one" would systematically
+* Within a rung the row CLOSEST to the track's peak is chosen; a member may
+* carry more than one full-frame still, so "the first one" would systematically
 * pick the moment the subject entered rather than the moment it was best seen.
 */
 function pickSummaryMedia(rows, aroundMs) {
@@ -15171,6 +15181,13 @@ function pickSummaryMedia(rows, aroundMs) {
 	}
 	return null;
 }
+/**
+* Same camera, same wall-clock second → same JPEG. Tracker ID churn
+* otherwise fills a mosaic with eleven copies of one driveway still.
+*/
+function frameDedupeKey(deviceId, mediaTimestamp) {
+	return `${deviceId}:${Math.floor(mediaTimestamp / 1e3)}`;
+}
 //#endregion
 //#region src/notification-center/summary/summary-window.ts
 /**
@@ -15470,7 +15487,12 @@ var NcSummaryProducer = class {
 					droppedStationary: filtered.droppedStationary
 				};
 			}
-			const loaded = await this.loadTiles(rule, selection.tiles);
+			const loaded = await this.loadTiles({
+				rule,
+				preferred: selection.tiles,
+				refill: remainingSummaryCandidates(filtered.kept, selection.tiles, rule.rank),
+				maxTiles: rule.maxTiles
+			});
 			const detections = countDetections({ tracks: selection.tiles.map((t) => ({
 				firstSeen: t.firstSeen,
 				lastSeen: t.lastSeen,
@@ -15528,7 +15550,7 @@ var NcSummaryProducer = class {
 				tiles: loaded.length,
 				cameras: new Set(loaded.map((t) => t.candidate.deviceId)).size,
 				camerasDropped: selection.camerasDropped,
-				droppedNoMedia: selection.tiles.length - loaded.length,
+				droppedNoMedia: Math.max(0, rule.maxTiles - loaded.length),
 				mosaicBytes: mosaic.bytes,
 				mosaicPublished: mosaic.ref !== null,
 				enqueued,
@@ -15592,10 +15614,18 @@ var NcSummaryProducer = class {
 		}
 		return all;
 	}
-	/** One blob per tile — the cheap question (index rows) always first. */
-	async loadTiles(rule, tiles) {
+	/** One blob per tile — the cheap question (index rows) always first.
+	*  Duplicate camera-seconds are skipped so tracker ID churn cannot paint
+	*  the same driveway eleven times; leftover ranked candidates refill. */
+	async loadTiles(input) {
 		const out = [];
-		for (const candidate of tiles) {
+		const seenFrames = /* @__PURE__ */ new Set();
+		const seenIds = /* @__PURE__ */ new Set();
+		const queue = [...input.preferred, ...input.refill];
+		for (const candidate of queue) {
+			if (out.length >= input.maxTiles) break;
+			if (seenIds.has(candidate.trackId)) continue;
+			seenIds.add(candidate.trackId);
 			const tags = { deviceId: candidate.deviceId };
 			try {
 				const rows = await this.deps.listMediaInfo(candidate.trackId);
@@ -15604,25 +15634,38 @@ var NcSummaryProducer = class {
 					this.deps.logger.debug("summary tile dropped: the track carries no clean media", {
 						tags,
 						meta: {
-							ruleId: rule.id,
+							ruleId: input.rule.id,
 							trackId: candidate.trackId,
 							mediaRows: rows.length
 						}
 					});
 					continue;
 				}
+				const frameKey = frameDedupeKey(candidate.deviceId, picked.timestamp);
+				if (seenFrames.has(frameKey)) {
+					this.deps.logger.debug("summary tile dropped: same frame as an earlier tile", {
+						tags,
+						meta: {
+							ruleId: input.rule.id,
+							trackId: candidate.trackId,
+							frameKey
+						}
+					});
+					continue;
+				}
 				const jpeg = await this.deps.readMedia(picked.key);
 				if (jpeg === null || jpeg.byteLength === 0) {
 					this.deps.logger.debug("summary tile dropped: the media blob could not be read", {
 						tags,
 						meta: {
-							ruleId: rule.id,
+							ruleId: input.rule.id,
 							trackId: candidate.trackId,
 							mediaKey: picked.key
 						}
 					});
 					continue;
 				}
+				seenFrames.add(frameKey);
 				out.push({
 					candidate,
 					jpeg
@@ -15631,7 +15674,7 @@ var NcSummaryProducer = class {
 				this.deps.logger.warn("summary tile dropped: reading its media threw", {
 					tags,
 					meta: {
-						ruleId: rule.id,
+						ruleId: input.rule.id,
 						trackId: candidate.trackId,
 						error: String(err)
 					}
@@ -39894,8 +39937,9 @@ var OverlayDetailStateStore = class {
 *
 * See docs/superpowers/specs/2026-07-17-package-zones-design.md §3.3 +
 * docs/superpowers/specs/2026-07-17-detection-config-exposure-design.md
-* (surface C). Dwell default is 15s per operator decision (the design's
-* §3.3 draft said 45s).
+* (surface C). Confirmation is N frames (default 3); dwell default is 0
+* (an extra bar). The 15 s dwell plus a 5 s round-gap missed a real
+* parcel on device 615 (2026-08-24 13:40).
 */
 var PackageDropSettingsSchema = require_dist.object({
 	/**
@@ -39916,13 +39960,20 @@ var PackageDropSettingsSchema = require_dist.object({
 	*/
 	packageDropEnabled: require_dist.boolean().default(true),
 	/**
-	* Minimum OBSERVED dwell (seconds, since first-seen) before a newly
-	* promoted stationary package counts as a delivery. Kills a bag briefly
-	* set down and snatched back. Operator default 15s. Values beyond the
-	* stationary promotion window (30s) are satisfied only once the entry
-	* has actually been observed that long.
+	* Frames the box must be re-seen on before it is a parked package.
+	* Same bar as tracker `minHits`: one frame is a flicker, two can still
+	* be a passer-by's bag, three is "it stayed". A settle burst of three
+	* frames in ~1 s is enough; no second governor round after the courier
+	* left. Device 615 2026-08-24 13:40 expired at 1 round / 1.5 s dwell.
 	*/
-	packageDropDwellSec: require_dist.number().int().min(0).max(3600).default(15),
+	packageDropMinFrames: require_dist.number().int().min(1).max(20).default(3),
+	/**
+	* Extra OBSERVED dwell (seconds, since first-seen) on top of N frames.
+	* 0 (the default) means the frame count is enough — a courier who drops
+	* and leaves in 2 s still delivers. Raise this to reject a bag briefly
+	* set down and snatched back.
+	*/
+	packageDropDwellSec: require_dist.number().int().min(0).max(3600).default(0),
 	/** Reject tiny far-field blobs: min bbox area as a fraction of the frame. */
 	packageDropMinBboxAreaFrac: require_dist.number().min(0).max(1).default(.004),
 	/**
@@ -39940,13 +39991,15 @@ var PackageDropSettingsSchema = require_dist.object({
 	packageDropPickupEnabled: require_dist.boolean().default(true),
 	/**
 	* A parcel needs a deliverer: a stillness candidate only ever promotes to
-	* `delivered` if a non-package track (person/vehicle/animal) was active on
-	* the device within this many seconds BEFORE the box first appeared — and a
-	* departure only counts as `picked-up` with somebody around the
-	* disappearance. 0 disables both gates. Device 615's streetlight wedge
-	* cycled delivered→picked-up ~23×/night with nobody in frame, ever.
-	* Default 300 s: wide enough to absorb the motion-settle governor's cadence
-	* (the box is often first SEEN minutes after the courier left).
+	* `delivered` if a non-package track (person/vehicle/animal) was active IN
+	* A CONFIGURED PACKAGE DROP-OFF ZONE within this many seconds BEFORE the
+	* box first appeared — and a departure only counts as `picked-up` with
+	* somebody in that zone around the disappearance. Whole-camera motion (a
+	* walker at the far gate) does not count. 0 disables both gates. Device
+	* 615's streetlight wedge cycled delivered→picked-up ~23×/night with
+	* nobody in the drop-off zone. Default 300 s: wide enough to absorb the
+	* motion-settle governor's cadence (the box is often first SEEN minutes
+	* after the courier left).
 	*/
 	packageDropActivityWindowSec: require_dist.number().int().min(0).max(3600).default(300),
 	/**
@@ -39970,6 +40023,7 @@ function resolvePackageDropSettings(raw) {
 	};
 	return {
 		packageDropEnabled: pick("packageDropEnabled"),
+		packageDropMinFrames: pick("packageDropMinFrames"),
 		packageDropDwellSec: pick("packageDropDwellSec"),
 		packageDropMinBboxAreaFrac: pick("packageDropMinBboxAreaFrac"),
 		packageDropMaxBboxAreaFrac: pick("packageDropMaxBboxAreaFrac"),
@@ -40227,29 +40281,6 @@ var DeferredBirthRegistry = class {
 		this.byDevice.delete(deviceKey);
 	}
 };
-var AnalyticsGroupRecordSchema = require_dist.object({
-	id: require_dist.string(),
-	deviceId: require_dist.number().int(),
-	openedAt: require_dist.number().int(),
-	closedAt: require_dist.number().int(),
-	timestamp: require_dist.number().int(),
-	memberCount: require_dist.number().int(),
-	memberTrackIds: require_dist.array(require_dist.string()).readonly(),
-	className: require_dist.string(),
-	classes: require_dist.array(require_dist.string()).readonly(),
-	/** Relative event-media path, or null when the group has no picture yet. */
-	mediaUrl: require_dist.string().nullable(),
-	singleton: require_dist.boolean()
-});
-var AnalyticsGroupMemberSchema = require_dist.object({
-	trackId: require_dist.string(),
-	deviceId: require_dist.number().int(),
-	className: require_dist.string(),
-	firstSeen: require_dist.number().int(),
-	lastSeen: require_dist.number().int(),
-	mediaUrl: require_dist.string().nullable()
-});
-var AnalyticsGroupDetailSchema = AnalyticsGroupRecordSchema.extend({ members: require_dist.array(AnalyticsGroupMemberSchema).readonly() });
 var ListGroupsInputSchema = require_dist.object({
 	deviceId: require_dist.number().int().optional(),
 	sinceMs: require_dist.number().int().optional(),
@@ -40259,66 +40290,11 @@ var ListGroupsInputSchema = require_dist.object({
 });
 var groupActions = require_dist.defineCustomActions({
 	"analytics.listGroups": require_dist.customAction(ListGroupsInputSchema, require_dist.object({
-		groups: require_dist.array(AnalyticsGroupRecordSchema).readonly(),
+		groups: require_dist.array(require_dist.AnalyticsGroupRecordSchema).readonly(),
 		hasMore: require_dist.boolean()
 	})),
-	"analytics.getGroup": require_dist.customAction(require_dist.object({ groupId: require_dist.string().min(1) }), require_dist.object({ group: AnalyticsGroupDetailSchema.nullable() }))
+	"analytics.getGroup": require_dist.customAction(require_dist.object({ groupId: require_dist.string().min(1) }), require_dist.object({ group: require_dist.AnalyticsGroupDetailSchema.nullable() }))
 });
-//#endregion
-//#region src/pipeline-analytics/group/group-query.ts
-/**
-* Stamp a relative event-media URL.
-*
-* Media keys contain `:` and the data-plane serves them by key. Track ids are
-* bare and fall through to the existing event/track thumbnail resolver. Never
-* percent-encode: the handler does not URL-decode the path.
-*/
-function stampEventMediaUrl(baseUrl, id) {
-	if (baseUrl === null || baseUrl.length === 0) return null;
-	if (id === null || id === void 0 || id.length === 0) return null;
-	return `${baseUrl}/${id}`;
-}
-/** Union of every class on the members; `className` is the first, stable order. */
-function aggregateGroupClasses(tracks) {
-	const seen = /* @__PURE__ */ new Set();
-	const classes = [];
-	for (const track of tracks) for (const name of [track.className, ...track.classes ?? []]) {
-		if (name.length === 0 || seen.has(name)) continue;
-		seen.add(name);
-		classes.push(name);
-	}
-	return {
-		className: classes[0] ?? "unknown",
-		classes
-	};
-}
-function toGroupRecord(input) {
-	const { className, classes } = aggregateGroupClasses(input.tracks);
-	const mediaId = input.group.mediaKey ?? (input.group.memberCount === 1 ? input.memberTrackIds[0] : null);
-	return {
-		id: input.group.id,
-		deviceId: input.group.deviceId,
-		openedAt: input.group.openedAt,
-		closedAt: input.group.closedAt,
-		timestamp: input.group.timestamp,
-		memberCount: input.memberTrackIds.length > 0 ? input.memberTrackIds.length : input.group.memberCount,
-		memberTrackIds: [...input.memberTrackIds],
-		className,
-		classes: [...classes],
-		mediaUrl: stampEventMediaUrl(input.eventMediaBaseUrl, mediaId),
-		singleton: input.memberTrackIds.length <= 1
-	};
-}
-function toGroupMember(member, track, eventMediaBaseUrl) {
-	return {
-		trackId: member.trackId,
-		deviceId: member.deviceId,
-		className: track?.className ?? "unknown",
-		firstSeen: track?.firstSeen ?? member.timestamp,
-		lastSeen: track?.lastSeen ?? member.timestamp,
-		mediaUrl: stampEventMediaUrl(eventMediaBaseUrl, member.trackId)
-	};
-}
 function trackToLite(track) {
 	return {
 		trackId: track.trackId,
@@ -40328,116 +40304,43 @@ function trackToLite(track) {
 		lastSeen: track.lastSeen
 	};
 }
-async function listGroupRecords(ports, input) {
-	const page = await ports.groupStore.listRecent(input);
-	const groups = [];
-	for (const group of page.groups) groups.push(await buildGroupRecord(ports, group));
-	return {
-		groups,
-		hasMore: page.hasMore
-	};
-}
-async function getGroupDetail(ports, groupId) {
-	const group = await ports.groupStore.get(groupId);
-	if (group === null) return null;
-	const members = await ports.groupStore.listMembers(groupId);
-	const lites = [];
-	const rows = [];
-	for (const member of members) {
-		const track = await ports.loadTrack(member.trackId);
-		const lite = track === null ? null : trackToLite(track);
-		if (lite !== null) lites.push(lite);
-		rows.push(toGroupMember(member, lite, ports.eventMediaBaseUrl()));
-	}
-	return {
-		...toGroupRecord({
-			group,
-			memberTrackIds: members.map((m) => m.trackId),
-			tracks: lites,
-			eventMediaBaseUrl: ports.eventMediaBaseUrl()
-		}),
-		members: rows
-	};
-}
-async function buildGroupRecord(ports, group) {
-	const members = await ports.groupStore.listMembers(group.id);
-	const lites = [];
-	for (const member of members) {
-		const track = await ports.loadTrack(member.trackId);
-		if (track !== null) lites.push(trackToLite(track));
-	}
-	return toGroupRecord({
-		group,
-		memberTrackIds: members.map((m) => m.trackId),
-		tracks: lites,
-		eventMediaBaseUrl: ports.eventMediaBaseUrl()
+/**
+* Gallery and digest read the same ladder: groupCrop, then the native-frame
+* pointer, then a member's clean full frame. Plate / face / member
+* thumbnails never reach the picker — a plate read overwrites the vehicle
+* first-level crop under the same `thumbnail` kind. A multi with no crop
+* still has a picture if the sealer stored `nativeKey`.
+*/
+var DIGEST_MEMBER_FALLBACK_KINDS = new Set([
+	"keyFrame",
+	"keyFrameSmall",
+	"fullFrame"
+]);
+function digestMediaRows(input) {
+	const owned = [];
+	if (input.mediaKey !== null && input.mediaKey.length > 0) owned.push({
+		key: input.mediaKey,
+		kind: "groupCrop",
+		timestamp: input.timestamp
 	});
-}
-//#endregion
-//#region src/pipeline-analytics/group/group-crop.ts
-/** Always containSubject: true. Never the 0.5 delivered threshold. */
-function groupWideCentralSquareLayout(unionBbox, frame) {
-	return wideCentralSquareLayout(unionBbox, frame, { containSubject: true });
-}
-async function cropGroupFromRgb(rgb, frameWidth, frameHeight, unionBbox) {
-	const layout = groupWideCentralSquareLayout(unionBbox, {
-		W: frameWidth,
-		H: frameHeight
+	if (input.nativeKey !== null && input.nativeKey.length > 0) owned.push({
+		key: input.nativeKey,
+		kind: "nativeFrame",
+		timestamp: input.timestamp
 	});
-	const { crop: slab } = await extractCrop(rgb, frameWidth, frameHeight, layout.fetch);
-	return composeWideCentralSquareThumbnail(slab, layout);
+	if (owned.length > 0) return owned;
+	return input.memberRows.filter((row) => DIGEST_MEMBER_FALLBACK_KINDS.has(row.kind));
 }
 var MATCH_WINDOW_MS = 1e3;
 var MOVE_EPS = .35;
+/** Live-assigner window: same predicate, recent positions only. */
+var LIVE_WINDOW_MS = 3e3;
 /** Registry stationary is out; audio has no bbox and is never a member or a singleton. */
 function isEligibleMember(track) {
 	if (track.closedReason === "stationary-promotion") return false;
 	if (track.className === "audio") return false;
 	return true;
 }
-function temporallyOverlap(a, b, slackMs) {
-	return a.firstSeen <= b.lastSeen + slackMs && b.firstSeen <= a.lastSeen + slackMs;
-}
-/** Connected components of temporal overlap (+ slack) per camera. */
-function sessionsOf(tracks) {
-	const byDevice = /* @__PURE__ */ new Map();
-	for (const t of tracks) {
-		const list = byDevice.get(t.deviceId);
-		if (list) list.push(t);
-		else byDevice.set(t.deviceId, [t]);
-	}
-	const sessions = [];
-	for (const deviceTracks of byDevice.values()) {
-		const n = deviceTracks.length;
-		const parent = deviceTracks.map((_, i) => i);
-		const find = (i) => {
-			let cur = i;
-			while (parent[cur] !== cur) cur = parent[cur];
-			let walk = i;
-			while (parent[walk] !== cur) {
-				const next = parent[walk];
-				parent[walk] = cur;
-				walk = next;
-			}
-			return cur;
-		};
-		const union = (i, j) => {
-			const ri = find(i);
-			const rj = find(j);
-			if (ri !== rj) parent[ri] = rj;
-		};
-		for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) if (temporallyOverlap(deviceTracks[i], deviceTracks[j], 3e3)) union(i, j);
-		const buckets = /* @__PURE__ */ new Map();
-		for (let i = 0; i < n; i++) {
-			const root = find(i);
-			const bucket = buckets.get(root);
-			if (bucket) bucket.push(deviceTracks[i]);
-			else buckets.set(root, [deviceTracks[i]]);
-		}
-		sessions.push(...buckets.values());
-	}
-	return sessions;
-}
 function diag(bbox) {
 	return Math.hypot(bbox.w, bbox.h);
 }
@@ -40459,9 +40362,21 @@ function meanDiag(positions) {
 	for (const p of positions) sum += diag(p.bbox);
 	return sum / positions.length;
 }
-function netDisplacement(track) {
-	const first = track.positions[0];
-	const last = track.positions[track.positions.length - 1];
+function vecLen(v) {
+	return Math.hypot(v.x, v.y);
+}
+function cosine(a, b) {
+	const la = vecLen(a);
+	const lb = vecLen(b);
+	if (la === 0 || lb === 0) return 1;
+	return (a.x * b.x + a.y * b.y) / (la * lb);
+}
+function positionsInWindow(track, start, end) {
+	return track.positions.filter((p) => p.timestamp >= start && p.timestamp <= end);
+}
+function windowDisplacement(positions) {
+	const first = positions[0];
+	const last = positions[positions.length - 1];
 	if (!first || !last) return {
 		x: 0,
 		y: 0
@@ -40473,24 +40388,19 @@ function netDisplacement(track) {
 		y: b.y - a.y
 	};
 }
-function vecLen(v) {
-	return Math.hypot(v.x, v.y);
-}
-function cosine(a, b) {
-	const la = vecLen(a);
-	const lb = vecLen(b);
-	if (la === 0 || lb === 0) return 1;
-	return (a.x * b.x + a.y * b.y) / (la * lb);
-}
-function relativeMotion(track) {
-	const mean = meanDiag(track.positions);
+function windowRelativeMotion(positions) {
+	const mean = meanDiag(positions);
 	if (mean <= 0) return 0;
-	return vecLen(netDisplacement(track)) / mean;
+	return vecLen(windowDisplacement(positions)) / mean;
 }
-/** A ~ B iff cohesion ≥ 0.5 AND NOT (both move AND cos < 0.3). */
-function pairTogether(a, b) {
-	const overlapStart = Math.max(a.firstSeen, b.firstSeen);
-	const overlapEnd = Math.min(a.lastSeen, b.lastSeen);
+/**
+* Same cohesion + crossing veto as {@link pairTogether}, over `[now − 3 s, now]`.
+* Displacement/cosine use the window, not the whole track.
+*/
+function pairTogetherNow(a, b, now) {
+	const start = now - LIVE_WINDOW_MS;
+	const overlapStart = Math.max(a.firstSeen, b.firstSeen, start);
+	const overlapEnd = Math.min(a.lastSeen, b.lastSeen, now);
 	if (overlapEnd < overlapStart) return false;
 	let joint = 0;
 	let close = 0;
@@ -40507,55 +40417,245 @@ function pairTogether(a, b) {
 	}
 	if (joint === 0) return false;
 	if (close / joint < .5) return false;
-	const aMoves = relativeMotion(a) >= MOVE_EPS;
-	const bMoves = relativeMotion(b) >= MOVE_EPS;
-	if (aMoves && bMoves && cosine(netDisplacement(a), netDisplacement(b)) < .3) return false;
+	const wa = positionsInWindow(a, start, now);
+	const wb = positionsInWindow(b, start, now);
+	const aMoves = windowRelativeMotion(wa) >= MOVE_EPS;
+	const bMoves = windowRelativeMotion(wb) >= MOVE_EPS;
+	if (aMoves && bMoves && cosine(windowDisplacement(wa), windowDisplacement(wb)) < .3) return false;
 	return true;
 }
-function clusterGroups(tracks) {
-	const eligible = tracks.filter(isEligibleMember);
-	const out = [];
-	for (const session of sessionsOf(eligible)) {
-		const pairable = [];
-		for (const t of session) if (t.positions.length < 2) out.push({
-			deviceId: t.deviceId,
-			memberTrackIds: [t.trackId]
-		});
-		else pairable.push(t);
-		if (pairable.length === 0) continue;
-		const parent = pairable.map((_, i) => i);
-		const find = (i) => {
-			let cur = i;
-			while (parent[cur] !== cur) cur = parent[cur];
-			let walk = i;
-			while (parent[walk] !== cur) {
-				const next = parent[walk];
-				parent[walk] = cur;
-				walk = next;
-			}
-			return cur;
-		};
-		const union = (i, j) => {
-			const ri = find(i);
-			const rj = find(j);
-			if (ri !== rj) parent[ri] = rj;
-		};
-		for (let i = 0; i < pairable.length; i++) for (let j = i + 1; j < pairable.length; j++) if (pairTogether(pairable[i], pairable[j])) union(i, j);
-		const buckets = /* @__PURE__ */ new Map();
-		for (let i = 0; i < pairable.length; i++) {
-			const root = find(i);
-			const bucket = buckets.get(root);
-			const id = pairable[i].trackId;
-			if (bucket) bucket.push(id);
-			else buckets.set(root, [id]);
-		}
-		const deviceId = pairable[0].deviceId;
-		for (const memberTrackIds of buckets.values()) out.push({
-			deviceId,
-			memberTrackIds
+var GroupLiveAssigner = class {
+	nextId;
+	snapshots = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	membership = /* @__PURE__ */ new Map();
+	/** `${trackId}>${groupId}` → first instant the join predicate held. */
+	joinSince = /* @__PURE__ */ new Map();
+	/** trackId → first instant they failed pair against every remaining member. */
+	leaveSince = /* @__PURE__ */ new Map();
+	constructor(nextId = () => (0, node_crypto.randomUUID)()) {
+		this.nextId = nextId;
+	}
+	observe(track, now) {
+		this.snapshots.set(track.trackId, track);
+		if (!isEligibleMember(track)) {
+			this.removeFromGroup(track.trackId);
+			return;
+		}
+		if (!this.membership.has(track.trackId)) this.birthSingleton(track, now);
+		this.considerLeave(track, now);
+		const groupId = this.membership.get(track.trackId);
+		const group = groupId !== void 0 ? this.groups.get(groupId) : void 0;
+		if (group) for (const id of [...group.members]) {
+			if (id === track.trackId) continue;
+			const snap = this.snapshots.get(id);
+			if (snap) this.considerLeave(snap, now);
+		}
+		this.considerJoin(track, now);
+	}
+	groupOf(trackId) {
+		return this.membership.get(trackId);
+	}
+	snapshot(trackId) {
+		return this.snapshots.get(trackId);
+	}
+	liveGroups() {
+		return [...this.groups.values()].map((g) => this.toLive(g));
+	}
+	idleGroups(now, idleMs) {
+		return this.liveGroups().filter((g) => now >= g.lastActiveAt + idleMs);
+	}
+	drop(ids) {
+		for (const id of ids) {
+			const g = this.groups.get(id);
+			if (!g) continue;
+			for (const member of g.members) this.membership.delete(member);
+			this.groups.delete(id);
+		}
+	}
+	birthSingleton(track, now) {
+		const id = this.nextId();
+		this.groups.set(id, {
+			id,
+			deviceId: track.deviceId,
+			openedAt: now,
+			members: new Set([track.trackId])
 		});
+		this.membership.set(track.trackId, id);
 	}
-	return out;
+	considerLeave(track, now) {
+		const groupId = this.membership.get(track.trackId);
+		if (groupId === void 0) return;
+		const group = this.groups.get(groupId);
+		if (!group || group.members.size < 2) {
+			this.leaveSince.delete(track.trackId);
+			return;
+		}
+		if ([...group.members].filter((id) => id !== track.trackId).some((id) => {
+			const other = this.snapshots.get(id);
+			return other !== void 0 && pairTogetherNow(track, other, now);
+		})) {
+			this.leaveSince.delete(track.trackId);
+			return;
+		}
+		const since = this.leaveSince.get(track.trackId) ?? now;
+		this.leaveSince.set(track.trackId, since);
+		if (now - since < 3e3) return;
+		this.peel(track, now);
+	}
+	peel(track, now) {
+		this.removeFromGroup(track.trackId);
+		this.leaveSince.delete(track.trackId);
+		this.birthSingleton(track, now);
+	}
+	considerJoin(track, now) {
+		const mineId = this.membership.get(track.trackId);
+		if (mineId === void 0) return;
+		const mine = this.groups.get(mineId);
+		if (!mine || mine.members.size !== 1) {
+			this.clearJoinClocks(track.trackId);
+			return;
+		}
+		let best;
+		for (const group of this.groups.values()) {
+			if (group.id === mineId || group.deviceId !== track.deviceId) continue;
+			let gap = Number.POSITIVE_INFINITY;
+			let together = false;
+			for (const memberId of group.members) {
+				const other = this.snapshots.get(memberId);
+				if (!other) continue;
+				if (pairTogetherNow(track, other, now)) {
+					together = true;
+					gap = Math.min(gap, centroidGap(track, other, now));
+				}
+			}
+			if (!together) continue;
+			if (best === void 0 || gap < best.gap) best = {
+				groupId: group.id,
+				gap
+			};
+		}
+		if (best === void 0) {
+			this.clearJoinClocks(track.trackId);
+			return;
+		}
+		const key = `${track.trackId}>${best.groupId}`;
+		for (const existing of [...this.joinSince.keys()]) if (existing.startsWith(`${track.trackId}>`) && existing !== key) this.joinSince.delete(existing);
+		const since = this.joinSince.get(key) ?? now;
+		this.joinSince.set(key, since);
+		if (now - since < 1500) return;
+		this.absorb(track.trackId, mineId, best.groupId);
+	}
+	absorb(trackId, fromId, intoId) {
+		const into = this.groups.get(intoId);
+		if (!into) return;
+		into.members.add(trackId);
+		this.membership.set(trackId, intoId);
+		this.groups.delete(fromId);
+		this.clearJoinClocks(trackId);
+		this.leaveSince.delete(trackId);
+	}
+	removeFromGroup(trackId) {
+		const groupId = this.membership.get(trackId);
+		this.membership.delete(trackId);
+		this.clearJoinClocks(trackId);
+		this.leaveSince.delete(trackId);
+		if (groupId === void 0) return;
+		const group = this.groups.get(groupId);
+		if (!group) return;
+		group.members.delete(trackId);
+		if (group.members.size === 0) this.groups.delete(groupId);
+	}
+	clearJoinClocks(trackId) {
+		for (const key of [...this.joinSince.keys()]) if (key.startsWith(`${trackId}>`)) this.joinSince.delete(key);
+	}
+	toLive(group) {
+		let lastActiveAt = group.openedAt;
+		for (const id of group.members) {
+			const snap = this.snapshots.get(id);
+			if (snap && snap.lastSeen > lastActiveAt) lastActiveAt = snap.lastSeen;
+		}
+		return {
+			id: group.id,
+			deviceId: group.deviceId,
+			memberTrackIds: [...group.members],
+			openedAt: group.openedAt,
+			lastActiveAt
+		};
+	}
+};
+function centroidGap(a, b, now) {
+	const pa = a.positions.reduce((best, p) => Math.abs(p.timestamp - now) < Math.abs(best.timestamp - now) ? p : best, a.positions[0]);
+	const pb = b.positions.reduce((best, p) => Math.abs(p.timestamp - now) < Math.abs(best.timestamp - now) ? p : best, b.positions[0]);
+	if (!pa || !pb) return Number.POSITIVE_INFINITY;
+	const ca = bboxCentroid(pa.bbox);
+	const cb = bboxCentroid(pb.bbox);
+	return Math.hypot(ca.x - cb.x, ca.y - cb.y);
+}
+//#endregion
+//#region src/pipeline-analytics/group/group-session.ts
+/** Same idle as the notification burst (`NC_GROUP_DEFAULT_IDLE_SEC`). */
+var GROUP_SESSION_IDLE_MS = 3e4;
+//#endregion
+//#region src/pipeline-analytics/group/group-live-buffer.ts
+function toGroupableTrack(track) {
+	return {
+		trackId: track.trackId,
+		deviceId: track.deviceId,
+		className: track.className,
+		firstSeen: track.firstSeen,
+		lastSeen: track.lastSeen,
+		positions: track.positions.map((p) => ({
+			...p,
+			bbox: { ...p.bbox }
+		})),
+		...track.closedReason !== void 0 ? { closedReason: track.closedReason } : {}
+	};
+}
+var GroupLiveBuffer = class {
+	assigner;
+	primed = /* @__PURE__ */ new Set();
+	constructor(nextId) {
+		this.assigner = new GroupLiveAssigner(nextId);
+	}
+	observe(track, now) {
+		this.assigner.observe(track, now);
+	}
+	groupOf(trackId) {
+		return this.assigner.groupOf(trackId);
+	}
+	snapshot(trackId) {
+		return this.assigner.snapshot(trackId);
+	}
+	liveGroups() {
+		return this.assigner.liveGroups();
+	}
+	idleGroups(now, idleMs = GROUP_SESSION_IDLE_MS) {
+		return this.assigner.idleGroups(now, idleMs);
+	}
+	drop(ids) {
+		this.assigner.drop(ids);
+	}
+	isPrimed(deviceId) {
+		return this.primed.has(deviceId);
+	}
+	markPrimed(deviceId) {
+		this.primed.add(deviceId);
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/group/group-crop.ts
+/** Always containSubject: true. Never the 0.5 delivered threshold. */
+function groupWideCentralSquareLayout(unionBbox, frame) {
+	return wideCentralSquareLayout(unionBbox, frame, { containSubject: true });
+}
+async function cropGroupFromRgb(rgb, frameWidth, frameHeight, unionBbox) {
+	const layout = groupWideCentralSquareLayout(unionBbox, {
+		W: frameWidth,
+		H: frameHeight
+	});
+	const { crop: slab } = await extractCrop(rgb, frameWidth, frameHeight, layout.fetch);
+	return composeWideCentralSquareThumbnail(slab, layout);
 }
 //#endregion
 //#region src/pipeline-analytics/group/group-instant.ts
@@ -40572,6 +40672,7 @@ function clusterGroups(tracks) {
 *
 * Retrospective. No new capture path.
 */
+var GROUP_MEDIA_MATCH_MS = 2e3;
 function nearest(positions, t, windowMs) {
 	let best;
 	let bestDt = windowMs + 1;
@@ -40680,55 +40781,85 @@ function chooseAnchorTrackId(members, ownsCleanFrame) {
 		return life !== 0 ? life : a.trackId.localeCompare(b.trackId);
 	})[0].trackId;
 }
-//#endregion
-//#region src/pipeline-analytics/group/group-session.ts
 /**
-* Session close → sealed groups. A group is born here, never live.
+* The RGB source for a group crop is a full native frame. Thumbnails are
+* already single-subject crops and cannot substitute for union-bbox geometry.
 *
-* Session = temporal chain + 3 s slack, per camera. Close = every overlapping
-* track is persisted AND the newest lastSeen is older than the idle cutoff
-* (the Phase-1 burst's 30 s, reused — not a second clock).
-*
-* Merge and split cannot occur: connected components of a closed session is a
-* partition. Say it out loud so a later live-group attempt does not reach
-* for them here.
+* Prefer a keyFrame within {@link GROUP_MEDIA_MATCH_MS} of the chosen instant;
+* if none, take the nearest keyFrame anyway — dropping the crop because the
+* best-shot was 3 s off the instant is how a recognised person left the
+* digest with no crop.
 */
-/** Same idle as the notification burst (`NC_GROUP_DEFAULT_IDLE_SEC`). */
-var GROUP_SESSION_IDLE_MS = 3e4;
-function overlaps(a, b) {
-	return a.firstSeen <= b.lastSeen + 3e3 && b.firstSeen <= a.lastSeen + 3e3;
+function pickCleanPixelRow(rows, instantMs) {
+	const ranked = (maxDt) => {
+		const candidates = [];
+		for (const row of rows) {
+			const rank = row.kind === "keyFrame" ? 0 : row.kind === "keyFrameSmall" ? 1 : -1;
+			if (rank < 0) continue;
+			const dt = Math.abs(row.timestamp - instantMs);
+			if (maxDt !== null && dt > maxDt) continue;
+			candidates.push({
+				key: row.key,
+				dt,
+				rank
+			});
+		}
+		return candidates.toSorted((a, b) => a.rank - b.rank || a.dt - b.dt)[0];
+	};
+	const near = ranked(GROUP_MEDIA_MATCH_MS);
+	if (near !== void 0) return {
+		key: near.key,
+		usedFallback: false
+	};
+	const any = ranked(null);
+	if (any === void 0) return null;
+	return {
+		key: any.key,
+		usedFallback: true
+	};
 }
-function sessionSpan(tracks) {
+//#endregion
+//#region src/pipeline-analytics/group/group-live-replay.ts
+function sliceTrackAt(track, now) {
+	const positions = track.positions.filter((p) => p.timestamp <= now);
+	const last = positions[positions.length - 1];
 	return {
-		firstSeen: Math.min(...tracks.map((t) => t.firstSeen)),
-		lastSeen: Math.max(...tracks.map((t) => t.lastSeen))
+		...track,
+		lastSeen: last?.timestamp ?? track.firstSeen,
+		positions
 	};
 }
-/**
-* Sessions whose members are all in `closed` and whose newest lastSeen is
-* older than `idleMs`. An overlapping ACTIVE track keeps the session open.
-*/
-function sessionsReadyToSeal(closed, active, now, idleMs = GROUP_SESSION_IDLE_MS) {
-	const byDevice = /* @__PURE__ */ new Map();
-	for (const t of closed) {
-		const list = byDevice.get(t.deviceId);
-		if (list) list.push(t);
-		else byDevice.set(t.deviceId, [t]);
-	}
-	const ready = [];
-	for (const [deviceId, tracks] of byDevice) {
-		const deviceActive = active.filter((a) => a.deviceId === deviceId);
-		for (const session of sessionsOf(tracks)) {
-			const span = sessionSpan(session);
-			if (now < span.lastSeen + idleMs) continue;
-			if (deviceActive.some((a) => overlaps(span, a))) continue;
-			ready.push(session);
+function replayInto(tracks, observer) {
+	const events = [];
+	const byId = /* @__PURE__ */ new Map();
+	for (const track of tracks) {
+		byId.set(track.trackId, track);
+		if (track.positions.length === 0) {
+			events.push({
+				t: track.lastSeen,
+				trackId: track.trackId
+			});
+			continue;
 		}
+		for (const p of track.positions) events.push({
+			t: p.timestamp,
+			trackId: track.trackId
+		});
+	}
+	events.sort((a, b) => a.t - b.t || a.trackId.localeCompare(b.trackId));
+	let lastKey = "";
+	for (const e of events) {
+		const key = `${e.trackId}@${e.t}`;
+		if (key === lastKey) continue;
+		lastKey = key;
+		const track = byId.get(e.trackId);
+		if (!track) continue;
+		observer.observe(sliceTrackAt(track, e.t), e.t);
 	}
-	return ready;
 }
-function partitionsForSealedSessions(closed, active, now, idleMs = GROUP_SESSION_IDLE_MS) {
-	return clusterGroups(sessionsReadyToSeal(closed, active, now, idleMs).flat());
+function replayLive(tracks, assigner = new GroupLiveAssigner()) {
+	replayInto(tracks, assigner);
+	return assigner;
 }
 //#endregion
 //#region src/pipeline-analytics/group/group-sealer.ts
@@ -40736,9 +40867,9 @@ var DEFAULT_FRAME = {
 	width: 640,
 	height: 360
 };
-var SEAL_LOOKBACK_MS = 10 * 6e4;
-var BACKFILL_LOOKBACK_MS = 2880 * 6e4;
 var QUERY_LIMIT = 2e3;
+/** Crash recover: replay this camera only, on its next activity. */
+var GROUP_CRASH_LOOKBACK_MS = 2 * 6e4;
 function toInstant(t) {
 	return {
 		trackId: t.trackId,
@@ -40752,93 +40883,164 @@ function toInstant(t) {
 		confidence: t.importance
 	};
 }
+function memberBoxesAt(members, at, frame) {
+	const w = Math.max(frame.width, 1);
+	const h = Math.max(frame.height, 1);
+	const boxes = [];
+	for (const member of members) {
+		let best = member.positions[0];
+		let bestDt = Number.POSITIVE_INFINITY;
+		for (const p of member.positions) {
+			const dt = Math.abs(p.timestamp - at);
+			if (dt <= 1e3 && dt < bestDt) {
+				best = p;
+				bestDt = dt;
+			}
+		}
+		if (best === void 0 || bestDt === Number.POSITIVE_INFINITY) continue;
+		boxes.push({
+			bbox: {
+				x: best.bbox.x / w,
+				y: best.bbox.y / h,
+				w: best.bbox.w / w,
+				h: best.bbox.h / h
+			},
+			label: member.className,
+			observedAt: best.timestamp
+		});
+	}
+	return boxes;
+}
+function toSealer(track) {
+	return {
+		trackId: track.trackId,
+		deviceId: track.deviceId,
+		className: track.className,
+		firstSeen: track.firstSeen,
+		lastSeen: track.lastSeen,
+		positions: track.positions,
+		...track.closedReason !== void 0 ? { closedReason: track.closedReason } : {}
+	};
+}
 var GroupSealer = class {
 	deps;
 	constructor(deps) {
 		this.deps = deps;
 	}
-	async sealRecent() {
-		const now = this.deps.now();
-		return this.sealSince(now - SEAL_LOOKBACK_MS, now);
-	}
-	async backfill() {
-		const now = this.deps.now();
-		return this.sealSince(now - BACKFILL_LOOKBACK_MS, now);
+	get processEnabled() {
+		return this.deps.enabled ?? false;
 	}
-	async sealSince(since, now) {
+	async flushIdle(buffer, now = this.deps.now()) {
+		if (!this.processEnabled) return 0;
 		let written = 0;
-		let devices;
+		for (const group of buffer.idleGroups(now, GROUP_SESSION_IDLE_MS)) if (await this.persistLiveGroup(group, buffer)) {
+			buffer.drop([group.id]);
+			written += 1;
+		}
+		return written;
+	}
+	/**
+	* First activity on camera D after a crash: replay 2 minutes of that camera
+	* into the live buffer, persist whoever is already idle, keep the rest in RAM.
+	*/
+	async recoverCamera(deviceId, buffer) {
+		if (!this.processEnabled) return 0;
+		if (buffer.isPrimed(deviceId)) return 0;
+		const now = this.deps.now();
 		try {
-			devices = await this.deps.trackStore.listDeviceIds();
+			replayInto(await this.deps.trackStore.queryHistorical({
+				deviceId,
+				since: now - GROUP_CRASH_LOOKBACK_MS,
+				until: now,
+				limit: QUERY_LIMIT,
+				projection: "full"
+			}), buffer);
 		} catch (err) {
-			this.deps.logger.warn("group sealer: listDeviceIds failed", { meta: { error: String(err) } });
-			return 0;
+			this.deps.logger.warn("group sealer: lookback failed", {
+				tags: { deviceId },
+				meta: { error: String(err) }
+			});
+		} finally {
+			buffer.markPrimed(deviceId);
 		}
-		for (const deviceId of devices) try {
-			written += await this.sealDevice(deviceId, since, now);
+		return this.flushIdle(buffer, now);
+	}
+	/**
+	* Seal ONE camera over a caller-owned window via live replay.
+	*
+	* This is how a digest recovers groups without a boot scan: the producer
+	* already knows the window. Walking every camera for 48h at initialize()
+	* is what wedged hub-main.
+	*/
+	async sealWindow(deviceId, since, until) {
+		if (!this.processEnabled) return 0;
+		try {
+			const closed = await this.deps.trackStore.queryHistorical({
+				deviceId,
+				since,
+				until,
+				limit: QUERY_LIMIT,
+				projection: "full"
+			});
+			if (closed.length === 0) return 0;
+			const already = new Set((await this.deps.groupStore.membersOfTracks(closed.map((t) => t.trackId))).map((m) => m.trackId));
+			const pending = closed.filter((t) => !already.has(t.trackId));
+			if (pending.length === 0) return 0;
+			const assigner = replayLive(pending);
+			const now = this.deps.now();
+			const byId = new Map(pending.map((t) => [t.trackId, t]));
+			let written = 0;
+			for (const group of assigner.idleGroups(now, GROUP_SESSION_IDLE_MS)) {
+				const members = group.memberTrackIds.map((id) => byId.get(id)).filter((t) => t !== void 0);
+				if (members.length === 0) continue;
+				try {
+					await this.persistPartition(members, group.openedAt);
+					written += 1;
+				} catch (err) {
+					this.deps.logger.warn("group sealer: persist failed", {
+						tags: { deviceId },
+						meta: {
+							members: members.map((m) => m.trackId),
+							error: String(err)
+						}
+					});
+				}
+			}
+			return written;
 		} catch (err) {
 			this.deps.logger.warn("group sealer: device failed", {
 				tags: { deviceId },
 				meta: { error: String(err) }
 			});
+			return 0;
 		}
-		return written;
 	}
-	async sealDevice(deviceId, since, now) {
-		const closed = await this.deps.trackStore.queryHistorical({
-			deviceId,
-			since,
-			until: now,
-			limit: QUERY_LIMIT,
-			projection: "full"
-		});
-		if (closed.length === 0) return 0;
-		const already = new Set((await this.deps.groupStore.membersOfTracks(closed.map((t) => t.trackId))).map((m) => m.trackId));
-		const pending = closed.filter((t) => !already.has(t.trackId));
-		if (pending.length === 0) return 0;
-		const active = this.deps.trackStore.getActive(deviceId).map((t) => ({
-			deviceId,
-			firstSeen: t.firstSeen,
-			lastSeen: t.lastSeen
-		}));
-		const partitions = partitionsForSealedSessions(pending.map(toInstant), active, now, GROUP_SESSION_IDLE_MS);
-		if (partitions.length === 0) {
-			if (pending.filter((t) => t.closedReason !== "stationary-promotion" && t.className !== "audio").length === 0 && pending.length > 0) this.deps.logger.info("group session produced no groups", {
+	async persistLiveGroup(group, buffer) {
+		const deviceId = group.deviceId;
+		const snaps = group.memberTrackIds.map((id) => buffer.snapshot(id)).filter((t) => t !== void 0);
+		if (snaps.length === 0) return true;
+		const already = new Set((await this.deps.groupStore.membersOfTracks(snaps.map((t) => t.trackId))).map((m) => m.trackId));
+		const pending = snaps.filter((t) => !already.has(t.trackId)).map(toSealer);
+		if (pending.length === 0) return true;
+		try {
+			await this.persistPartition(pending, group.openedAt);
+			return true;
+		} catch (err) {
+			this.deps.logger.warn("group sealer: persist failed", {
 				tags: { deviceId },
 				meta: {
-					dropped: pending.length,
-					reason: "no-eligible-members"
+					members: pending.map((m) => m.trackId),
+					error: String(err)
 				}
 			});
-			return 0;
-		}
-		const byId = new Map(pending.map((t) => [t.trackId, t]));
-		let written = 0;
-		for (const part of partitions) {
-			const members = part.memberTrackIds.map((id) => byId.get(id)).filter((t) => t !== void 0);
-			if (members.length === 0) continue;
-			if (members.every((m) => already.has(m.trackId))) continue;
-			try {
-				await this.persistPartition(members);
-				written += 1;
-			} catch (err) {
-				this.deps.logger.warn("group sealer: persist failed", {
-					tags: { deviceId },
-					meta: {
-						members: members.map((m) => m.trackId),
-						error: String(err)
-					}
-				});
-			}
+			return false;
 		}
-		return written;
 	}
-	async persistPartition(members) {
+	async persistPartition(members, openedAt) {
 		const deviceId = members[0].deviceId;
 		const frame = this.deps.frameDims(deviceId) ?? DEFAULT_FRAME;
 		const instantMembers = members.map(toInstant);
 		const instant = chooseGroupInstant(instantMembers, frame);
-		const openedAt = Math.min(...members.map((m) => m.firstSeen));
 		const closedAt = Math.max(...members.map((m) => m.lastSeen));
 		const timestamp = instant?.timestamp ?? closedAt;
 		const mediaInfos = await Promise.all(members.map(async (m) => ({
@@ -40874,29 +41076,66 @@ var GroupSealer = class {
 			nativeKey
 		});
 		if (members.length < 2 || instant === null) return;
-		const source = await this.pickCleanPixels(mediaInfos, timestamp);
-		if (source === null) return;
+		const source = await this.pickCleanPixels(mediaInfos, timestamp, deviceId);
+		if (source === null) {
+			this.deps.logger.info("group sealer: no clean pixels for crop", {
+				tags: { deviceId },
+				meta: {
+					groupId: draft.id,
+					members: members.map((m) => m.trackId)
+				}
+			});
+			return;
+		}
 		try {
-			const raw = await (0, sharp.default)(source.jpeg).removeAlpha().raw().toBuffer({ resolveWithObject: true });
-			if (raw.info.channels !== 3) return;
-			const union = {
-				x: instant.ux * raw.info.width,
-				y: instant.uy * raw.info.height,
-				w: instant.uw * raw.info.width,
-				h: instant.uh * raw.info.height
-			};
-			const crop = await cropGroupFromRgb(raw.data, raw.info.width, raw.info.height, union);
-			const mediaKey = await this.deps.mediaStore.put({
+			const raw = await (0, sharp.default)(source.jpeg).removeAlpha().toColorspace("srgb").raw().toBuffer({ resolveWithObject: true });
+			if (raw.info.channels === 3) {
+				const union = {
+					x: instant.ux * raw.info.width,
+					y: instant.uy * raw.info.height,
+					w: instant.uw * raw.info.width,
+					h: instant.uh * raw.info.height
+				};
+				const crop = await cropGroupFromRgb(raw.data, raw.info.width, raw.info.height, union);
+				const mediaKey = await this.deps.mediaStore.put({
+					deviceId,
+					ownerKind: "group",
+					ownerId: draft.id,
+					kind: "thumbnail",
+					timestamp,
+					data: crop
+				});
+				await this.deps.groupStore.setMediaKey(draft.id, mediaKey);
+			}
+		} catch (err) {
+			this.deps.logger.warn("group sealer: crop failed", {
+				tags: { deviceId },
+				meta: {
+					groupId: draft.id,
+					error: String(err)
+				}
+			});
+		}
+		try {
+			const composed = await composeGroupFrame({
+				jpeg: source.jpeg,
+				boxes: memberBoxesAt(instantMembers, timestamp, frame),
+				at: timestamp,
+				logger: this.deps.logger,
+				deviceId,
+				groupKey: draft.id
+			});
+			if (composed === null) return;
+			await this.deps.mediaStore.put({
 				deviceId,
 				ownerKind: "group",
 				ownerId: draft.id,
-				kind: "thumbnail",
+				kind: "fullFrameBoxed",
 				timestamp,
-				data: crop
+				data: composed.bytes
 			});
-			await this.deps.groupStore.setMediaKey(draft.id, mediaKey);
 		} catch (err) {
-			this.deps.logger.warn("group sealer: crop failed", {
+			this.deps.logger.warn("group sealer: boxed frame failed", {
 				tags: { deviceId },
 				meta: {
 					groupId: draft.id,
@@ -40905,27 +41144,53 @@ var GroupSealer = class {
 			});
 		}
 	}
-	async pickCleanPixels(mediaInfos, instantMs) {
-		const candidates = [];
-		for (const info of mediaInfos) for (const row of info.rows) {
-			const rank = row.kind === "keyFrame" ? 0 : row.kind === "keyFrameSmall" ? 1 : -1;
-			if (rank < 0) continue;
-			const dt = Math.abs(row.timestamp - instantMs);
-			if (dt > 2e3) continue;
-			candidates.push({
-				key: row.key,
-				dt,
-				rank
-			});
-		}
-		const chosen = candidates.toSorted((a, b) => a.rank - b.rank || a.dt - b.dt)[0];
-		if (chosen === void 0) return null;
+	async pickCleanPixels(mediaInfos, instantMs, deviceId) {
+		const chosen = pickCleanPixelRow(mediaInfos.flatMap((info) => info.rows), instantMs);
+		if (chosen === null) return null;
+		if (chosen.usedFallback) this.deps.logger.info("group sealer: crop pixels not within 2s of instant, using nearest keyFrame", {
+			tags: { deviceId },
+			meta: {
+				instantMs,
+				mediaKey: chosen.key
+			}
+		});
 		const file = await this.deps.mediaStore.getByKey(chosen.key);
 		if (file === null) return null;
 		return { jpeg: Buffer.from(file.base64, "base64") };
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/group/group-cursor.ts
+function encodeGroupCursor(cursor) {
+	return Buffer.from(JSON.stringify({
+		c: cursor.closedAt,
+		i: cursor.groupId
+	}), "utf8").toString("base64url");
+}
+function decodeGroupCursor(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+	} catch {
+		throw new Error("listGroups: malformed cursor");
+	}
+	if (parsed === null || typeof parsed !== "object" || !("c" in parsed) || !("i" in parsed) || typeof parsed.c !== "number" || !Number.isFinite(parsed.c) || typeof parsed.i !== "string" || parsed.i.length === 0) throw new Error("listGroups: malformed cursor");
+	return {
+		closedAt: parsed.c,
+		groupId: parsed.i
+	};
+}
+function compareGroupDesc(a, b) {
+	if (a.closedAt !== b.closedAt) return b.closedAt - a.closedAt;
+	if (a.id === b.id) return 0;
+	return a.id < b.id ? 1 : -1;
+}
+/** True when `row` sits strictly AFTER the cursor in DESC order. */
+function isAfterGroupCursor(row, cursor) {
+	if (row.closedAt < cursor.closedAt) return true;
+	return row.closedAt === cursor.closedAt && row.id < cursor.groupId;
+}
+//#endregion
 //#region src/pipeline-analytics/group/group-store.ts
 /**
 * The group ENTITY store — a co-moving partition of one session, with one
@@ -40947,8 +41212,8 @@ var GroupSealer = class {
 */
 /**
 * @durable class=ledger owner=pipeline-analytics
-*   write="one row per co-moving group at session close — sealed, never live.
-*     Membership is a partition of one camera's eligible tracks. mediaKey is
+*   write="one row per co-moving group, sealed at idle — never a live row.
+*     Membership is the RAM members at persist, not a session partition. mediaKey is
 *     the group's own crop; nativeKey is a POINTER to the anchor member's
 *     keyFrame, nulled if that member is deleted alone. anchorTrackId and
 *     nativeKey are the only fields rewritten after birth."
@@ -41187,6 +41452,24 @@ var TrackGroupStore = class {
 			data: r.data
 		}));
 	}
+	/**
+	* Membership for a page of groups in ONE query. `listGroupRecords` used to
+	* call {@link listMembers} per row — 60 groups is 60 settings-store RPCs,
+	* ~20 s, and the viewer feed times out into a retry loop.
+	*/
+	async listMembersForGroups(groupIds) {
+		if (groupIds.length === 0) return [];
+		return (await this.store.query.query({
+			collection: TRACK_GROUP_MEMBERS_COLLECTION,
+			filter: {
+				whereIn: { groupId: [...groupIds] },
+				limit: 1e4
+			}
+		})).map((r) => this.normalizeMember({
+			id: r.id,
+			data: r.data
+		}));
+	}
 	async membersOfTracks(trackIds) {
 		const out = [];
 		for (const trackId of trackIds) {
@@ -41202,20 +41485,29 @@ var TrackGroupStore = class {
 		return out;
 	}
 	/**
-	* Newest-closed page for the Library Groups tab.
+	* Newest-closed page for the Groups feed.
 	*
 	* Time filter is overlap (`closedAt >= since` and `openedAt <= until`),
 	* same as {@link listOverlapping}. Pagination is applied AFTER the window
 	* so a day cursor is honest rather than a raw-row offset that skips live
-	* groups on a busy camera.
+	* groups on a busy camera. `deviceIds: []` is an empty page (same as
+	* `listRecentTracks`); omit the field for every camera. `deviceId` stays
+	* as the single-camera alias the custom-action bridge still sends.
 	*/
 	async listRecent(input) {
 		const limit = Math.min(Math.max(input.limit ?? 40, 1), 100);
 		const offset = Math.max(input.offset ?? 0, 0);
-		const slice = (await this.store.query.query({
+		const deviceIds = input.deviceIds !== void 0 ? input.deviceIds : input.deviceId !== void 0 ? [input.deviceId] : void 0;
+		if (deviceIds !== void 0 && deviceIds.length === 0) return {
+			groups: [],
+			hasMore: false,
+			nextCursor: null
+		};
+		const cursor = input.cursor !== void 0 && input.cursor.length > 0 ? decodeGroupCursor(input.cursor) : null;
+		const filtered = (await this.store.query.query({
 			collection: TRACK_GROUPS_COLLECTION,
 			filter: {
-				...input.deviceId !== void 0 ? { where: { deviceId: input.deviceId } } : {},
+				...deviceIds !== void 0 && deviceIds.length === 1 ? { where: { deviceId: deviceIds[0] } } : deviceIds !== void 0 ? { whereIn: { deviceId: [...deviceIds] } } : {},
 				orderBy: {
 					field: "closedAt",
 					direction: "desc"
@@ -41228,11 +41520,20 @@ var TrackGroupStore = class {
 		})).filter((g) => {
 			if (input.sinceMs !== void 0 && g.closedAt < input.sinceMs) return false;
 			if (input.untilMs !== void 0 && g.openedAt > input.untilMs) return false;
+			if (cursor !== null && !isAfterGroupCursor(g, cursor)) return false;
 			return true;
-		}).slice(offset, offset + limit + 1);
+		}).toSorted(compareGroupDesc);
+		const slice = (cursor !== null ? filtered : filtered.slice(offset)).slice(0, limit + 1);
+		const groups = slice.slice(0, limit);
+		const hasMore = slice.length > limit;
+		const last = groups[groups.length - 1];
 		return {
-			groups: slice.slice(0, limit),
-			hasMore: slice.length > limit
+			groups,
+			hasMore,
+			nextCursor: hasMore && last !== void 0 ? encodeGroupCursor({
+				closedAt: last.closedAt,
+				groupId: last.id
+			}) : null
 		};
 	}
 	/** Groups whose life overlaps `[since, until]` on one camera. */
@@ -42564,7 +42865,7 @@ function evaluateStationaryPromotion(input) {
 	};
 }
 var DEFAULT_PACKAGE_STILLNESS_CONFIG = {
-	minRounds: 2,
+	minHits: 3,
 	roundGapMs: 5e3,
 	ttlMs: 5 * 6e4,
 	assocIou: .3
@@ -42597,8 +42898,9 @@ var PackageStillnessTracker = class {
 			const prev = next[index];
 			if (prev === void 0) continue;
 			consumed.add(prev.id);
-			const updated = confirm(prev, input, s, this.config.roundGapMs);
-			if (!(updated.promotedAt === null && updated.activityBackedAtOpen && updated.rounds >= this.config.minRounds && input.timestamp - updated.firstSeenAt >= input.minDwellMs)) {
+			const updated = confirm(prev, input, s);
+			const minHits = input.minHits ?? this.config.minHits;
+			if (!(updated.promotedAt === null && updated.activityBackedAtOpen && updated.hits >= minHits && input.timestamp - updated.firstSeenAt >= input.minDwellMs)) {
 				next[index] = updated;
 				continue;
 			}
@@ -42622,7 +42924,7 @@ var PackageStillnessTracker = class {
 					id: c.id,
 					className: c.className,
 					bbox: { ...c.bbox },
-					rounds: c.rounds,
+					hits: c.hits,
 					firstSeenAt: c.firstSeenAt,
 					lastSeenAt: c.lastSeenAt,
 					activityBackedAtOpen: c.activityBackedAtOpen
@@ -42680,7 +42982,7 @@ var PackageStillnessTracker = class {
 			frameHeight: input.frameHeight,
 			firstSeenAt: input.timestamp,
 			lastSeenAt: input.timestamp,
-			rounds: 1,
+			hits: 1,
 			promotedAt: null,
 			activityBackedAtOpen,
 			...s.trackId !== void 0 ? { sourceTrackId: s.trackId } : {},
@@ -42690,18 +42992,16 @@ var PackageStillnessTracker = class {
 		};
 	}
 };
-/** Re-confirm a candidate with this frame's box. A new ROUND is only counted
-*  when the gap since the last sighting clears `roundGapMs`, so a burst of
-*  frames inside one governor round counts once. */
-function confirm(prev, input, s, roundGapMs) {
-	const newRound = input.timestamp - prev.lastSeenAt >= roundGapMs;
+/** Re-confirm a candidate with this frame's box. Every sighting is a hit —
+*  a settle burst of three frames in one second is three confirmations. */
+function confirm(prev, input, s) {
 	return {
 		...prev,
 		bbox: { ...s.bbox },
 		frameWidth: input.frameWidth,
 		frameHeight: input.frameHeight,
 		lastSeenAt: input.timestamp,
-		rounds: newRound ? prev.rounds + 1 : prev.rounds,
+		hits: prev.hits + 1,
 		...s.trackId !== void 0 ? { sourceTrackId: s.trackId } : {},
 		...s.label !== void 0 ? { label: s.label } : {},
 		...s.confidence !== void 0 ? { confidence: s.confidence } : {},
@@ -42726,6 +43026,31 @@ function toEntry(c) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/package/package-zone-activity.ts
+/**
+* Whether a live track is motion inside a configured package drop-off zone.
+*
+* The stillness activity gate used to stamp ANY non-package track on the
+* camera. A walker at the far gate then "delivered" the streetlight wedge
+* on the doormat. The operator's prerequisite is motion in the drop-off
+* zone the package rule points at — the same zones `PackageDropDetector`
+* uses for the centroid gate.
+*/
+function isDelivererInPackageZone(trackZones, packageZoneIds) {
+	if (packageZoneIds.size === 0 || trackZones.length === 0) return false;
+	for (const z of trackZones) if (packageZoneIds.has(z)) return true;
+	return false;
+}
+/** Zone ids referenced by enabled `package`-stage rules. Disabled rules do not count. */
+function collectPackageZoneIds(rules) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const r of rules) {
+		if (r.enabled === false) continue;
+		for (const z of r.zoneIds) ids.add(z);
+	}
+	return ids;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/stationary/stationary-zones.ts
 /**
 * Zone ids whose 0–1 polygon contains the entry's normalised bbox centroid.
@@ -49350,10 +49675,21 @@ var TrackStore = class {
 	* in-memory dedup (the query cap has no DISTINCT); best-effort.
 	*/
 	async listDeviceIds() {
+		return this.collectDeviceIds(0);
+	}
+	/**
+	* Distinct deviceIds with a persisted track whose `lastSeen` is at least
+	* `since`. The group sealer's 10-minute window. Walking from epoch 0 is how
+	* `sealRecent` wedged hub-main every TTL sweep.
+	*/
+	async listDeviceIdsSince(since) {
+		return this.collectDeviceIds(Math.max(0, Math.floor(since)));
+	}
+	async collectDeviceIds(fromLastSeen) {
 		const seenDevices = /* @__PURE__ */ new Set();
 		const seenIds = /* @__PURE__ */ new Set();
 		const PAGE = 500;
-		let cursor = 0;
+		let cursor = fromLastSeen;
 		try {
 			for (;;) {
 				const rows = await this.store.query.query({
@@ -49618,6 +49954,28 @@ var TrackStore = class {
 		return this.rowToTrack(row.id, row.data);
 	}
 	/**
+	* Batch read of persisted tracks. `listGroupRecords` cannot call
+	* {@link getPersistedByTrackId} per member — that is one settings-store RPC
+	* per row and a 60-group page takes ~20 s, which the viewer feed times out.
+	*/
+	async getPersistedByTrackIds(trackIds) {
+		if (trackIds.length === 0) return [];
+		const PAGE = 500;
+		const out = [];
+		for (let i = 0; i < trackIds.length; i += PAGE) {
+			const chunk = trackIds.slice(i, i + PAGE);
+			const rows = await this.store.query.query({
+				collection: TRACKS_COLLECTION,
+				filter: {
+					whereIn: { id: [...chunk] },
+					limit: chunk.length
+				}
+			});
+			for (const row of rows) out.push(this.rowToTrack(row.id, row.data));
+		}
+		return out;
+	}
+	/**
 	* Persist a SYNTHETIC track (a sensor/control event projected into the
 	* unified track store). Unlike `persistCompleted` there is no live in-RAM
 	* state and no trajectory envelope (synthetic tracks carry no positions) —
@@ -54690,11 +55048,22 @@ function buildGlobalSettingsSchema(cap) {
 					description: "Also emit a package-picked-up event when the delivered package leaves.",
 					default: PACKAGE_DROP_DEFAULTS.packageDropPickupEnabled
 				},
+				{
+					type: "slider",
+					key: "packageDropMinFrames",
+					label: "Confirmation frames",
+					description: "How many frames the box must be seen on before it counts as a delivery. One is a flicker; two can still be a passer-by; three is the default bar against false positives. Independent of dwell.",
+					min: 1,
+					max: 10,
+					step: 1,
+					default: PACKAGE_DROP_DEFAULTS.packageDropMinFrames,
+					showValue: true
+				},
 				{
 					type: "slider",
 					key: "packageDropDwellSec",
 					label: "Minimum dwell",
-					description: "How long a package must stay parked before it counts as a delivery. Higher = fewer false positives from bags briefly set down.",
+					description: "Extra time the package must stay parked after the confirmation frames. 0 (default) means N frames is enough — a courier who drops and leaves in a couple of seconds still delivers. Raise to reject a bag briefly set down.",
 					min: 0,
 					max: 300,
 					step: 5,
@@ -54728,7 +55097,7 @@ function buildGlobalSettingsSchema(cap) {
 					type: "slider",
 					key: "packageDropActivityWindowSec",
 					label: "Deliverer window",
-					description: "A delivery only counts if a person or vehicle was active on this camera within this many seconds before the package appeared — and a pick-up only with somebody around when it vanished. 0 disables the requirement.",
+					description: "A delivery only counts if a person or vehicle was in the configured package drop-off zone within this many seconds before the package appeared — and a pick-up only with somebody in that zone when it vanished. Motion elsewhere on the camera does not count. 0 disables the requirement.",
 					min: 0,
 					max: 1800,
 					step: 30,
@@ -56740,6 +57109,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	plateStore = null;
 	groupStore = null;
 	groupSealer = null;
+	groupLive = null;
+	/** Serialise first-activity lookback per camera, then observe in order. */
+	groupObserveTail = /* @__PURE__ */ new Map();
 	plateRecognizer = null;
 	objectEmbeddingStore = null;
 	/** Live state of the detached embedding rebuild — see `rebuildObjectEmbeddings`. */
@@ -57150,11 +57522,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*/
 	packageStillness = new PackageStillnessTracker({ newId: () => (0, node_crypto.randomUUID)() });
 	/**
-	* Frame-clock timestamp of the last NON-package track seen per device — the
-	* activity mirror behind the package activity gate ("a parcel needs a
-	* deliverer"). Deliberately not {@link lastTrackActivityMs}: that map is
-	* stamped by ANY live track, including the package-class FP itself, which
-	* would let the streetlight wedge vouch for its own delivery.
+	* Frame-clock timestamp of the last NON-package track seen IN A PACKAGE
+	* DROP-OFF ZONE per device — the activity mirror behind the package
+	* activity gate ("a parcel needs a deliverer"). A walker at the far gate
+	* does not stamp this. Deliberately not {@link lastTrackActivityMs}: that
+	* map is stamped by ANY live track, including the package-class FP itself,
+	* which would let the streetlight wedge vouch for its own delivery.
 	*/
 	lastNonPackageActivityAt = /* @__PURE__ */ new Map();
 	/** Last time the oversize-sighting drop was logged per device — one line
@@ -58064,6 +58437,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			media: mediaStore
 		});
 		this.groupStore = groupStore;
+		this.groupLive = new GroupLiveBuffer();
 		this.groupSealer = new GroupSealer({
 			trackStore,
 			groupStore,
@@ -58078,9 +58452,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			now: () => Date.now()
 		});
-		this.groupSealer.backfill().catch((err) => {
-			logger.warn("group sealer backfill failed", { meta: { error: require_dist.errMsg(err) } });
-		});
 		return {
 			trackStore,
 			mediaStore,
@@ -58523,12 +58894,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	buildSummaryPorts(stores) {
 		return {
 			listTracks: async ({ deviceId, sinceMs, untilMs, limit }) => {
-				const groups = await stores.groupStore.listOverlapping({
-					deviceId,
-					sinceMs,
-					untilMs,
-					limit
-				});
 				const windowTracks = await stores.trackStore.queryHistorical({
 					deviceId,
 					since: sinceMs,
@@ -58536,51 +58901,42 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					projection: "slim",
 					limit: Math.max(limit, 2e3)
 				});
-				const trackById = new Map(windowTracks.map((t) => [t.trackId, t]));
 				const { minHits } = await this.resolveDeviceDetectionSensitivitySettings(deviceId);
-				const out = [];
-				for (const group of groups) {
-					const members = await stores.groupStore.listMembers(group.id);
-					const tracks = members.map((m) => trackById.get(m.trackId)).filter((t) => t !== void 0);
-					if (tracks.length === 0) continue;
-					const classes = [...new Set(tracks.flatMap((t) => [t.className, ...t.classes ?? []]))];
-					const zones = [...new Set(tracks.flatMap((t) => [...t.zonesVisited]))];
-					const importance = Math.max(0, ...tracks.map((t) => t.importance ?? 0));
-					const primary = tracks.reduce((best, t) => (t.importance ?? 0) > (best.importance ?? 0) ? t : best);
-					out.push({
-						trackId: group.id,
-						groupId: group.id,
-						memberTrackIds: members.map((m) => m.trackId),
-						deviceId,
-						className: primary.className,
-						firstSeen: group.openedAt,
-						lastSeen: group.closedAt,
-						importance,
-						zones,
-						classes,
-						...tracks.every((t) => t.closedReason === "stationary-promotion") ? { stationary: true } : {},
-						confirmed: tracks.some((t) => t.observations !== void 0 && t.observations >= minHits)
-					});
-				}
-				return out;
+				return windowTracks.map((t) => ({
+					trackId: t.trackId,
+					deviceId,
+					className: t.className,
+					firstSeen: t.firstSeen,
+					lastSeen: t.lastSeen,
+					zones: [...t.zonesVisited],
+					...t.importance !== void 0 ? { importance: t.importance } : {},
+					...t.classes !== void 0 && t.classes.length > 0 ? { classes: t.classes } : {},
+					...t.closedReason === "stationary-promotion" ? { stationary: true } : {},
+					confirmed: t.observations !== void 0 && t.observations >= minHits
+				}));
 			},
 			listMediaInfo: async (id) => {
 				const group = await stores.groupStore.get(id);
-				if (group?.mediaKey) return [{
-					key: group.mediaKey,
-					kind: "groupCrop",
-					timestamp: group.timestamp
-				}];
-				if (group && group.memberCount === 1) {
-					const memberId = (await stores.groupStore.listMembers(group.id))[0]?.trackId;
-					if (!memberId) return [];
-					return (await stores.mediaStore.listInfoByOwner("track", memberId)).map((r) => ({
+				if (group) {
+					if (group.mediaKey || group.nativeKey) return digestMediaRows({
+						mediaKey: group.mediaKey,
+						nativeKey: group.nativeKey,
+						timestamp: group.timestamp,
+						memberRows: []
+					});
+					const members = await stores.groupStore.listMembers(group.id);
+					const memberRows = (await Promise.all(members.map((m) => stores.mediaStore.listInfoByOwner("track", m.trackId)))).flatMap((rows) => rows.map((r) => ({
 						key: r.key,
 						kind: r.kind,
 						timestamp: r.timestamp
-					}));
+					})));
+					return digestMediaRows({
+						mediaKey: group.mediaKey,
+						nativeKey: group.nativeKey,
+						timestamp: group.timestamp,
+						memberRows
+					});
 				}
-				if (group) return [];
 				return (await stores.mediaStore.listInfoByOwner("track", id)).map((r) => ({
 					key: r.key,
 					kind: r.kind,
@@ -59826,6 +60182,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				state: t.state
 			});
 			positionsCountById.set(t.trackId, upserted.positions.length);
+			this.enqueueLiveGroup(upserted, result.timestamp);
 		}
 		if (result.rawTrackedDetections.length > 0) {
 			const { minHits } = await this.resolveDeviceDetectionSensitivitySettings(deviceId);
@@ -60039,6 +60396,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			deviceId,
 			tracked: result.tracked,
 			packageClasses,
+			packageZoneIds: collectPackageZoneIds(proxy?.state.zoneRules.value?.package ?? []),
 			settings: packageSettings,
 			frameWidth: result.frameWidth,
 			frameHeight: result.frameHeight,
@@ -61749,8 +62107,11 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
 		await this.trackCloser.sweep();
-		this.groupSealer?.sealRecent();
+		if (this.isPostProcessingNode && this.groupLive) this.groupSealer?.flushIdle(this.groupLive);
 	}
+	/** Hub-only: assign this sighting in RAM. First activity on a camera
+	*  replays 2 minutes of that camera (crash recover), then observe is sync. */
+	enqueueLiveGroup(track, now) {}
 	/** Unified retention (Phase 1): earliest retained footage per device — the
 	*  follow-recordings cutoff source. Cached 10 min: availability answers in
 	*  ~70 ms but the sweep asks once per device per pass. `null` = no footage
@@ -62196,7 +62557,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	runPackageStillness(input) {
 		if (this.packageDropDetector === null) return;
 		const tags = { deviceId: input.deviceId };
-		for (const t of input.tracked) if (!input.packageClasses.has(t.className)) {
+		for (const t of input.tracked) {
+			if (input.packageClasses.has(t.className)) continue;
+			if (!isDelivererInPackageZone(t.zones, input.packageZoneIds)) continue;
 			this.lastNonPackageActivityAt.set(input.deviceId, input.timestamp);
 			break;
 		}
@@ -62243,6 +62606,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			frameWidth: input.frameWidth,
 			frameHeight: input.frameHeight,
 			timestamp: input.timestamp,
+			minHits: input.settings.packageDropMinFrames,
 			minDwellMs: input.settings.packageDropDwellSec * 1e3,
 			activityWindowMs: input.settings.packageDropActivityWindowSec * 1e3,
 			...lastActivityAt !== void 0 ? { lastActivityAt } : {}
@@ -62346,9 +62710,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		for (const ex of outcome.expired) {
 			const observedDwellMs = ex.lastSeenAt - ex.firstSeenAt;
 			const requiredDwellMs = input.settings.packageDropDwellSec * 1e3;
+			const requiredHits = input.settings.packageDropMinFrames;
 			const reasons = [];
 			if (!ex.activityBackedAtOpen) reasons.push("no-activity-before-open");
-			if (ex.rounds < 2) reasons.push("rounds");
+			if (ex.hits < requiredHits) reasons.push("hits");
 			if (observedDwellMs < requiredDwellMs) reasons.push("dwell");
 			this.ctx.logger.info("package candidate expired without promotion", {
 				tags,
@@ -62356,8 +62721,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					candidateId: ex.id,
 					className: ex.className,
 					bbox: ex.bbox,
-					rounds: ex.rounds,
-					minRounds: 2,
+					hits: ex.hits,
+					minHits: requiredHits,
 					observedDwellMs,
 					requiredDwellMs,
 					activityBackedAtOpen: ex.activityBackedAtOpen,
@@ -62394,6 +62759,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		};
 		if (plausible) this.stationaryRegistry?.promote(entry);
 		processor.dropTrack(track.trackId);
+		const peek = this.trackStore?.peekActive(track.trackId);
+		if (peek) this.enqueueLiveGroup(toGroupableTrack({
+			trackId: track.trackId,
+			deviceId,
+			className: track.className,
+			firstSeen: peek.firstSeen,
+			lastSeen: timestamp,
+			positions: peek.positions,
+			closedReason: "stationary-promotion"
+		}), timestamp);
 		this.trackStore?.closeActive(track.trackId, "stationary-promotion").catch((err) => {
 			this.ctx.logger.warn("stationary promotion: closing the source track failed — its media, events and vector are now unowned", {
 				tags: { deviceId },
@@ -62609,6 +62984,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async listRecentTracks(input) {
 		return this.queryFacade.listRecentTracks(input);
 	}
+	async listGroups(input) {
+		return {
+			groups: [],
+			nextCursor: null
+		};
+	}
+	async getGroup(input) {
+		return null;
+	}
 	/**
 	* Every event kind the device can produce: built-ins (motion + audio),
 	* detection classes actually observed on the device, and sensor kinds
@@ -63753,33 +64137,38 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	buildFaceRescoreActionHandlers() {
 		return { "face.rescoreTrack": (input) => this.rescoreFaceForTrack(input) };
 	}
-	buildGroupActionHandlers() {
-		const ports = () => {
-			const groupStore = this.groupStore;
-			if (groupStore === null) return null;
-			return {
-				groupStore,
-				loadTrack: async (trackId) => {
-					const tracks = this.trackStore;
-					if (!tracks) return null;
-					return tracks.getActiveByTrack(trackId) ?? await tracks.getPersistedByTrackId(trackId);
-				},
-				eventMediaBaseUrl: () => this.eventMediaBaseUrl
-			};
+	groupQueryPorts() {
+		const groupStore = this.groupStore;
+		if (groupStore === null) return null;
+		return {
+			groupStore,
+			loadTracks: async (trackIds) => {
+				const map = /* @__PURE__ */ new Map();
+				const tracks = this.trackStore;
+				if (!tracks || trackIds.length === 0) return map;
+				const missing = [];
+				for (const id of trackIds) {
+					const active = tracks.getActiveByTrack(id);
+					if (active !== null) map.set(id, trackToLite(active));
+					else missing.push(id);
+				}
+				if (missing.length === 0) return map;
+				for (const persisted of await tracks.getPersistedByTrackIds(missing)) map.set(persisted.trackId, trackToLite(persisted));
+				return map;
+			},
+			eventMediaBaseUrl: () => this.eventMediaBaseUrl
 		};
+	}
+	buildGroupActionHandlers() {
 		return {
 			"analytics.listGroups": async (input) => {
-				const ready = ports();
-				if (ready === null) return {
+				return {
 					groups: [],
 					hasMore: false
 				};
-				return listGroupRecords(ready, input);
 			},
 			"analytics.getGroup": async (input) => {
-				const ready = ports();
-				if (ready === null) return { group: null };
-				return { group: await getGroupDetail(ready, input.groupId) };
+				return { group: null };
 			}
 		};
 	}