@camstack/addon-post-analysis 1.2.159 → 1.2.160

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-CLxPUxVN.js");
+const require_dist = require("../dist-WrUmjaGQ.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -3082,8 +3082,8 @@ async function raceTimeout(call, timeoutMs) {
 * detail the encoder can see.
 */
 async function downscaleJpeg(bytes, maxPx) {
-	const { default: sharp$16 } = await import("sharp");
-	const out = await sharp$16(Buffer.from(bytes)).resize({
+	const { default: sharp$15 } = await import("sharp");
+	const out = await sharp$15(Buffer.from(bytes)).resize({
 		width: maxPx,
 		height: maxPx,
 		fit: "inside",
@@ -9982,8 +9982,8 @@ var NcDispatcher = class {
 		try {
 			const points = (await this.deps.getZonePolygons?.(deviceId, zoneIds) ?? []).flat();
 			if (points.length === 0) return null;
-			const { default: sharp$15 } = await import("sharp");
-			const img = sharp$15(Buffer.from(jpeg));
+			const { default: sharp$14 } = await import("sharp");
+			const img = sharp$14(Buffer.from(jpeg));
 			const meta = await img.metadata();
 			const W = meta.width ?? 0;
 			const H = meta.height ?? 0;
@@ -15697,10 +15697,9 @@ function remainingSummaryCandidates(kept, taken, rank) {
 /**
 * The media a tile is drawn from, best first.
 *
-* A digest tile is a SUBJECT, so the crops come first: the group's first-level
-* crop (`groupCrop`), the group's native-frame pointer, then the TRACK's own
-* subject crop (`thumbnail`, then its `thumbnailSmall` downscale), and only
-* then the clean whole scene (`keyFrame` → `keyFrameSmall` → `fullFrame`).
+* A digest tile is a SUBJECT, so the crops come first: the TRACK's own subject
+* crop (`thumbnail`, then its `thumbnailSmall` downscale), and only then the
+* clean whole scene (`keyFrame` → `keyFrameSmall` → `fullFrame`).
 *
 * ⚠ The whole-scene rungs are a FALLBACK and stay on the ladder. Measured on
 * 60 real tracks (615/617, 24 h): 52 carry a crop, 43 carry a scene rung, and
@@ -15708,19 +15707,19 @@ function remainingSummaryCandidates(kept, taken, rank) {
 * two tiles for nothing. A track with neither is dropped, never drawn as an
 * empty cell (see `NcSummaryProducer.loadTiles`).
 *
-* ## Why `thumbnail` is back (2026-08-27)
+* ## Why `thumbnail` is on the ladder (2026-08-27)
 *
 * It was removed on 2026-08-24 (160200681) because a successful plate read
 * overwrites the vehicle first-level crop under the same `thumbnail` kind.
-* **That collision belongs to the GROUP entity**: the sealer is what writes
-* `ownerKind: 'group', kind: 'thumbnail'` (`group/group-sealer.ts`), and the
-* group process is OFF (`GROUPS_PROCESS_ENABLED`, `group/group-enabled.ts`).
-* On a TRACK, plates live under `ownerKind: 'plate'` / `kind: 'plateCrop'` and
-* never touch `thumbnail`. The same commit turned the group process off, so
-* `groupCrop` and `nativeFrame` became unreachable and every digest tile fell
-* through to `keyFrame` — a whole frame — for three days.
-* `scripts/check-summary-ladder-reachable.ts` is the guard that refuses that
-* shape now.
+* **That collision belonged to the GROUP entity** — its sealer was what wrote
+* `ownerKind: 'group', kind: 'thumbnail'`. On a TRACK, plates live under
+* `ownerKind: 'plate'` / `kind: 'plateCrop'` and never touch `thumbnail`. The
+* same commit turned the group process off, so the two group-only head rungs
+* became unreachable and every digest tile fell through to `keyFrame` — a
+* whole frame — for three days. The group entity was deleted outright on
+* 2026-09-01 and its rungs went with it;
+* `scripts/check-summary-ladder-reachable.ts` is the guard that keeps the
+* best reachable rung a subject crop.
 *
 * Boxed frames stay absent: a drawn rectangle is a permanent lie in a digest
 * tile. Plate and face crops stay absent: a digest tile of a targa is the
@@ -15728,8 +15727,6 @@ function remainingSummaryCandidates(kept, taken, rank) {
 * `frameDedupeKey`, not by hiding the whole-scene fallback.
 */
 var SUMMARY_MEDIA_LADDER = [
-	"groupCrop",
-	"nativeFrame",
 	"thumbnail",
 	"thumbnailSmall",
 	"keyFrame",
@@ -15764,7 +15761,8 @@ var SUMMARY_SIZE_GATED_RUNGS = new Set(["thumbnail"]);
 * Is this row a picture, or a template wearing a picture's kind?
 *
 * Only a size the index REPORTED can demote a row. A `null` size is unknown,
-* and demoting on unknown would silently delete every group-owned pointer.
+* and demoting on unknown would silently delete every row an index could not
+* measure.
 */
 function rowClearsSizeFloor(row, rung) {
 	if (!SUMMARY_SIZE_GATED_RUNGS.has(rung)) return true;
@@ -17395,8 +17393,8 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 	];
 	if (bbox === void 0) return files;
 	try {
-		const { default: sharp$14 } = await import("sharp");
-		const meta = await sharp$14(Buffer.from(jpeg)).metadata();
+		const { default: sharp$13 } = await import("sharp");
+		const meta = await sharp$13(Buffer.from(jpeg)).metadata();
 		const W = meta.width ?? 0;
 		const H = meta.height ?? 0;
 		if (W === 0 || H === 0) return files;
@@ -17404,7 +17402,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		const top = Math.max(0, Math.min(H - 1, Math.floor(bbox.y * H)));
 		const width = Math.max(1, Math.min(W - left, Math.ceil(bbox.w * W)));
 		const height = Math.max(1, Math.min(H - top, Math.ceil(bbox.h * H)));
-		const cropBuf = await sharp$14(Buffer.from(jpeg)).extract({
+		const cropBuf = await sharp$13(Buffer.from(jpeg)).extract({
 			left,
 			top,
 			width,
@@ -17426,7 +17424,7 @@ async function deriveSyntheticMedia(jpeg, bbox, timestamp) {
 		});
 		const stroke = Math.max(2, Math.round(Math.min(W, H) / 240));
 		const overlay = Buffer.from(`<svg width="${W}" height="${H}"><rect x="${left}" y="${top}" width="${width}" height="${height}" fill="none" stroke="#22d3ee" stroke-width="${stroke}"/></svg>`);
-		const boxedBuf = await sharp$14(Buffer.from(jpeg)).composite([{
+		const boxedBuf = await sharp$13(Buffer.from(jpeg)).composite([{
 			input: overlay,
 			top: 0,
 			left: 0
@@ -25958,10 +25956,29 @@ var OWNER_KINDS = [
 	"identity",
 	"plate",
 	"vehicle",
-	"scene",
-	"group"
+	"scene"
 ];
 /**
+* Owner kinds that NOTHING may write any more, but whose rows can still be on
+* disk from before the owning code was deleted.
+*
+* `'group'` is the co-moving group entity, removed on 2026-09-01 together with
+* `pipeline-analytics:track-groups` / `:track-group-members`
+* ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)).
+* The tables are dropped at boot from `RETIRED_COLLECTIONS`, so a group-owned
+* media row can never be claimed again: `resolveMediaOwner` maps it to
+* `{ kind: 'retired-owner' }` and the orphan audit reclaims it under the same
+* grace window and ceilings as any other orphan.
+*
+* 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"];
+/** Is this an owner kind whose owning code is gone? See {@link RETIRED_OWNER_KINDS}. */
+function isRetiredMediaOwnerKind(value) {
+	return RETIRED_OWNER_KINDS.includes(value);
+}
+/**
 * Narrow an arbitrary string to an `OwnerKind`.
 *
 * Exists so a caller that builds owner scopes from data (the training-export
@@ -27091,10 +27108,6 @@ var MediaStore = class {
 	async deleteForTracks(trackIds) {
 		return this.deleteForOwner("track", trackIds);
 	}
-	/** Delete the group's OWN crop. The native frame is a pointer and is not here. */
-	async deleteByGroups(groupIds) {
-		return this.deleteForOwnerCounted("group", groupIds);
-	}
 	/**
 	* `TrackScopedStore` contract for the retention cascade: delete all media
 	* owned by the given tracks — the tracks' OWN media (`ownerKind:'track'`) plus
@@ -33963,7 +33976,6 @@ var EMPTY_CASCADE_TALLY = {
 	faces: 0,
 	plates: 0,
 	embeddings: 0,
-	groups: 0,
 	bytesReclaimed: 0
 };
 /** Fold a leaf store's receipts into a running tally. */
@@ -34007,13 +34019,6 @@ function addLeafCounts(tally, counts) {
 					bytesReclaimed
 				};
 				break;
-			case "groups":
-				next = {
-					...next,
-					groups: next.groups + c.rows,
-					bytesReclaimed
-				};
-				break;
 		}
 	}
 	return next;
@@ -34027,7 +34032,6 @@ function mergeCascadeTallies(a, b) {
 		faces: a.faces + b.faces,
 		plates: a.plates + b.plates,
 		embeddings: a.embeddings + b.embeddings,
-		groups: a.groups + b.groups,
 		bytesReclaimed: a.bytesReclaimed + b.bytesReclaimed
 	};
 }
@@ -34090,7 +34094,6 @@ function absentCascadeLegs(stores) {
 	if (!stores.faceStore) absent.push("faces");
 	if (!stores.plateStore) absent.push("plates");
 	if (!stores.objectEmbeddingStore) absent.push("embeddings");
-	if (!stores.groupStore) absent.push("groups");
 	return absent;
 }
 function buildAnalyticsCascadeRegistry(stores) {
@@ -34098,7 +34101,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.groupStore) registry.push(stores.groupStore);
 	return registry;
 }
 /**
@@ -47843,1420 +47845,6 @@ function shouldAutoReembed(samples, targetModelId, knownPixelless, passRunning)
 	if (passRunning || targetModelId === null || targetModelId === "") return false;
 	return samples.some((s) => s.modelId !== targetModelId && s.mediaKey !== void 0 && !knownPixelless.has(s.sampleId));
 }
-var ListGroupsInputSchema = require_dist.object({
-	deviceId: require_dist.number().int().optional(),
-	sinceMs: require_dist.number().int().optional(),
-	untilMs: require_dist.number().int().optional(),
-	limit: require_dist.number().int().min(1).max(100).optional(),
-	offset: require_dist.number().int().min(0).optional()
-});
-var groupActions = require_dist.defineCustomActions({
-	"analytics.listGroups": require_dist.customAction(ListGroupsInputSchema, require_dist.object({
-		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: require_dist.AnalyticsGroupDetailSchema.nullable() }))
-});
-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 diag(bbox) {
-	return Math.hypot(bbox.w, bbox.h);
-}
-function nearestPosition(positions, t) {
-	let best;
-	let bestDt = 1001;
-	for (const p of positions) {
-		const dt = Math.abs(p.timestamp - t);
-		if (dt <= 1e3 && dt < bestDt) {
-			best = p;
-			bestDt = dt;
-		}
-	}
-	return best;
-}
-function meanDiag(positions) {
-	if (positions.length === 0) return 0;
-	let sum = 0;
-	for (const p of positions) sum += diag(p.bbox);
-	return sum / positions.length;
-}
-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
-	};
-	const a = bboxCentroid(first.bbox);
-	const b = bboxCentroid(last.bbox);
-	return {
-		x: b.x - a.x,
-		y: b.y - a.y
-	};
-}
-function windowRelativeMotion(positions) {
-	const mean = meanDiag(positions);
-	if (mean <= 0) return 0;
-	return vecLen(windowDisplacement(positions)) / mean;
-}
-/**
-* 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;
-	for (let t = overlapStart; t <= overlapEnd; t += 500) {
-		const pa = nearestPosition(a.positions, t);
-		const pb = nearestPosition(b.positions, t);
-		if (!pa || !pb) continue;
-		joint++;
-		const ca = bboxCentroid(pa.bbox);
-		const cb = bboxCentroid(pb.bbox);
-		const gap = Math.hypot(ca.x - cb.x, ca.y - cb.y);
-		const scale = (diag(pa.bbox) + diag(pb.bbox)) / 2;
-		if ((scale > 0 ? gap / scale : Number.POSITIVE_INFINITY) <= 1.5) close++;
-	}
-	if (joint === 0) return false;
-	if (close / joint < .5) 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;
-}
-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);
-	}
-	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);
-	}
-};
-function trackToLite(track) {
-	return {
-		trackId: track.trackId,
-		className: track.className,
-		classes: track.classes,
-		firstSeen: track.firstSeen,
-		lastSeen: track.lastSeen
-	};
-}
-/**
-* 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,
-		sizeBytes: null
-	});
-	if (input.nativeKey !== null && input.nativeKey.length > 0) owned.push({
-		key: input.nativeKey,
-		kind: "nativeFrame",
-		timestamp: input.timestamp,
-		sizeBytes: null
-	});
-	if (owned.length > 0) return owned;
-	return input.memberRows.filter((row) => DIGEST_MEMBER_FALLBACK_KINDS.has(row.kind));
-}
-//#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
-/**
-* Chosen instant + union bbox for a group, at close, over stored positions[]
-* (`docs/design/2026-08-21-group-entity-and-group-media.md` §4.1).
-*
-* Tier order — the first that separates two candidates decides:
-*   1. completeness (members with a position within ±1 s)
-*   2. square containment of the union (D212)
-*   3. semantic (a member's confirmed recognition)
-*   4. edge-clear (union touches no frame border)
-*   5. effective score = mean(confidence) × containment × sizeFactor
-*
-* Retrospective. No new capture path.
-*/
-var GROUP_MEDIA_MATCH_MS = 2e3;
-function nearest(positions, t, windowMs) {
-	let best;
-	let bestDt = windowMs + 1;
-	for (const p of positions) {
-		const dt = Math.abs(p.timestamp - t);
-		if (dt <= windowMs && dt < bestDt) {
-			best = p;
-			bestDt = dt;
-		}
-	}
-	return best;
-}
-function unionOf(boxes) {
-	if (boxes.length === 0) return null;
-	let x0 = Infinity;
-	let y0 = Infinity;
-	let x1 = -Infinity;
-	let y1 = -Infinity;
-	for (const b of boxes) {
-		x0 = Math.min(x0, b.x);
-		y0 = Math.min(y0, b.y);
-		x1 = Math.max(x1, b.x + b.w);
-		y1 = Math.max(y1, b.y + b.h);
-	}
-	return {
-		x: x0,
-		y: y0,
-		w: x1 - x0,
-		h: y1 - y0
-	};
-}
-function touchesBorder(box, frame, tol = 1) {
-	return box.x <= tol || box.y <= tol || box.x + box.w >= frame.width - tol || box.y + box.h >= frame.height - tol;
-}
-function scoreInstant(members, t, frame) {
-	const boxes = [];
-	let semantic = false;
-	let confSum = 0;
-	let confN = 0;
-	for (const m of members) {
-		const p = nearest(m.positions, t, MATCH_WINDOW_MS);
-		if (!p) continue;
-		boxes.push(p.bbox);
-		if (m.semantic === true) semantic = true;
-		if (m.confidence !== void 0) {
-			confSum += m.confidence;
-			confN += 1;
-		}
-	}
-	const union = unionOf(boxes);
-	if (!union) return null;
-	const square = centralSquareContainmentFraction(union, {
-		W: frame.width,
-		H: frame.height
-	});
-	const containment = bboxContainment(union, frame.width, frame.height);
-	const size = bboxSizeScore(union, frame.width, frame.height);
-	const meanConf = confN > 0 ? confSum / confN : 1;
-	return {
-		timestamp: t,
-		union,
-		visibleCount: boxes.length,
-		square,
-		semantic,
-		edgeClear: !touchesBorder(union, frame),
-		effective: meanConf * containment * size
-	};
-}
-function better(a, b) {
-	if (a.visibleCount !== b.visibleCount) return a.visibleCount > b.visibleCount ? a : b;
-	if (a.square !== b.square) return a.square > b.square ? a : b;
-	if (a.semantic !== b.semantic) return a.semantic ? a : b;
-	if (a.edgeClear !== b.edgeClear) return a.edgeClear ? a : b;
-	if (a.effective !== b.effective) return a.effective > b.effective ? a : b;
-	return a.timestamp <= b.timestamp ? a : b;
-}
-function chooseGroupInstant(members, frame) {
-	if (members.length === 0) return null;
-	const candidates = /* @__PURE__ */ new Set();
-	for (const m of members) for (const p of m.positions) candidates.add(p.timestamp);
-	let best = null;
-	for (const t of candidates) {
-		const scored = scoreInstant(members, t, frame);
-		if (!scored) continue;
-		best = best === null ? scored : better(scored, best);
-	}
-	if (!best) return null;
-	const w = Math.max(frame.width, 1);
-	const h = Math.max(frame.height, 1);
-	return {
-		timestamp: best.timestamp,
-		union: best.union,
-		ux: best.union.x / w,
-		uy: best.union.y / h,
-		uw: best.union.w / w,
-		uh: best.union.h / h,
-		visibleCount: best.visibleCount
-	};
-}
-/** Longest-lived member that owns a clean full frame; ties break on trackId. */
-function chooseAnchorTrackId(members, ownsCleanFrame) {
-	const eligible = members.filter((m) => ownsCleanFrame(m.trackId));
-	if (eligible.length === 0) return null;
-	return eligible.toSorted((a, b) => {
-		const life = b.lastSeen - b.firstSeen - (a.lastSeen - a.firstSeen);
-		return life !== 0 ? life : a.trackId.localeCompare(b.trackId);
-	})[0].trackId;
-}
-/**
-* 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.
-*
-* 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.
-*/
-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
-	};
-}
-//#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 {
-		...track,
-		lastSeen: last?.timestamp ?? track.firstSeen,
-		positions
-	};
-}
-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);
-	}
-}
-function replayLive(tracks, assigner = new GroupLiveAssigner()) {
-	replayInto(tracks, assigner);
-	return assigner;
-}
-//#endregion
-//#region src/pipeline-analytics/group/group-sealer.ts
-var DEFAULT_FRAME = {
-	width: 640,
-	height: 360
-};
-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,
-		deviceId: t.deviceId,
-		className: t.className,
-		firstSeen: t.firstSeen,
-		lastSeen: t.lastSeen,
-		positions: t.positions,
-		...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {},
-		semantic: t.hasFace === true || t.hasPlate === true,
-		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;
-	}
-	get processEnabled() {
-		return this.deps.enabled ?? false;
-	}
-	async flushIdle(buffer, now = this.deps.now()) {
-		if (!this.processEnabled) return 0;
-		let written = 0;
-		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 {
-			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: lookback failed", {
-				tags: { deviceId },
-				meta: { error: String(err) }
-			});
-		} finally {
-			buffer.markPrimed(deviceId);
-		}
-		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;
-		}
-	}
-	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: {
-					members: pending.map((m) => m.trackId),
-					error: String(err)
-				}
-			});
-			return false;
-		}
-	}
-	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 closedAt = Math.max(...members.map((m) => m.lastSeen));
-		const timestamp = instant?.timestamp ?? closedAt;
-		const mediaInfos = await Promise.all(members.map(async (m) => ({
-			trackId: m.trackId,
-			rows: await this.deps.mediaStore.listInfoByOwner("track", m.trackId)
-		})));
-		const ownsClean = (trackId) => {
-			return mediaInfos.find((m) => m.trackId === trackId)?.rows.some((r) => r.kind === "keyFrame" || r.kind === "keyFrameSmall") ?? false;
-		};
-		const anchorTrackId = members.length >= 2 ? chooseAnchorTrackId(instantMembers, ownsClean) : null;
-		let nativeKey = null;
-		if (anchorTrackId !== null) {
-			const rows = mediaInfos.find((m) => m.trackId === anchorTrackId)?.rows ?? [];
-			nativeKey = (rows.find((r) => r.kind === "keyFrame") ?? rows.find((r) => r.kind === "keyFrameSmall"))?.key ?? null;
-		}
-		const draft = await this.deps.groupStore.insert({
-			deviceId,
-			timestamp,
-			openedAt,
-			closedAt,
-			members: members.map((m) => ({
-				trackId: m.trackId,
-				firstSeen: m.firstSeen
-			})),
-			anchorTrackId,
-			ux: instant?.ux ?? 0,
-			uy: instant?.uy ?? 0,
-			uw: instant?.uw ?? 0,
-			uh: instant?.uh ?? 0,
-			frameWidth: frame.width,
-			frameHeight: frame.height,
-			mediaKey: null,
-			nativeKey
-		});
-		if (members.length < 2 || instant === 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().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: "fullFrameBoxed",
-				timestamp,
-				data: composed.bytes
-			});
-		} catch (err) {
-			this.deps.logger.warn("group sealer: boxed frame failed", {
-				tags: { deviceId },
-				meta: {
-					groupId: draft.id,
-					error: String(err)
-				}
-			});
-		}
-	}
-	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
-* picture of its own (`docs/design/2026-08-21-group-entity-and-group-media.md`).
-*
-* Two tables, two questions:
-*
-* - `pipeline-analytics:track-groups` is the group row. It has N members and
-*   no `trackId` column; it is owned by its members (owner-indirection).
-* - `pipeline-analytics:track-group-members` is one row per member. The column
-*   is named exactly `trackId` so the classification derives `track-owned`.
-*
-* `anchorTrackId` and `nativeKey` are the only fields mutable after birth:
-* they are nulled when the anchor member is deleted alone. Everything else is
-* written once. Re-anchoring is deliberately not done.
-*
-* No age clock. A group dies when its last member does; a group with one live
-* member does not, and it never keeps a dead link.
-*/
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   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."
-*   retention="NO age clock (D61). Rows leave with their last member through
-*     TrackGroupStore.deleteByTracks: memberships first; zero survivors
-*     deletes the group's media then the row; survivors plus a lost anchor
-*     null the pointer. The orphan audit verifies the same via a second
-*     resolver (groupId → any member still present)."
-*/
-var TRACK_GROUPS_COLLECTION = "pipeline-analytics:track-groups";
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per member at group birth — id is '<groupId>:<trackId>'.
-*     timestamp is the member's firstSeen so the orphan audit has a clock
-*     column. Never rewritten."
-*   retention="TRACK-OWNED and clockless (D61): the column is named exactly
-*     trackId, so classification derives ownership and the cascade deletes
-*     the row with its track. A group with surviving members stays."
-*/
-var TRACK_GROUP_MEMBERS_COLLECTION = "pipeline-analytics:track-group-members";
-var TRACK_GROUPS_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "deviceId",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "timestamp",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "openedAt",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "closedAt",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "memberCount",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "anchorTrackId",
-		type: "TEXT"
-	},
-	{
-		name: "ux",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "uy",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "uw",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "uh",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "frameWidth",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "frameHeight",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "mediaKey",
-		type: "TEXT"
-	},
-	{
-		name: "nativeKey",
-		type: "TEXT"
-	},
-	{
-		name: "sealed",
-		type: "BOOLEAN",
-		notNull: true
-	}
-];
-var TRACK_GROUP_MEMBERS_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "groupId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "trackId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "deviceId",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "timestamp",
-		type: "INTEGER",
-		notNull: true
-	}
-];
-var TRACK_GROUPS_INDEXES = [{
-	name: "idx_track_groups_device_closed",
-	columns: ["deviceId", "closedAt"]
-}, {
-	name: "idx_track_groups_device_opened",
-	columns: ["deviceId", "openedAt"]
-}];
-var TRACK_GROUP_MEMBERS_INDEXES = [{
-	name: "idx_track_group_members_track",
-	columns: ["trackId"]
-}, {
-	name: "idx_track_group_members_group",
-	columns: ["groupId"]
-}];
-function newGroupId() {
-	return `grp-${(0, node_crypto.randomUUID)()}`;
-}
-function memberRowId(groupId, trackId) {
-	return `${groupId}:${trackId}`;
-}
-var TrackGroupStore = class {
-	store;
-	logger;
-	media;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.media = deps.media ?? null;
-	}
-	static async declare(store) {
-		await Promise.all([store.declareCollection.mutate({
-			collection: TRACK_GROUPS_COLLECTION,
-			columns: [...TRACK_GROUPS_COLUMNS],
-			indexes: [...TRACK_GROUPS_INDEXES]
-		}), store.declareCollection.mutate({
-			collection: TRACK_GROUP_MEMBERS_COLLECTION,
-			columns: [...TRACK_GROUP_MEMBERS_COLUMNS],
-			indexes: [...TRACK_GROUP_MEMBERS_INDEXES]
-		})]);
-	}
-	async insert(input) {
-		const id = newGroupId();
-		const group = {
-			id,
-			deviceId: input.deviceId,
-			timestamp: input.timestamp,
-			openedAt: input.openedAt,
-			closedAt: input.closedAt,
-			memberCount: input.members.length,
-			anchorTrackId: input.anchorTrackId,
-			ux: input.ux,
-			uy: input.uy,
-			uw: input.uw,
-			uh: input.uh,
-			frameWidth: input.frameWidth,
-			frameHeight: input.frameHeight,
-			mediaKey: input.mediaKey,
-			nativeKey: input.nativeKey,
-			sealed: true
-		};
-		await this.store.set.mutate({
-			collection: TRACK_GROUPS_COLLECTION,
-			key: id,
-			value: this.toRow(group)
-		});
-		for (const member of input.members) await this.store.set.mutate({
-			collection: TRACK_GROUP_MEMBERS_COLLECTION,
-			key: memberRowId(id, member.trackId),
-			value: {
-				groupId: id,
-				trackId: member.trackId,
-				deviceId: input.deviceId,
-				timestamp: member.firstSeen
-			}
-		});
-		return group;
-	}
-	/** The crop is written after birth; this is the only post-birth write besides the pointer null. */
-	async setMediaKey(groupId, mediaKey) {
-		const current = await this.get(groupId);
-		if (current === null) return;
-		await this.store.set.mutate({
-			collection: TRACK_GROUPS_COLLECTION,
-			key: groupId,
-			value: this.toRow({
-				...current,
-				mediaKey
-			})
-		});
-	}
-	async get(groupId) {
-		const raw = await this.store.get.query({
-			collection: TRACK_GROUPS_COLLECTION,
-			key: groupId
-		});
-		if (!raw) return null;
-		return this.normalizeGroup({
-			id: groupId,
-			data: raw
-		});
-	}
-	async listMembers(groupId) {
-		return (await this.store.query.query({
-			collection: TRACK_GROUP_MEMBERS_COLLECTION,
-			filter: { where: { groupId } }
-		})).map((r) => this.normalizeMember({
-			id: r.id,
-			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) {
-			const rows = await this.store.query.query({
-				collection: TRACK_GROUP_MEMBERS_COLLECTION,
-				filter: { where: { trackId } }
-			});
-			for (const r of rows) out.push(this.normalizeMember({
-				id: r.id,
-				data: r.data
-			}));
-		}
-		return out;
-	}
-	/**
-	* 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. `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 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: {
-				...deviceIds !== void 0 && deviceIds.length === 1 ? { where: { deviceId: deviceIds[0] } } : deviceIds !== void 0 ? { whereIn: { deviceId: [...deviceIds] } } : {},
-				orderBy: {
-					field: "closedAt",
-					direction: "desc"
-				},
-				limit: 2e3
-			}
-		})).map((r) => this.normalizeGroup({
-			id: r.id,
-			data: r.data
-		})).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;
-		}).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,
-			hasMore,
-			nextCursor: hasMore && last !== void 0 ? encodeGroupCursor({
-				closedAt: last.closedAt,
-				groupId: last.id
-			}) : null
-		};
-	}
-	/** Groups whose life overlaps `[since, until]` on one camera. */
-	async listOverlapping(input) {
-		return (await this.store.query.query({
-			collection: TRACK_GROUPS_COLLECTION,
-			filter: {
-				where: { deviceId: input.deviceId },
-				orderBy: {
-					field: "closedAt",
-					direction: "desc"
-				},
-				limit: input.limit ?? 2e3
-			}
-		})).map((r) => this.normalizeGroup({
-			id: r.id,
-			data: r.data
-		})).filter((g) => g.closedAt >= input.sinceMs && g.openedAt <= input.untilMs);
-	}
-	async existingGroupIds(ids) {
-		const live = /* @__PURE__ */ new Set();
-		for (const id of ids) if (await this.store.get.query({
-			collection: "pipeline-analytics:track-groups",
-			key: id
-		})) live.add(id);
-		return live;
-	}
-	/** Group ids that still have at least one membership row. */
-	async groupsWithMembers(ids) {
-		const live = /* @__PURE__ */ new Set();
-		for (const groupId of ids) if ((await this.store.query.query({
-			collection: "pipeline-analytics:track-group-members",
-			filter: {
-				where: { groupId },
-				limit: 1
-			}
-		})).length > 0) live.add(groupId);
-		return live;
-	}
-	/**
-	* Cascade leaf: delete memberships for the batch; a group with zero survivors
-	* dies (media then row); a group that lost only its anchor nulls the pointer.
-	*/
-	async deleteByTracks(trackIds) {
-		const batch = new Set(trackIds);
-		let memberRows = 0;
-		let groupRows = 0;
-		let mediaRows = 0;
-		let mediaBytes = 0;
-		const affected = /* @__PURE__ */ new Set();
-		try {
-			const memberships = await this.membersOfTracks(trackIds);
-			for (const member of memberships) try {
-				await this.store.delete.mutate({
-					collection: TRACK_GROUP_MEMBERS_COLLECTION,
-					key: member.id
-				});
-				memberRows += 1;
-				affected.add(member.groupId);
-			} catch (err) {
-				this.logger.warn("TrackGroupStore.deleteByTracks member delete failed", { meta: {
-					memberId: member.id,
-					error: String(err)
-				} });
-			}
-			for (const groupId of affected) try {
-				if ((await this.listMembers(groupId)).length === 0) {
-					if (this.media) {
-						const gone = await this.media.deleteByGroups([groupId]);
-						mediaRows += gone.rows;
-						mediaBytes += gone.bytes;
-					}
-					await this.store.delete.mutate({
-						collection: TRACK_GROUPS_COLLECTION,
-						key: groupId
-					});
-					groupRows += 1;
-					continue;
-				}
-				const group = await this.get(groupId);
-				if (group?.anchorTrackId && batch.has(group.anchorTrackId)) await this.store.set.mutate({
-					collection: TRACK_GROUPS_COLLECTION,
-					key: groupId,
-					value: this.toRow({
-						...group,
-						anchorTrackId: null,
-						nativeKey: null
-					})
-				});
-			} catch (err) {
-				this.logger.warn("TrackGroupStore.deleteByTracks group update failed", { meta: {
-					groupId,
-					error: String(err)
-				} });
-			}
-		} catch (err) {
-			this.logger.warn("TrackGroupStore.deleteByTracks failed", { meta: { error: String(err) } });
-		}
-		return [{
-			family: "groups",
-			rows: memberRows + groupRows,
-			bytes: 0
-		}, {
-			family: "media",
-			rows: mediaRows,
-			bytes: mediaBytes
-		}];
-	}
-	toRow(group) {
-		return {
-			deviceId: group.deviceId,
-			timestamp: group.timestamp,
-			openedAt: group.openedAt,
-			closedAt: group.closedAt,
-			memberCount: group.memberCount,
-			anchorTrackId: group.anchorTrackId,
-			ux: group.ux,
-			uy: group.uy,
-			uw: group.uw,
-			uh: group.uh,
-			frameWidth: group.frameWidth,
-			frameHeight: group.frameHeight,
-			mediaKey: group.mediaKey,
-			nativeKey: group.nativeKey,
-			sealed: group.sealed
-		};
-	}
-	normalizeGroup(r) {
-		const data = r.data;
-		return {
-			id: r.id,
-			deviceId: Number(data["deviceId"]),
-			timestamp: Number(data["timestamp"]),
-			openedAt: Number(data["openedAt"]),
-			closedAt: Number(data["closedAt"]),
-			memberCount: Number(data["memberCount"]),
-			anchorTrackId: typeof data["anchorTrackId"] === "string" ? data["anchorTrackId"] : null,
-			ux: Number(data["ux"]),
-			uy: Number(data["uy"]),
-			uw: Number(data["uw"]),
-			uh: Number(data["uh"]),
-			frameWidth: Number(data["frameWidth"]),
-			frameHeight: Number(data["frameHeight"]),
-			mediaKey: typeof data["mediaKey"] === "string" ? data["mediaKey"] : null,
-			nativeKey: typeof data["nativeKey"] === "string" ? data["nativeKey"] : null,
-			sealed: Boolean(data["sealed"])
-		};
-	}
-	normalizeMember(r) {
-		const data = r.data;
-		return {
-			id: r.id,
-			groupId: String(data["groupId"]),
-			trackId: String(data["trackId"]),
-			deviceId: Number(data["deviceId"]),
-			timestamp: Number(data["timestamp"])
-		};
-	}
-};
 //#endregion
 //#region src/pipeline-analytics/media-capture-log.ts
 var DEFAULT_FLUSH_INTERVAL_MS$1 = 6e4;
@@ -57663,24 +56251,12 @@ var ANALYTICS_COLLECTIONS = [
 		collection: PLATES_COLLECTION,
 		classification: derived(PLATE_COLUMNS)
 	},
-	{
-		collection: TRACK_GROUP_MEMBERS_COLLECTION,
-		classification: derived(TRACK_GROUP_MEMBERS_COLUMNS)
-	},
 	{
 		collection: MEDIA_COLLECTION,
 		classification: {
 			kind: "owner-indirection",
 			derivation: "explicit",
-			why: "(ownerKind, ownerId) means a different entity per kind — a trackId for 'track', a PREFIXED trackId for 'face'/'plate', an eventId for 'event', a groupId for 'group', and an enrolled gallery row for 'identity'/'vehicle' that retention must never touch. The mapping is `resolveMediaOwner` in orphan-audit.ts."
-		}
-	},
-	{
-		collection: TRACK_GROUPS_COLLECTION,
-		classification: {
-			kind: "owner-indirection",
-			derivation: "explicit",
-			why: "a group has N members and no trackId column; it is owned by its membership rows. The mapping is `resolveGroupOwner` in orphan-audit.ts (groupId → any member still present). Do not classify never-orphaned — that would make the last-member guarantee unverifiable."
+			why: "(ownerKind, ownerId) means a different entity per kind — a trackId for 'track', a PREFIXED trackId for 'face'/'plate', an eventId for 'event', and an enrolled gallery row for 'identity'/'vehicle' that retention must never touch. A RETIRED ownerKind (the deleted group entity) resolves to an owner that can never exist again and is always an orphan. The mapping is `resolveMediaOwner` in orphan-audit.ts."
 		}
 	},
 	{
@@ -57792,7 +56368,7 @@ var ANALYTICS_COLLECTIONS = [
 		collection: SCENE_LATCH_COLLECTION,
 		classification: {
 			kind: "never-orphaned",
-			why: "it IS owned — by the scene set — but the owner-cleanup is self-contained: `pruneExcept(the scene set)` runs on every scene reload, so a latch whose scene is gone is collected there and never by retention. Deliberately NOT `owner-indirection`: that kind puts a collection into `auditableCollections()`, and the orphan audit resolves only the indirections it has a resolver for (`pipeline-analytics:media` and `pipeline-analytics:track-groups`)."
+			why: "it IS owned — by the scene set — but the owner-cleanup is self-contained: `pruneExcept(the scene set)` runs on every scene reload, so a latch whose scene is gone is collected there and never by retention. Deliberately NOT `owner-indirection`: that kind puts a collection into `auditableCollections()`, and the orphan audit resolves only the indirections it has a resolver for (`pipeline-analytics:media`)."
 		}
 	},
 	{
@@ -57852,6 +56428,10 @@ function resolveMediaOwner(row) {
 		kind: "unresolvable",
 		why: "media row carries no (ownerKind, ownerId)"
 	};
+	if (isRetiredMediaOwnerKind(kindRaw)) return {
+		kind: "retired-owner",
+		ownerKind: kindRaw
+	};
 	const ownerKind = kindRaw;
 	if (isRetentionExemptOwnerKind(ownerKind)) return {
 		kind: "exempt",
@@ -57880,10 +56460,6 @@ function resolveMediaOwner(row) {
 			kind: "unresolvable",
 			why: `plate-owned media whose ownerId does not carry the '${PLATE_MEDIA_OWNER_PREFIX}' prefix`
 		};
-		case "group": return {
-			kind: "group",
-			groupId: ownerId
-		};
 		default: return {
 			kind: "unresolvable",
 			why: `unknown ownerKind '${kindRaw}'`
@@ -57895,13 +56471,6 @@ function resolveMediaOwner(row) {
 * is derived the same way the classification is — an enrolled row is out of
 * reach regardless of what happened to the track that produced it.
 */
-/** A group row lives iff any membership row still names it. */
-function resolveGroupOwner(row) {
-	return {
-		kind: "group-members",
-		groupId: row.key
-	};
-}
 function resolveDeclaredTrackOwner(row, enrolmentExempt) {
 	if (enrolmentExempt && row.data["assigned"] === true) return {
 		kind: "exempt",
@@ -57932,17 +56501,6 @@ function buildOrphanScopes(collections = auditableCollections()) {
 				});
 				continue;
 			}
-			if (entry.collection === "pipeline-analytics:track-groups") {
-				scopes.push({
-					id: entry.collection,
-					collection: entry.collection,
-					resolve: resolveGroupOwner,
-					timestampField: "timestamp",
-					sizeField: null,
-					deviceIdField: "deviceId"
-				});
-				continue;
-			}
 			continue;
 		}
 		if (entry.classification.kind !== "track-owned") continue;
@@ -57974,17 +56532,11 @@ var DEFAULT_ORPHAN_LIMITS = {
 function questionsFor(refs) {
 	const trackIds = /* @__PURE__ */ new Set();
 	const eventIds = /* @__PURE__ */ new Set();
-	const groupIds = /* @__PURE__ */ new Set();
-	const groupMemberIds = /* @__PURE__ */ new Set();
 	for (const ref of refs) if (ref.kind === "track") trackIds.add(ref.trackId);
 	else if (ref.kind === "event") eventIds.add(ref.eventId);
-	else if (ref.kind === "group") groupIds.add(ref.groupId);
-	else if (ref.kind === "group-members") groupMemberIds.add(ref.groupId);
 	return {
 		trackIds: [...trackIds],
-		eventIds: [...eventIds],
-		groupIds: [...groupIds],
-		groupMemberIds: [...groupMemberIds]
+		eventIds: [...eventIds]
 	};
 }
 /**
@@ -58016,16 +56568,12 @@ async function auditScope(scope, deps, limits, cursor) {
 			break;
 		}
 		const refs = rows.map((row) => scope.resolve(row));
-		const { trackIds, eventIds, groupIds, groupMemberIds } = questionsFor(refs);
+		const { trackIds, eventIds } = questionsFor(refs);
 		let liveTracks;
 		let liveEvents;
-		let liveGroups;
-		let liveGroupsWithMembers;
 		try {
 			liveTracks = trackIds.length > 0 ? await deps.liveTrackIds(trackIds) : /* @__PURE__ */ new Set();
 			liveEvents = eventIds.length > 0 ? await deps.liveEventIds(eventIds) : /* @__PURE__ */ new Set();
-			liveGroups = groupIds.length > 0 && deps.liveGroupIds ? await deps.liveGroupIds(groupIds) : /* @__PURE__ */ new Set();
-			liveGroupsWithMembers = groupMemberIds.length > 0 && deps.liveGroupsWithMembers ? await deps.liveGroupsWithMembers(groupMemberIds) : /* @__PURE__ */ new Set();
 		} catch (err) {
 			deps.logger.warn("orphan audit: liveness probe failed — scope abandoned for this run", { meta: {
 				collection: scope.collection,
@@ -58049,7 +56597,7 @@ async function auditScope(scope, deps, limits, cursor) {
 				tally.unresolvable += 1;
 				continue;
 			}
-			if (ref.kind === "track" ? liveTracks.has(ref.trackId) : ref.kind === "event" ? liveEvents.has(ref.eventId) : ref.kind === "group" ? liveGroups.has(ref.groupId) : liveGroupsWithMembers.has(ref.groupId)) continue;
+			if (ref.kind === "track" ? liveTracks.has(ref.trackId) : ref.kind === "event" ? liveEvents.has(ref.eventId) : false) continue;
 			const ts = num(row.data, scope.timestampField);
 			if (ts !== null && ts > graceFloor) {
 				tally.withinGrace += 1;
@@ -64887,8 +63435,7 @@ var customActions = {
 	...locationDiscardActions,
 	...viewerSettingsActions,
 	...photoEnrollActions,
-	...faceRescoreActions,
-	...groupActions
+	...faceRescoreActions
 };
 /**
 * Assist threshold when the caller does not pin one. Packages have their own
@@ -65180,11 +63727,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	faceStore = null;
 	faceRecognizer = null;
 	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`. */
@@ -66142,8 +64684,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					...locationDiscardActions,
 					...viewerSettingsActions,
 					...photoEnrollActions,
-					...faceRescoreActions,
-					...groupActions
+					...faceRescoreActions
 				},
 				actionHandlers: {
 					...ncHandlers,
@@ -66151,7 +64692,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					...this.buildDebugActionHandlers(),
 					...this.buildPhotoEnrollActionHandlers(),
 					...this.buildFaceRescoreActionHandlers(),
-					...this.buildGroupActionHandlers(),
 					...this.viewerSettingsSnapshots ? makeViewerSettingsActionHandlers(this.viewerSettingsSnapshots) : {}
 				}
 			} : {}
@@ -66385,7 +64925,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			SceneStore.declare(api.settingsStore),
 			NotificationCenter.declare(api.settingsStore),
 			ViewerSettingsSnapshotStore.declare(api.settingsStore),
-			TrackGroupStore.declare(api.settingsStore),
 			declareMigrationMarkers(api.settingsStore)
 		]);
 		this.viewerSettingsSnapshots = new ViewerSettingsSnapshotStore(api.settingsStore);
@@ -66745,31 +65284,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			logger: logger.child("PlateStore")
 		});
 		this.plateStore = plateStore;
-		const vehicleStore = new VehicleStore({
-			store: api.settingsStore,
-			logger: logger.child("VehicleStore")
-		});
-		const groupStore = new TrackGroupStore({
-			store: api.settingsStore,
-			logger: logger.child("TrackGroupStore"),
-			media: mediaStore
-		});
-		this.groupStore = groupStore;
-		this.groupLive = new GroupLiveBuffer();
-		this.groupSealer = new GroupSealer({
-			trackStore,
-			groupStore,
-			mediaStore,
-			logger: logger.child("GroupSealer"),
-			frameDims: (deviceId) => {
-				const dims = this.lastFrameDimsByDevice.get(deviceId);
-				return dims ? {
-					width: dims.w,
-					height: dims.h
-				} : void 0;
-			},
-			now: () => Date.now()
-		});
 		return {
 			trackStore,
 			mediaStore,
@@ -66777,8 +65291,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			identityStore,
 			faceStore,
 			plateStore,
-			vehicleStore,
-			groupStore
+			vehicleStore: new VehicleStore({
+				store: api.settingsStore,
+				logger: logger.child("VehicleStore")
+			})
 		};
 	}
 	/** Face + plate recognizers, the durable keyFrame-derived plate crop and the
@@ -67299,28 +65815,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				}));
 			},
 			listMediaInfo: async (id) => {
-				const group = await stores.groupStore.get(id);
-				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,
-						sizeBytes: r.sizeBytes
-					})));
-					return digestMediaRows({
-						mediaKey: group.mediaKey,
-						nativeKey: group.nativeKey,
-						timestamp: group.timestamp,
-						memberRows
-					});
-				}
 				return (await stores.mediaStore.listInfoByOwner("track", id)).map((r) => ({
 					key: r.key,
 					kind: r.kind,
@@ -68691,7 +67185,6 @@ 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);
@@ -70788,11 +69281,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
 		await this.trackCloser.sweep();
-		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
@@ -71494,16 +69983,6 @@ 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 },
@@ -71731,15 +70210,6 @@ 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
@@ -72258,8 +70728,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				},
 				liveTrackIds: (ids) => trackStore.existingTrackIds(ids),
 				liveEventIds: (ids) => eventStore.existingEventIds(ids),
-				liveGroupIds: (ids) => this.groupStore?.existingGroupIds(ids) ?? Promise.resolve(/* @__PURE__ */ new Set()),
-				liveGroupsWithMembers: (ids) => this.groupStore?.groupsWithMembers(ids) ?? Promise.resolve(/* @__PURE__ */ new Set()),
 				reclaim: async (collection, key) => {
 					if (collection === "pipeline-analytics:media") {
 						await mediaStore.deleteByKey(key);
@@ -73022,41 +71490,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	buildFaceRescoreActionHandlers() {
 		return { "face.rescoreTrack": (input) => this.rescoreFaceForTrack(input) };
 	}
-	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) => {
-				return {
-					groups: [],
-					hasMore: false
-				};
-			},
-			"analytics.getGroup": async (input) => {
-				return { group: null };
-			}
-		};
-	}
 	buildPhotoEnrollActionHandlers() {
 		return {
 			"photo.analyze": async (input) => {
@@ -73442,8 +71875,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			mediaStore,
 			faceStore: this.faceStore,
 			plateStore: this.plateStore,
-			objectEmbeddingStore: this.objectEmbeddingStore,
-			groupStore: this.groupStore
+			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: {
@@ -73652,8 +72084,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			media: 0,
 			faces: 0,
 			plates: 0,
-			embeddings: 0,
-			groups: 0
+			embeddings: 0
 		};
 		this.lastPruneBytes = 0;
 		const cascade = this.buildTrackCascadeRegistry();
@@ -73713,8 +72144,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			media: tally.media,
 			faces: tally.faces,
 			plates: tally.plates,
-			embeddings: tally.embeddings,
-			groups: tally.groups
+			embeddings: tally.embeddings
 		};
 	}
 	/**