@camstack/addon-post-analysis 1.1.37 → 1.1.39

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { C as hydrateSchema, D as object, E as number, O as string, S as createEvent, T as boolean, _ as videoclipsCapability, a as OpsLogEntrySchema, b as BaseAddon, c as buildEventKindDescriptor, d as faceGalleryCapability, g as subKindsOf, h as plateGalleryCapability, i as MACRO_LABELS, k as EventCategory, l as cosineSimilarity, m as pipelineAnalyticsCapability, n as EVENT_KIND_BY_CAP, o as addonWidgetsSourceCapability, p as nodePin, r as EVENT_PAD_MS, s as audioMetricsCapability, t as DEFAULT_EVENT_COLOR, v as zoneAnalyticsCapability, w as array, x as DeviceType, y as errMsg } from "../dist-DPBet4IQ.mjs";
+import { C as hydrateSchema, D as object, E as number, O as string, S as createEvent, T as boolean, _ as videoclipsCapability, a as OpsLogEntrySchema, b as BaseAddon, c as buildEventKindDescriptor, d as faceGalleryCapability, g as subKindsOf, h as plateGalleryCapability, i as MACRO_LABELS, k as EventCategory, l as cosineSimilarity, m as pipelineAnalyticsCapability, n as EVENT_KIND_BY_CAP, o as addonWidgetsSourceCapability, p as nodePin, r as EVENT_PAD_MS, s as audioMetricsCapability, t as DEFAULT_EVENT_COLOR, v as zoneAnalyticsCapability, w as array, x as DeviceType, y as errMsg } from "../dist-CO07v2sR.mjs";
 import { randomUUID } from "node:crypto";
 import sharp from "sharp";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -1120,8 +1120,35 @@ var DEFAULT_TRACKER_CONFIG = {
 	rescueIouThreshold: .1,
 	rescueCentroidFactor: .75,
 	resurrectionWindowMs: 8e3,
-	stationarySpeedPx: 2
+	stationarySpeedPx: 2,
+	dedupEnabled: true,
+	dedupSpawnIou: .6,
+	dedupMergeIou: .6,
+	dedupMergeFrames: 5,
+	personAnimalDedup: true,
+	animalOverPersonMaxScore: .6,
+	animalOverPersonIou: .2,
+	classVotingEnabled: true,
+	classVoteMinFraction: .5,
+	perClassMinScoreEnabled: true,
+	classMinScores: {
+		animal: .45,
+		vehicle: .45
+	},
+	confirmBypassEnabled: false,
+	confirmBypassScore: .9,
+	byteTrackEnabled: true,
+	byteTrackHighThreshold: .4,
+	byteTrackLowIouThreshold: .2,
+	minSpawnAreaEnabled: true,
+	classSpawnAreaFracs: { person: 5e-4 },
+	classGroupAssoc: true
 };
+/** Macro-classes the duplicate resolver may collapse across (people in
+*  non-upright poses misdetected as animals). Any other cross-class pair is
+*  NEVER a duplicate. */
+var PERSON_CLASS = "person";
+var ANIMAL_CLASS = "animal";
 var MAX_PATH_LENGTH = 300;
 function clamp(value, min, max) {
 	return Math.max(min, Math.min(max, value));
@@ -1144,16 +1171,127 @@ function containment(inner, outer) {
 	const innerArea = inner.w * inner.h;
 	return innerArea > 0 ? iw * ih / innerArea : 0;
 }
-var SortTracker = class {
+var SortTracker = class SortTracker {
 	config;
 	tracks = [];
 	lostTracks = [];
+	/**
+	* Consecutive-frame overlap streak per unordered live-track pair
+	* (`idA|idB`, ids sorted). Drives the sustained-overlap merge: a pair is
+	* merged only once its streak reaches `dedupMergeFrames`. Entries reset the
+	* moment the pair stops overlapping and are pruned when either track dies.
+	*/
+	dupStreaks = /* @__PURE__ */ new Map();
 	constructor(config = {}) {
 		this.config = {
 			...DEFAULT_TRACKER_CONFIG,
 			...config
 		};
 	}
+	/** Whether two macro-classes may be collapsed as the SAME subject. Same class
+	*  always; the {person,animal} pair only when `personAnimalDedup` is on. */
+	dedupCompatible(a, b) {
+		if (a === b) return true;
+		if (!this.config.personAnimalDedup) return false;
+		return a === PERSON_CLASS && b === ANIMAL_CLASS || a === ANIMAL_CLASS && b === PERSON_CLASS;
+	}
+	/** Unordered, stable key for a track pair (UUIDs never contain `|`). */
+	static pairKey(a, b) {
+		return a < b ? `${a}|${b}` : `${b}|${a}`;
+	}
+	/** Association-gating group of a class. When `classGroupAssoc` is on the
+	*  {person,animal} pair collapses to one group so a per-frame class flip
+	*  (crouch person → animal) re-matches the existing track instead of spawning a
+	*  concurrent id. Every other class is its own group. */
+	assocGroup(cls) {
+		if (this.config.classGroupAssoc && (cls === PERSON_CLASS || cls === ANIMAL_CLASS)) return `${PERSON_CLASS}|${ANIMAL_CLASS}`;
+		return cls;
+	}
+	/** Whether a detection may associate to a track under the current class gate:
+	*  exact class when `classGating` is off (no gate at all) — matching the legacy
+	*  contract — otherwise same association group (group == exact class unless
+	*  `classGroupAssoc` widened it to {person,animal}). */
+	associable(trackClass, detClass) {
+		if (!this.config.classGating) return true;
+		return this.assocGroup(trackClass) === this.assocGroup(detClass);
+	}
+	/** Whether a spawn candidate clears its per-class minimum bbox-area floor
+	*  (fraction of frame area). Ungated when disabled, when the class has no floor,
+	*  or when the caller supplied no frame dimensions (fraction is uncomputable). */
+	meetsSpawnAreaFloor(det, frameArea) {
+		if (!this.config.minSpawnAreaEnabled) return true;
+		const floor = this.config.classSpawnAreaFracs[det.class] ?? 0;
+		if (floor <= 0 || frameArea <= 0) return true;
+		return det.bbox.w * det.bbox.h / frameArea >= floor;
+	}
+	/**
+	* True when spawning a fresh track for `det` would duplicate an already-live
+	* track: (a) it overlaps a concurrent compatible-class track by
+	* `dedupSpawnIou`, or (b) it is a low-confidence `animal` sitting on a
+	* concurrent `person` track (person-in-odd-pose false animal). `live` is the
+	* set of tracks already surviving this frame (matched, coasting, resurrected,
+	* and earlier same-frame spawns).
+	*/
+	isDuplicateSpawn(det, live) {
+		for (const t of live) if (this.dedupCompatible(t.class, det.class) && iou$2(det.bbox, t.bbox) >= this.config.dedupSpawnIou) return true;
+		if (this.config.personAnimalDedup && det.class === ANIMAL_CLASS && det.score < this.config.animalOverPersonMaxScore) {
+			for (const t of live) if (t.class === PERSON_CLASS && iou$2(det.bbox, t.bbox) >= this.config.animalOverPersonIou) return true;
+		}
+		return false;
+	}
+	/** The lower-importance track of a duplicate pair — the one to drop. A
+	*  `person` always beats a cross-class `animal`; otherwise more hits wins,
+	*  ties break to the older track, then the higher score. */
+	static duplicateLoser(a, b) {
+		if (a.class !== b.class) {
+			if (a.class === PERSON_CLASS && b.class === ANIMAL_CLASS) return b;
+			if (b.class === PERSON_CLASS && a.class === ANIMAL_CLASS) return a;
+		}
+		if (a.hits !== b.hits) return a.hits > b.hits ? b : a;
+		if (a.firstSeen !== b.firstSeen) return a.firstSeen < b.firstSeen ? b : a;
+		return a.score >= b.score ? b : a;
+	}
+	/**
+	* Merge concurrent duplicate tracks. Two live compatible-class tracks that
+	* stay overlapped (≥ `dedupMergeIou`) for `dedupMergeFrames` consecutive
+	* frames are collapsed: the lower-importance one is dropped (NOT graveyarded
+	* — a confirmed duplicate must not resurrect). This is the fix for a subject
+	* the detector double-fires (two boxes each frame, each feeding its OWN
+	* track, so neither is ever "unmatched" for spawn-suppression to catch) and
+	* for a person misdetected as `animal` alongside the real person track.
+	*/
+	resolveDuplicates() {
+		if (!this.config.dedupEnabled) return;
+		const live = this.tracks;
+		const liveIds = new Set(live.map((t) => t.id));
+		for (const key of this.dupStreaks.keys()) {
+			const [a, b] = key.split("|");
+			if (a === void 0 || b === void 0 || !liveIds.has(a) || !liveIds.has(b)) this.dupStreaks.delete(key);
+		}
+		const dropIds = /* @__PURE__ */ new Set();
+		for (let i = 0; i < live.length; i++) for (let j = i + 1; j < live.length; j++) {
+			const a = live[i];
+			const b = live[j];
+			if (dropIds.has(a.id) || dropIds.has(b.id)) continue;
+			if (!this.dedupCompatible(a.class, b.class)) continue;
+			const key = SortTracker.pairKey(a.id, b.id);
+			if (iou$2(a.bbox, b.bbox) < this.config.dedupMergeIou) {
+				this.dupStreaks.delete(key);
+				continue;
+			}
+			const streak = (this.dupStreaks.get(key) ?? 0) + 1;
+			if (streak >= this.config.dedupMergeFrames) {
+				dropIds.add(SortTracker.duplicateLoser(a, b).id);
+				this.dupStreaks.delete(key);
+			} else this.dupStreaks.set(key, streak);
+		}
+		if (dropIds.size === 0) return;
+		this.tracks = this.tracks.filter((t) => !dropIds.has(t.id));
+		for (const key of this.dupStreaks.keys()) {
+			const [a, b] = key.split("|");
+			if (a !== void 0 && dropIds.has(a) || b !== void 0 && dropIds.has(b)) this.dupStreaks.delete(key);
+		}
+	}
 	/** Where a track is expected this frame — extrapolated by velocity while
 	*  coasting (predictiveCoasting), else its last known bbox. A stationary
 	*  track (speed < stationarySpeedPx) is frozen so bbox jitter can't walk the
@@ -1174,13 +1312,16 @@ var SortTracker = class {
 		};
 	}
 	/**
-	* Loose same-class gate used by the rescue and resurrection passes: accept
+	* Loose same-group gate used by the rescue and resurrection passes: accept
 	* when the detection overlaps the track's LAST-KNOWN bbox by `rescueIou`, or
-	* its centroid is within `rescueCentroidFactor × bbox-diagonal`. Always class-
-	* gated (a rescue must never cross classes), independent of `classGating`.
+	* its centroid is within `rescueCentroidFactor × bbox-diagonal`. Always group-
+	* gated (a rescue must never cross association groups) independent of
+	* `classGating`, so a coasting person track can be rescued by its own
+	* crouch→animal flip when `classGroupAssoc` is on, but never by an unrelated
+	* class.
 	*/
 	looseMatch(track, det) {
-		if (track.class !== det.class) return false;
+		if (this.assocGroup(track.class) !== this.assocGroup(det.class)) return false;
 		if (iou$2(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return true;
 		const tc = bboxCentroid(track.bbox);
 		const dc = bboxCentroid(det.bbox);
@@ -1188,29 +1329,65 @@ var SortTracker = class {
 		const diag = Math.hypot(track.bbox.w, track.bbox.h);
 		return dist <= this.config.rescueCentroidFactor * diag;
 	}
-	update(detections, timestamp) {
-		if (this.config.maxTrackLifetimeMs > 0) {
-			const alive = [];
-			for (const track of this.tracks) if (timestamp - track.firstSeen > this.config.maxTrackLifetimeMs) {
-				track.lost = true;
-				track.lostAt = timestamp;
-				track.resurrectable = false;
-				this.lostTracks.push(track);
-			} else alive.push(track);
-			this.tracks = alive;
+	/** Fold a matched detection's class + score into a track's lifetime vote
+	*  tally. A non-positive score still counts as an infinitesimal vote so a
+	*  zero-confidence frame contributes to the frame-count tiebreak. */
+	addClassVote(track, det) {
+		const weight = det.score > 0 ? det.score : Number.EPSILON;
+		track.classVotes.set(det.class, (track.classVotes.get(det.class) ?? 0) + weight);
+	}
+	/**
+	* The class to REPORT for a track: the confidence-weighted lifetime majority
+	* when voting is on and the winner holds ≥ `classVoteMinFraction` of the total
+	* weight; otherwise the latest-frame class (ambiguous vote or voting off).
+	*/
+	resolveReportedClass(t) {
+		if (!this.config.classVotingEnabled || t.classVotes.size === 0) return t.class;
+		let bestClass = t.class;
+		let bestVote = -1;
+		let total = 0;
+		for (const [cls, v] of t.classVotes) {
+			total += v;
+			if (v > bestVote) {
+				bestVote = v;
+				bestClass = cls;
+			}
 		}
-		this.lostTracks = this.lostTracks.filter((t) => timestamp - t.lostAt <= this.config.resurrectionWindowMs);
-		const used = /* @__PURE__ */ new Set();
-		const matchedTracks = /* @__PURE__ */ new Set();
-		const matched = /* @__PURE__ */ new Map();
+		if (total <= 0) return t.class;
+		return bestVote / total >= this.config.classVoteMinFraction ? bestClass : t.class;
+	}
+	/** Whether a detection clears its per-class spawn score floor. Only gates NEW
+	*  spawns — an established track still matches below its floor. */
+	meetsClassScoreFloor(det) {
+		if (!this.config.perClassMinScoreEnabled) return true;
+		const floor = this.config.classMinScores[det.class] ?? 0;
+		return det.score >= floor;
+	}
+	/** Whether a track is confirmed for EMISSION: it reached `minHits`, or (opt-in)
+	*  a single very-high-confidence detection bypassed the hit gate (fast car). */
+	isConfirmedForEmit(t) {
+		if (t.hits >= this.config.minHits) return true;
+		return this.config.confirmBypassEnabled && t.score >= this.config.confirmBypassScore;
+	}
+	/**
+	* One greedy IoU association pass over a candidate detection subset against the
+	* currently-UNMATCHED tracks, on each track's PREDICTED box. Highest-IoU pairs
+	* bind first; a track/detection binds at most once. Shared by the high-score
+	* first stage and the low-score second stage (different candidate sets + IoU
+	* gates) so the two-tier ByteTrack association stays a single implementation.
+	* Mutates `used` / `matchedTracks` / `matched` in place.
+	*/
+	greedyAssociate(detections, candidateIdxs, iouThreshold, used, matchedTracks, matched) {
 		const pairs = [];
 		for (const track of this.tracks) {
+			if (matchedTracks.has(track)) continue;
 			const pbox = this.predicted(track);
-			for (let di = 0; di < detections.length; di++) {
+			for (const di of candidateIdxs) {
+				if (used.has(di)) continue;
 				const det = detections[di];
-				if (this.config.classGating && track.class !== det.class) continue;
+				if (!this.associable(track.class, det.class)) continue;
 				const score = iou$2(pbox, det.bbox);
-				if (score >= this.config.iouThreshold) pairs.push({
+				if (score >= iouThreshold) pairs.push({
 					track,
 					detIdx: di,
 					score
@@ -1224,11 +1401,34 @@ var SortTracker = class {
 			matchedTracks.add(pair.track);
 			used.add(pair.detIdx);
 		}
+	}
+	update(detections, timestamp, frameContext) {
+		const frameArea = frameContext ? frameContext.frameWidth * frameContext.frameHeight : 0;
+		if (this.config.maxTrackLifetimeMs > 0) {
+			const alive = [];
+			for (const track of this.tracks) if (timestamp - track.firstSeen > this.config.maxTrackLifetimeMs) {
+				track.lost = true;
+				track.lostAt = timestamp;
+				track.resurrectable = false;
+				this.lostTracks.push(track);
+			} else alive.push(track);
+			this.tracks = alive;
+		}
+		this.lostTracks = this.lostTracks.filter((t) => timestamp - t.lostAt <= this.config.resurrectionWindowMs);
+		const used = /* @__PURE__ */ new Set();
+		const matchedTracks = /* @__PURE__ */ new Set();
+		const matched = /* @__PURE__ */ new Map();
+		const highIdxs = [];
+		const lowIdxs = [];
+		for (let di = 0; di < detections.length; di++) if (this.config.byteTrackEnabled && detections[di].score < this.config.byteTrackHighThreshold) lowIdxs.push(di);
+		else highIdxs.push(di);
+		const lowSet = new Set(lowIdxs);
+		this.greedyAssociate(detections, highIdxs, this.config.iouThreshold, used, matchedTracks, matched);
 		const rescuePairs = [];
 		for (const track of this.tracks) {
 			if (matchedTracks.has(track)) continue;
 			for (let di = 0; di < detections.length; di++) {
-				if (used.has(di)) continue;
+				if (used.has(di) || lowSet.has(di)) continue;
 				const det = detections[di];
 				if (!this.looseMatch(track, det)) continue;
 				rescuePairs.push({
@@ -1245,6 +1445,7 @@ var SortTracker = class {
 			matchedTracks.add(pair.track);
 			used.add(pair.detIdx);
 		}
+		if (this.config.byteTrackEnabled && lowIdxs.length > 0) this.greedyAssociate(detections, lowIdxs, this.config.byteTrackLowIouThreshold, used, matchedTracks, matched);
 		for (const [track, det] of matched) {
 			const prevCenter = bboxCentroid({
 				x: track.bbox.x,
@@ -1272,6 +1473,7 @@ var SortTracker = class {
 			};
 			track.path.push(det.bbox);
 			if (track.path.length > MAX_PATH_LENGTH) track.path.shift();
+			this.addClassVote(track, det);
 		}
 		const occluderBoxes = [];
 		for (const track of matchedTracks) occluderBoxes.push(track.bbox);
@@ -1321,13 +1523,34 @@ var SortTracker = class {
 			};
 			best.path.push(det.bbox);
 			if (best.path.length > MAX_PATH_LENGTH) best.path.shift();
+			this.addClassVote(best, det);
 			surviving.push(best);
 			used.add(di);
 		}
-		for (let di = 0; di < detections.length; di++) {
-			if (used.has(di)) continue;
+		const unmatchedIdx = [];
+		for (let di = 0; di < detections.length; di++) if (!used.has(di)) unmatchedIdx.push(di);
+		const classRank = (cls) => cls === PERSON_CLASS ? 0 : cls === ANIMAL_CLASS ? 2 : 1;
+		unmatchedIdx.sort((ia, ib) => {
+			const da = detections[ia];
+			const db = detections[ib];
+			const r = classRank(da.class) - classRank(db.class);
+			return r !== 0 ? r : db.score - da.score;
+		});
+		for (const di of unmatchedIdx) {
 			const det = detections[di];
+			if (!this.meetsClassScoreFloor(det)) {
+				used.add(di);
+				continue;
+			}
+			if (!this.meetsSpawnAreaFloor(det, frameArea)) {
+				used.add(di);
+				continue;
+			}
 			if (this.config.occlusionEnabled && occluderBoxes.some((ob) => containment(det.bbox, ob) >= this.config.occlusionContainment)) continue;
+			if (this.config.dedupEnabled && this.isDuplicateSpawn(det, surviving)) {
+				used.add(di);
+				continue;
+			}
 			surviving.push({
 				id: randomUUID(),
 				bbox: det.bbox,
@@ -1345,19 +1568,22 @@ var SortTracker = class {
 				},
 				lost: false,
 				lostAt: 0,
-				resurrectable: true
+				resurrectable: true,
+				classVotes: new Map([[det.class, det.score > 0 ? det.score : Number.EPSILON]])
 			});
 		}
 		this.tracks = surviving;
-		return this.tracks.filter((t) => t.hits >= this.config.minHits).map((t) => ({
-			class: t.class,
+		this.resolveDuplicates();
+		return this.tracks.filter((t) => this.isConfirmedForEmit(t)).map((t) => ({
+			class: this.resolveReportedClass(t),
 			originalClass: t.originalClass,
 			score: t.score,
 			bbox: t.bbox,
 			trackId: t.id,
 			trackAge: t.hits,
 			velocity: t.velocity,
-			path: [...t.path]
+			path: [...t.path],
+			matchedThisFrame: t.lastSeen === timestamp
 		}));
 	}
 	/**
@@ -1379,6 +1605,7 @@ var SortTracker = class {
 	reset() {
 		this.tracks = [];
 		this.lostTracks = [];
+		this.dupStreaks.clear();
 	}
 };
 //#endregion
@@ -1938,7 +2165,10 @@ var FrameProcessor = class {
 			wokenEntryIds: []
 		};
 		const trackerInput = gate.suppressedIndices.size > 0 ? filteredDetections.filter((_, i) => !gate.suppressedIndices.has(i)) : filteredDetections;
-		const trackedDetections = this.tracker.update(trackerInput, timestamp);
+		const trackedDetections = this.tracker.update(trackerInput, timestamp, {
+			frameWidth,
+			frameHeight
+		});
 		const objectStates = this.stateAnalyzer.analyze(trackedDetections, timestamp);
 		const rawEvents = this.eventEmitter.emit(trackedDetections, objectStates, [], [], String(this.deviceId));
 		const zonesByTrack = /* @__PURE__ */ new Map();
@@ -1967,6 +2197,7 @@ var FrameProcessor = class {
 				bbox: { ...td.bbox },
 				zones: zonesByTrack.get(td.trackId) ?? [],
 				state,
+				matchedThisFrame: td.matchedThisFrame !== false,
 				...label ? { label } : {},
 				...emb !== void 0 ? {
 					embedding: emb.embedding,
@@ -4239,6 +4470,26 @@ var FACE_MEDIA_OWNER_PREFIX = "face-";
 *  `plate-<trackId>`. Used by `deleteByTracks` to derive the plate crop owners
 *  of a set of tracks without a `trackId` column on media rows. */
 var PLATE_MEDIA_OWNER_PREFIX = "plate-";
+/**
+* Kinds that hold exactly ONE row per `(ownerKind, ownerId)` — the current
+* "best"/rolling/first artefact, never a filmstrip. Their row id + blob path are
+* DETERMINISTIC (`owner:kind`, NO timestamp) and written via an UPSERT
+* (`store.set`, atomic `INSERT … ON CONFLICT DO UPDATE`), so N concurrent
+* captures for the same `(track, kind)` all address the SAME row/blob — one can
+* never become thirteen regardless of interleaving (RC-1). Accumulating kinds
+* (`snapshot`, event `crop`/`fullFrame*`, `faceCrop`/`plateCrop`) keep their
+* per-instance timestamped id so the filmstrip / per-event / per-enrollment rows
+* still accumulate.
+*/
+var SINGLE_INSTANCE_KINDS = new Set([
+	"keyFrame",
+	"thumbnail",
+	"firstFrame",
+	"lastFrame"
+]);
+function isSingleInstanceKind(kind) {
+	return SINGLE_INSTANCE_KINDS.has(kind);
+}
 var MEDIA_COLUMNS = [
 	{
 		name: "id",
@@ -4290,10 +4541,11 @@ var MEDIA_INDEXES = [{
 	columns: ["deviceId", "timestamp"]
 }];
 function buildKey(params) {
-	return `${params.ownerKind}:${params.ownerId}:${params.kind}:${params.timestamp}`;
+	return isSingleInstanceKind(params.kind) ? `${params.ownerKind}:${params.ownerId}:${params.kind}` : `${params.ownerKind}:${params.ownerId}:${params.kind}:${params.timestamp}`;
 }
 function buildPath(params) {
-	return `pipeline-analytics/${params.deviceId}/${params.ownerKind}/${params.ownerId}/${params.kind}-${params.timestamp}.jpg`;
+	const base = `pipeline-analytics/${params.deviceId}/${params.ownerKind}/${params.ownerId}`;
+	return isSingleInstanceKind(params.kind) ? `${base}/${params.kind}.jpg` : `${base}/${params.kind}-${params.timestamp}.jpg`;
 }
 var MediaStore = class {
 	storage;
@@ -4316,25 +4568,31 @@ var MediaStore = class {
 	async put(params) {
 		const key = buildKey(params);
 		const path = buildPath(params);
+		const record = {
+			deviceId: params.deviceId,
+			ownerKind: params.ownerKind,
+			ownerId: params.ownerId,
+			kind: params.kind,
+			timestamp: params.timestamp,
+			path,
+			sizeBytes: params.data.length
+		};
 		try {
 			await this.storage.write({
 				location: "eventMedia",
 				relativePath: path,
 				data: params.data
 			});
-			await this.store.insert.mutate({
+			if (isSingleInstanceKind(params.kind)) await this.store.set.mutate({
+				collection: MEDIA_COLLECTION,
+				key,
+				value: record
+			});
+			else await this.store.insert.mutate({
 				collection: MEDIA_COLLECTION,
 				record: {
 					id: key,
-					data: {
-						deviceId: params.deviceId,
-						ownerKind: params.ownerKind,
-						ownerId: params.ownerId,
-						kind: params.kind,
-						timestamp: params.timestamp,
-						path,
-						sizeBytes: params.data.length
-					}
+					data: record
 				}
 			});
 			return key;
@@ -4353,8 +4611,14 @@ var MediaStore = class {
 	* Overwrite semantics: keep exactly ONE media entry per (ownerKind, ownerId,
 	* kind). Used for the rolling `lastFrame` and the best `thumbnail` per track —
 	* each new capture replaces the previous one (blob + index row) rather than
-	* accumulating a filmstrip the way `put` does. Deletes any existing rows of
-	* that (owner, kind) first, then writes the fresh one. Returns the new key.
+	* accumulating a filmstrip the way `put` does.
+	*
+	* These kinds are {@link SINGLE_INSTANCE_KINDS}, so `put` writes them to a
+	* DETERMINISTIC `owner:kind` row/blob via an UPSERT — N concurrent racing
+	* calls therefore all collapse onto the SAME row (RC-1), no query/insert/delete
+	* interleaving can leave survivors. The query+delete pass below is retained
+	* ONLY to reap LEGACY timestamped rows/blobs written before the deterministic
+	* scheme (transition back-compat); once migrated it is a no-op.
 	*/
 	async putReplacing(params) {
 		const existing = await this.store.query.query({
@@ -6096,6 +6360,25 @@ function squareSafeCropRegion(bbox, frame, padding) {
 		h: Math.round(ch)
 	};
 }
+/**
+* The same square-safe 16:9 region as {@link squareSafeCropRegion}, expressed in
+* NORMALIZED [0,1]×[0,1] coordinates instead of pixels.
+*
+* A normalized box maps DIRECTLY onto a native-resolution surface of the SAME
+* aspect ratio (the native crop path downscales while preserving aspect), so the
+* region computed from the detection frame's dimensions addresses the exact same
+* ROI on the runner's retained native frame. Reuses the pixel geometry verbatim
+* (single source of truth) and divides by the frame dimensions.
+*/
+function squareSafeCropRegionNormalized(bbox, frame, padding) {
+	const region = squareSafeCropRegion(bbox, frame, padding);
+	return {
+		x: region.x / frame.W,
+		y: region.y / frame.H,
+		w: region.w / frame.W,
+		h: region.h / frame.H
+	};
+}
 //#endregion
 //#region src/shared/frame/box-drawer.ts
 var DEFAULT_COLOR = DEFAULT_EVENT_COLOR;
@@ -6173,10 +6456,20 @@ async function drawBoxedFrame(frameData, frameWidth, frameHeight, boxes, opts =
 *  Small downscaled `thumbnail`s are intentionally left out for now — when we
 *  reintroduce them they'll be a separate small kind. */
 var MEDIA_QUALITY = 88;
-/** Output dimensions for square-safe 16:9 crops (crop/faceCrop/plateCrop). */
+/** Output dimensions for the LOCAL-FALLBACK square-safe 16:9 crops
+*  (crop/faceCrop/plateCrop/thumbnail) cut from the resolved ≤640 frame. */
 var CROP_WIDTH = 640;
 var CROP_HEIGHT = 360;
 var CROP_QUALITY = 80;
+/**
+* Native-surface crop width cap for subject crops (`crop`/`thumbnail`/
+* `faceCrop`/`plateCrop`). ~960px yields a sharp gallery/reel tile AND a
+* ≥224px classifier input straight from the runner's native surface, WITHOUT
+* hauling a full 1920px frame per subject (that width is reserved for the
+* full-frame `keyFrame`). It is an UPPER bound only: a native miss falls back to
+* the ≤640 local crop, so quality never regresses below today's behaviour.
+*/
+var NATIVE_SUBJECT_CROP_MAX_WIDTH = 960;
 function caption(className, confidence, label) {
 	const base = label && label !== className ? `${className} ${label}` : className;
 	return typeof confidence === "number" ? `${base} ${Math.round(confidence * 100)}%` : base;
@@ -6283,12 +6576,12 @@ var EventMediaDispatcher = class {
 			});
 			return empty;
 		}
-		for (const ev of events) await this.writeEventMedia(deviceId, frameData, fw, fh, ev, input.cropPadding);
+		for (const ev of events) await this.writeEventMedia(deviceId, frameHandle, frameData, fw, fh, ev, input.cropPadding);
 		for (const tf of trackFrames) await this.writeTrackFrame(deviceId, frameData, fw, fh, tf);
 		const storedSnapshots = [];
 		const thumbnailTrackIds = [];
 		for (const sn of snapshots) {
-			const res = await this.writeTrackSnapshot(deviceId, frameData, fw, fh, sn, input.cropPadding);
+			const res = await this.writeTrackSnapshot(deviceId, frameHandle, frameData, fw, fh, sn, input.cropPadding);
 			if (res.storedSnapshot) storedSnapshots.push(res.storedSnapshot);
 			if (res.thumbnailWritten) thumbnailTrackIds.push(sn.trackId);
 		}
@@ -6309,7 +6602,7 @@ var EventMediaDispatcher = class {
 	* failed). `thumbnailWritten` reports whether a best `thumbnail` actually
 	* landed this frame (#27-A) so the caller can stop forcing retries.
 	*/
-	async writeTrackSnapshot(deviceId, frameData, fw, fh, sn, cropPadding) {
+	async writeTrackSnapshot(deviceId, frameHandle, frameData, fw, fh, sn, cropPadding) {
 		if (!sn.appendSnapshot && !sn.rollingLastFrame && !sn.bestThumbnail) return {
 			storedSnapshot: null,
 			thumbnailWritten: false
@@ -6350,7 +6643,7 @@ var EventMediaDispatcher = class {
 		if (sn.rollingLastFrame && boxed) await this.replaceKind(deviceId, sn.trackId, "lastFrame", sn.timestamp, boxed);
 		let thumbnailWritten = false;
 		if (sn.bestThumbnail) try {
-			const crop = await this.cropSubjectRegion(frameData, fw, fh, sn.bbox, cropPadding);
+			const crop = await this.cropSubjectRegion(frameHandle, frameData, fw, fh, sn.bbox, cropPadding);
 			thumbnailWritten = await this.replaceKind(deviceId, sn.trackId, "thumbnail", sn.timestamp, crop);
 		} catch (err) {
 			this.deps.logger.warn("event media: track thumbnail crop failed", {
@@ -6369,12 +6662,38 @@ var EventMediaDispatcher = class {
 		};
 	}
 	/**
-	* Clean subject-centered crop of `bbox` out of the raw frame — the shared
-	* output contract of the object-event `crop` kind and the track `thumbnail`:
-	* square-safe 16:9 region around the bbox, extracted from the ORIGINAL frame
-	* (no box drawn), resized to 640×360, JPEG q80.
+	* Clean subject-centered crop of `bbox` — the shared output contract of the
+	* object-event `crop` kind, the child `faceCrop`/`plateCrop`, and the track
+	* `thumbnail`: the square-safe 16:9 region around the bbox with NO box drawn.
+	*
+	* NATIVE-FIRST: the region is requested from the runner's retained native
+	* surface (normalized [0,1] coords map directly onto it), downscaled to
+	* {@link NATIVE_SUBJECT_CROP_MAX_WIDTH} — a sharp tile at native detail. On any
+	* miss/error (or a runner without the method) it FALLS BACK to cropping the
+	* resolved ≤640 frame locally (today's behaviour), so quality never regresses.
+	* Both paths run inside the live-handle window opened by `captureForFrame`.
+	*/
+	async cropSubjectRegion(frameHandle, frameData, fw, fh, bbox, cropPadding) {
+		if (this.deps.getNativeCropJpeg) try {
+			const norm = squareSafeCropRegionNormalized(bbox, {
+				W: fw,
+				H: fh
+			}, cropPadding);
+			const native = await this.deps.getNativeCropJpeg(frameHandle, norm, NATIVE_SUBJECT_CROP_MAX_WIDTH);
+			if (native) return native;
+		} catch (err) {
+			this.deps.logger.debug("event media: native subject crop failed — local fallback", { meta: {
+				shmId: frameHandle.shmId,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+		return this.cropSubjectRegionLocal(frameData, fw, fh, bbox, cropPadding);
+	}
+	/**
+	* Local-fallback square-safe 16:9 crop out of the resolved ≤640 frame, resized
+	* to 640×360, JPEG q80. Used when the native surface is unavailable/missed.
 	*/
-	async cropSubjectRegion(frameData, fw, fh, bbox, cropPadding) {
+	async cropSubjectRegionLocal(frameData, fw, fh, bbox, cropPadding) {
 		const region = squareSafeCropRegion(bbox, {
 			W: fw,
 			H: fh
@@ -6417,13 +6736,13 @@ var EventMediaDispatcher = class {
 			return false;
 		}
 	}
-	async writeEventMedia(deviceId, frameData, fw, fh, ev, cropPadding) {
+	async writeEventMedia(deviceId, frameHandle, frameData, fw, fh, ev, cropPadding) {
 		const box = {
 			...ev.bbox,
 			label: caption(ev.className, ev.confidence, ev.label)
 		};
 		try {
-			const crop = await this.cropSubjectRegion(frameData, fw, fh, ev.bbox, cropPadding);
+			const crop = await this.cropSubjectRegion(frameHandle, frameData, fw, fh, ev.bbox, cropPadding);
 			await this.deps.mediaStore.put({
 				deviceId,
 				ownerKind: "event",
@@ -6483,24 +6802,7 @@ var EventMediaDispatcher = class {
 			});
 		}
 		if (ev.childCrops) for (const child of ev.childCrops) try {
-			const childRegion = squareSafeCropRegion(child.bbox, {
-				W: fw,
-				H: fh
-			}, cropPadding);
-			const childLeft = Math.max(0, Math.min(childRegion.x, fw - 1));
-			const childTop = Math.max(0, Math.min(childRegion.y, fh - 1));
-			const childWidth = Math.max(1, Math.min(childRegion.w, fw - childLeft));
-			const childHeight = Math.max(1, Math.min(childRegion.h, fh - childTop));
-			const childCropData = await sharp(frameData, { raw: {
-				width: fw,
-				height: fh,
-				channels: 3
-			} }).extract({
-				left: childLeft,
-				top: childTop,
-				width: childWidth,
-				height: childHeight
-			}).resize(CROP_WIDTH, CROP_HEIGHT).jpeg({ quality: CROP_QUALITY }).toBuffer();
+			const childCropData = await this.cropSubjectRegion(frameHandle, frameData, fw, fh, child.bbox, cropPadding);
 			await this.deps.mediaStore.put({
 				deviceId,
 				ownerKind: "event",
@@ -7661,11 +7963,89 @@ var TrackingSettingsSchema = object({
 	/** Speed (px/frame) below which a track's prediction is frozen (stationary
 	*  jitter can't drift the box off a sitting object). */
 	stationarySpeedPx: number().min(0).default(2),
+	/** Suppress + merge concurrent duplicate tracks (one subject the detector
+	*  double-fires, or a person misdetected as `animal`, otherwise becomes two
+	*  time-overlapping tracks that never re-associate — each firing its own
+	*  event). Off = legacy behaviour. */
+	dedupEnabled: boolean().default(true),
+	/** Envelope IoU at/above which a NEW spawn is treated as a duplicate of a
+	*  concurrent compatible-class track and suppressed. High so distinct
+	*  subjects appearing close together are not collapsed. */
+	dedupSpawnIou: number().min(0).max(1).default(.6),
+	/** Envelope IoU at/above which two concurrent tracks count as overlapping for
+	*  the sustained-merge streak. Kept equal to `dedupSpawnIou` by default so a
+	*  merged duplicate cannot re-spawn. */
+	dedupMergeIou: number().min(0).max(1).default(.6),
+	/** Consecutive overlapping frames before two live tracks are merged (the
+	*  lower-importance one dropped). Higher = more conservative. */
+	dedupMergeFrames: number().int().min(1).default(5),
+	/** Treat the {person,animal} class pair as duplicate-compatible — a person in
+	*  a non-upright pose is misdetected as `animal`; the false animal track
+	*  collapses into the real person track. */
+	personAnimalDedup: boolean().default(true),
+	/** A low-confidence `animal` (score below this) overlapping a concurrent
+	*  person track is suppressed at spawn. */
+	animalOverPersonMaxScore: number().min(0).max(1).default(.6),
+	/** IoU with a concurrent person track that triggers the low-confidence animal
+	*  spawn suppression. */
+	animalOverPersonIou: number().min(0).max(1).default(.2),
+	/** Resolve a track's reported class by a confidence-weighted majority over its
+	*  lifetime (vs. the latest frame) — kills per-frame class flips (a person
+	*  read as `animal` on one crouch frame keeps the `person` label). */
+	classVotingEnabled: boolean().default(true),
+	/** Winning class must hold at least this fraction of a track's total vote
+	*  weight to override the latest-frame class; below it the latest wins (so a
+	*  genuine mid-life reclassification is never frozen out). */
+	classVoteMinFraction: number().min(0).max(1).default(.5),
+	/** Enforce a per-class minimum detection score at track SPAWN (an established
+	*  track still matches below its floor — only new spawns are gated). */
+	perClassMinScoreEnabled: boolean().default(true),
+	/** Minimum spawn score for `person`. 0 = ungated (kept sensitive). */
+	minScorePerson: number().min(0).max(1).default(0),
+	/** Minimum spawn score for `animal` (FP-prone — higher floor). */
+	minScoreAnimal: number().min(0).max(1).default(.45),
+	/** Minimum spawn score for `vehicle` (FP-prone — higher floor). */
+	minScoreVehicle: number().min(0).max(1).default(.45),
+	/** Let a single very-high-confidence detection confirm a track for emission
+	*  before it reaches `minHits` (so a fast car crossing in 1-2 frames still
+	*  registers). Opt-in — default OFF keeps the strict N-hit gate. */
+	confirmBypassEnabled: boolean().default(false),
+	/** Score at/above which a detection confirms its track immediately (bypasses
+	*  `minHits`). Only consulted when `confirmBypassEnabled`. */
+	confirmBypassScore: number().min(0).max(1).default(.9),
 	/** Skip frames where detections suddenly drop to zero (detector glitch). */
 	dropoutSkipEnabled: boolean().default(true),
 	/** Max consecutive all-zero frames absorbed as a glitch before the scene is
 	*  treated as genuinely empty. */
-	dropoutMaxSkipFrames: number().int().min(0).default(5)
+	dropoutMaxSkipFrames: number().int().min(0).default(5),
+	/** Two-stage (ByteTrack) association: match high-confidence detections first,
+	*  then recover coasting tracks with the low-confidence leftovers before they
+	*  die. The single biggest fragmentation reducer. Off = legacy single pass. */
+	byteTrackEnabled: boolean().default(true),
+	/** Score at/above which a detection is HIGH (matched first); below it a detection
+	*  is LOW and only gets the second-stage recovery match. Does not gate spawning
+	*  (the per-class score/area floors do). */
+	byteTrackHighThreshold: number().min(0).max(1).default(.4),
+	/** Looser IoU gate for the low-score second (recovery) association stage — a
+	*  coasting box is stale, and the match only re-attaches an existing track. */
+	byteTrackLowIouThreshold: number().min(0).max(1).default(.2),
+	/** Enforce a per-class minimum bbox-area (fraction of frame) at track SPAWN —
+	*  kills tiny far-field / vanishing-point noise tracks. An established track
+	*  still matches a shrinking box; only spawns are gated. */
+	minSpawnAreaEnabled: boolean().default(true),
+	/** Min spawn bbox area for `person` as a fraction of the frame (0 = ungated).
+	*  Person is the only spawn-score-ungated class, so far-field person noise is
+	*  the worst offender; a conservative 0.05% rejects only vanishing-point blips. */
+	minSpawnAreaFracPerson: number().min(0).max(1).default(5e-4),
+	/** Min spawn bbox area for `animal` as a fraction of the frame (0 = ungated). */
+	minSpawnAreaFracAnimal: number().min(0).max(1).default(0),
+	/** Min spawn bbox area for `vehicle` as a fraction of the frame (0 = ungated). */
+	minSpawnAreaFracVehicle: number().min(0).max(1).default(0),
+	/** Gate association on a class GROUP ({person,animal}) instead of the exact
+	*  per-frame class, so a person that flips to `animal` for a frame re-matches
+	*  its existing track (no concurrent animal id). Reported label stays via the
+	*  class vote. Off = exact per-frame class gating. */
+	classGroupAssoc: boolean().default(true)
 });
 var TRACKING_DEFAULTS = TrackingSettingsSchema.parse({});
 /**
@@ -7695,8 +8075,31 @@ function resolveTrackingSettings(raw) {
 		rescueCentroidFactor: s.rescueCentroidFactor.catch(TRACKING_DEFAULTS.rescueCentroidFactor).parse(raw.rescueCentroidFactor),
 		resurrectionWindowMs: s.resurrectionWindowMs.catch(TRACKING_DEFAULTS.resurrectionWindowMs).parse(raw.resurrectionWindowMs),
 		stationarySpeedPx: s.stationarySpeedPx.catch(TRACKING_DEFAULTS.stationarySpeedPx).parse(raw.stationarySpeedPx),
+		dedupEnabled: s.dedupEnabled.catch(TRACKING_DEFAULTS.dedupEnabled).parse(raw.dedupEnabled),
+		dedupSpawnIou: s.dedupSpawnIou.catch(TRACKING_DEFAULTS.dedupSpawnIou).parse(raw.dedupSpawnIou),
+		dedupMergeIou: s.dedupMergeIou.catch(TRACKING_DEFAULTS.dedupMergeIou).parse(raw.dedupMergeIou),
+		dedupMergeFrames: s.dedupMergeFrames.catch(TRACKING_DEFAULTS.dedupMergeFrames).parse(raw.dedupMergeFrames),
+		personAnimalDedup: s.personAnimalDedup.catch(TRACKING_DEFAULTS.personAnimalDedup).parse(raw.personAnimalDedup),
+		animalOverPersonMaxScore: s.animalOverPersonMaxScore.catch(TRACKING_DEFAULTS.animalOverPersonMaxScore).parse(raw.animalOverPersonMaxScore),
+		animalOverPersonIou: s.animalOverPersonIou.catch(TRACKING_DEFAULTS.animalOverPersonIou).parse(raw.animalOverPersonIou),
+		classVotingEnabled: s.classVotingEnabled.catch(TRACKING_DEFAULTS.classVotingEnabled).parse(raw.classVotingEnabled),
+		classVoteMinFraction: s.classVoteMinFraction.catch(TRACKING_DEFAULTS.classVoteMinFraction).parse(raw.classVoteMinFraction),
+		perClassMinScoreEnabled: s.perClassMinScoreEnabled.catch(TRACKING_DEFAULTS.perClassMinScoreEnabled).parse(raw.perClassMinScoreEnabled),
+		minScorePerson: s.minScorePerson.catch(TRACKING_DEFAULTS.minScorePerson).parse(raw.minScorePerson),
+		minScoreAnimal: s.minScoreAnimal.catch(TRACKING_DEFAULTS.minScoreAnimal).parse(raw.minScoreAnimal),
+		minScoreVehicle: s.minScoreVehicle.catch(TRACKING_DEFAULTS.minScoreVehicle).parse(raw.minScoreVehicle),
+		confirmBypassEnabled: s.confirmBypassEnabled.catch(TRACKING_DEFAULTS.confirmBypassEnabled).parse(raw.confirmBypassEnabled),
+		confirmBypassScore: s.confirmBypassScore.catch(TRACKING_DEFAULTS.confirmBypassScore).parse(raw.confirmBypassScore),
 		dropoutSkipEnabled: s.dropoutSkipEnabled.catch(TRACKING_DEFAULTS.dropoutSkipEnabled).parse(raw.dropoutSkipEnabled),
-		dropoutMaxSkipFrames: s.dropoutMaxSkipFrames.catch(TRACKING_DEFAULTS.dropoutMaxSkipFrames).parse(raw.dropoutMaxSkipFrames)
+		dropoutMaxSkipFrames: s.dropoutMaxSkipFrames.catch(TRACKING_DEFAULTS.dropoutMaxSkipFrames).parse(raw.dropoutMaxSkipFrames),
+		byteTrackEnabled: s.byteTrackEnabled.catch(TRACKING_DEFAULTS.byteTrackEnabled).parse(raw.byteTrackEnabled),
+		byteTrackHighThreshold: s.byteTrackHighThreshold.catch(TRACKING_DEFAULTS.byteTrackHighThreshold).parse(raw.byteTrackHighThreshold),
+		byteTrackLowIouThreshold: s.byteTrackLowIouThreshold.catch(TRACKING_DEFAULTS.byteTrackLowIouThreshold).parse(raw.byteTrackLowIouThreshold),
+		minSpawnAreaEnabled: s.minSpawnAreaEnabled.catch(TRACKING_DEFAULTS.minSpawnAreaEnabled).parse(raw.minSpawnAreaEnabled),
+		minSpawnAreaFracPerson: s.minSpawnAreaFracPerson.catch(TRACKING_DEFAULTS.minSpawnAreaFracPerson).parse(raw.minSpawnAreaFracPerson),
+		minSpawnAreaFracAnimal: s.minSpawnAreaFracAnimal.catch(TRACKING_DEFAULTS.minSpawnAreaFracAnimal).parse(raw.minSpawnAreaFracAnimal),
+		minSpawnAreaFracVehicle: s.minSpawnAreaFracVehicle.catch(TRACKING_DEFAULTS.minSpawnAreaFracVehicle).parse(raw.minSpawnAreaFracVehicle),
+		classGroupAssoc: s.classGroupAssoc.catch(TRACKING_DEFAULTS.classGroupAssoc).parse(raw.classGroupAssoc)
 	};
 }
 //#endregion
@@ -8103,6 +8506,40 @@ function planPeriodicMedia(input) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/best-thumbnail-guard.ts
+/**
+* Void/envArea guard for best-`thumbnail` selection.
+*
+* ## Why this exists (the dawn/night "void" thumbnail)
+*
+* At dawn/night a moving subject's tracker box intermittently EXPLODES to
+* (near-)the whole frame — the "envelope exploded to full-frame" signature. If
+* that frame happens to win the best-detection race, the gallery/reel best
+* `thumbnail` becomes a useless full-scene tile (the subject crop is the entire
+* washed-out frame), not the subject. This guard rejects such a frame from the
+* best-`thumbnail` decision so the track keeps a real subject-centered tile.
+*
+* Conservative by design: it only rejects boxes covering ≥ {@link
+* NEAR_FULL_FRAME_AREA} of the frame — a genuine large close-up subject stays
+* well under this. Rejecting a frame does NOT land a thumbnail, so the #27-A
+* per-frame retry keeps trying until a plausible frame wins.
+*/
+/**
+* Area fraction at/above which a detection bbox is treated as an exploded
+* "envelope" (near-full-frame) box rather than a real subject. 0.85 keeps the
+* guard conservative — only boxes covering ≥85% of the frame are rejected.
+*/
+var NEAR_FULL_FRAME_AREA = .85;
+/**
+* True when `bbox` is a plausible SUBJECT box for a best `thumbnail` — i.e. its
+* area is below the near-full-frame threshold. Degenerate frame dimensions
+* (≤0) are treated as plausible (no info to reject on).
+*/
+function isPlausibleThumbnailBox(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return true;
+	return bbox.w * bbox.h / (frameWidth * frameHeight) < NEAR_FULL_FRAME_AREA;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-capture.ts
 /**
 * Pure helpers for the per-track NATIVE-resolution `keyFrame` capture
@@ -8134,11 +8571,12 @@ function planPeriodicMedia(input) {
 var KEYFRAME_NATIVE_MAX_WIDTH = 1920;
 /**
 * The tracks whose native `keyFrame` should be (re)captured THIS frame: exactly
-* the tracks that hit a new best-frame moment (`bestThumbnail`). `putReplacing`
-* downstream keeps one `keyFrame` per track (the current peak).
+* the tracks that hit a GENUINE new best-frame moment (`keyFrame`), NOT the
+* per-frame best-thumbnail retry. `putReplacing` downstream keeps one `keyFrame`
+* per track (the current peak).
 */
 function selectKeyFrameTrackIds(targets) {
-	return targets.filter((t) => t.bestThumbnail).map((t) => t.trackId);
+	return targets.filter((t) => t.keyFrame).map((t) => t.trackId);
 }
 /**
 * Build the `captureCrop` request for a track's native `keyFrame`: the FULL
@@ -8158,6 +8596,15 @@ function buildKeyFrameCaptureRequest(frameWidth, frameHeight) {
 		maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
 	};
 }
+/**
+* True when a native subject crop of `width` px is a plausible native hit worth
+* keeping, rather than a sub-threshold fallback stamp. Clamps the floor to the
+* requested `maxWidth` so a caller that legitimately asked for a narrow crop
+* (`maxWidth < MIN`) is not rejected for honouring its own cap.
+*/
+function nativeSubjectCropMeetsFloor(width, maxWidth) {
+	return width >= Math.min(320, maxWidth);
+}
 //#endregion
 //#region src/pipeline-analytics/track-retention-sweep.ts
 /**
@@ -9240,6 +9687,7 @@ var FaceRecognizer = class {
 			bbox: input.parentBbox,
 			zones: [],
 			state: "moving",
+			matchedThisFrame: true,
 			embedding: input.embedding,
 			embeddingModelId: modelId,
 			...input.faceBbox !== void 0 ? { faceBbox: input.faceBbox } : {},
@@ -11410,6 +11858,35 @@ function toAnalyticsDeviceSections(sections) {
 	}));
 }
 /**
+* Global-analytics section ids that are really per-camera DETECTION knobs and
+* belong in the consolidated `Detection pipeline → Settings` sub-tab alongside
+* Object Detection — NOT under the generic `Analytics` top-tab:
+*   - `detection-sensitivity` — minHits / cooldown / stationary threshold.
+*   - `tracking` — the tracker-tuning form incl. the FP knobs (dedup, person↔
+*     animal dedup, class voting, confirm-bypass, per-class min score).
+*   - `stationary-objects` — stationary promotion + occupancy tuning.
+* `DeviceDetail` folds `tab: 'detection-pipeline'` top-tab sections into the
+* structural Detection pipeline tab, so re-tagging is all that's needed —
+* there is no admin-ui change and no duplicate render (a section has one tab).
+*/
+var DETECTION_PIPELINE_SECTION_IDS = new Set([
+	"detection-sensitivity",
+	"tracking",
+	"stationary-objects"
+]);
+/**
+* Re-home the detection-knob sections from the `Analytics` top-tab onto the
+* `detection-pipeline` top-tab. Pure copy — only the `tab` of a matched
+* section changes; every other section (media policy, retention, faces, track
+* history) stays on Analytics.
+*/
+function retagDetectionSections(sections) {
+	return sections.map((s) => s.id !== void 0 && DETECTION_PIPELINE_SECTION_IDS.has(s.id) ? {
+		...s,
+		tab: "detection-pipeline"
+	} : s);
+}
+/**
 * Fields that live ONLY on the global settings page and must never surface in a
 * per-device contribution. The face-recognition `enabled` switch is the GLOBAL
 * master kill for the whole subsystem — per-camera face production is governed
@@ -11566,6 +12043,19 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	*  (recycled/blank live frame) still gets a subject crop for the gallery
 	*  instead of degrading to a full-scene tile. Cleared on track end + reset. */
 	thumbnailLandedTracks = /* @__PURE__ */ new Set();
+	/** Tracks with a best-`thumbnail` capture CURRENTLY in flight (RC-1). The
+	*  #27-A retry re-fired a fresh best-thumbnail capture every frame while one
+	*  was still resolving (capture latency stacks 0.1–3s under the native path),
+	*  so a short track issued N overlapping captures. While a track sits here
+	*  `buildSnapshotTargets` suppresses a new best-thumbnail request; the pending
+	*  result clears the flag (and, if it landed, sets `thumbnailLandedTracks`).
+	*  Cleared on track end + reset. */
+	thumbnailInFlight = /* @__PURE__ */ new Set();
+	/** Tracks with a native `keyFrame` capture CURRENTLY in flight (RC-1). Guards
+	*  the fire-and-forget `persistKeyFrames` so a burst of new-best frames issues
+	*  at most ONE outstanding 1920px native capture per track instead of one per
+	*  frame. Cleared when the capture settles (+ on track end / reset). */
+	keyFrameInFlight = /* @__PURE__ */ new Set();
 	/** Per-track update-gate memory for `PipelineAnalyticsTrackLifecycle`
 	*  `phase:'update'` — the last-emitted best (confidence / label / crop
 	*  area) + emit time, so a material improvement is measured against the
@@ -11791,11 +12281,6 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				timestamp: 0
 			};
 		};
-		this.eventMediaDispatcher = new EventMediaDispatcher({
-			getRemoteFrame,
-			mediaStore: this.mediaStore,
-			logger: logger.child("EventMediaDispatcher")
-		});
 		const cropMetricLogger = logger.child("NativeCrop");
 		let nativeHits = 0;
 		let nativeFallbacks = 0;
@@ -11812,7 +12297,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				detectionFrameFallbacks: nativeFallbacks
 			} });
 		};
-		const tryNativeCrop = async (frameHandle, paddedNorm, maxWidth) => {
+		const fetchNativeCropRgb = async (frameHandle, paddedNorm, maxWidth) => {
 			if (!pipelineRunnerApi?.getNativeCrop) return null;
 			try {
 				const native = await pipelineRunnerApi.getNativeCrop.query({
@@ -11821,12 +12306,42 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					...maxWidth !== void 0 ? { maxWidth } : {}
 				}, nodePin(frameHandle.nodeId));
 				if (!native || native.width <= 0 || native.height <= 0) return null;
-				return await encodeRgbCropToJpeg(Buffer.from(native.bytes), native.width, native.height);
+				return {
+					bytes: Buffer.from(native.bytes),
+					width: native.width,
+					height: native.height
+				};
 			} catch (err) {
 				cropMetricLogger.debug("native crop request failed — falling back", { meta: { error: errMsg(err) } });
 				return null;
 			}
 		};
+		const tryNativeCrop = async (frameHandle, paddedNorm, maxWidth) => {
+			const native = await fetchNativeCropRgb(frameHandle, paddedNorm, maxWidth);
+			if (!native) return null;
+			return await encodeRgbCropToJpeg(native.bytes, native.width, native.height);
+		};
+		const getNativeCropJpeg = async (frameHandle, normalizedBbox, maxWidth) => {
+			const native = await fetchNativeCropRgb(frameHandle, normalizedBbox, maxWidth);
+			if (!native || !nativeSubjectCropMeetsFloor(native.width, maxWidth)) {
+				if (native) cropMetricLogger.debug("native subject crop below floor — local fallback", { meta: {
+					width: native.width,
+					height: native.height,
+					maxWidth
+				} });
+				bumpCropMetric(false);
+				return null;
+			}
+			const jpeg = await encodeRgbCropToJpeg(native.bytes, native.width, native.height);
+			bumpCropMetric(jpeg !== null);
+			return jpeg;
+		};
+		this.eventMediaDispatcher = new EventMediaDispatcher({
+			getRemoteFrame,
+			getNativeCropJpeg,
+			mediaStore: this.mediaStore,
+			logger: logger.child("EventMediaDispatcher")
+		});
 		const resolveFrameShared = createSharedFrameResolver((frameHandle) => resolveFrame(frameHandle, { getRemoteFrame }));
 		const captureCrop = async (frameHandle, bbox, frameWidth, frameHeight, padding, maxWidth) => {
 			const paddedNorm = padBbox({
@@ -12370,6 +12885,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.bestFrameTracker.clear();
 		this.lastFrameAtByTrack.clear();
 		this.thumbnailLandedTracks.clear();
+		this.thumbnailInFlight.clear();
+		this.keyFrameInFlight.clear();
 		this.trackLifecycleUpdateMem.clear();
 		this.objectEmbeddingBestSelector.clear();
 		this.levelStateByDevice.clear();
@@ -12690,6 +13207,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					frames: captureAgg.frames,
 					...captureAgg.sums
 				} });
+				const thumbInFlightTrackIds = snapshotTargets.filter((t) => t.bestThumbnail).map((t) => t.trackId);
+				for (const trackId of thumbInFlightTrackIds) this.thumbnailInFlight.add(trackId);
 				this.eventMediaDispatcher.captureForFrame({
 					deviceId,
 					frameHandle,
@@ -12709,7 +13228,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						mediaKey: s.mediaKey
 					});
 					for (const trackId of res.thumbnailTrackIds) this.thumbnailLandedTracks.add(trackId);
-				}).catch(() => {});
+				}).catch(() => {}).finally(() => {
+					for (const trackId of thumbInFlightTrackIds) this.thumbnailInFlight.delete(trackId);
+				});
 			}
 		}
 		if (this.faceRecognizer && faceGloballyEnabled && faceSettings) this.faceRecognizer.processFrame({
@@ -13154,7 +13675,10 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		const mediaStore = this.mediaStore;
 		if (!capture || !mediaStore) return;
 		const req = buildKeyFrameCaptureRequest(frameWidth, frameHeight);
-		await Promise.all(trackIds.map(async (trackId) => {
+		const pending = trackIds.filter((id) => !this.keyFrameInFlight.has(id));
+		if (pending.length === 0) return;
+		for (const id of pending) this.keyFrameInFlight.add(id);
+		await Promise.all(pending.map(async (trackId) => {
 			try {
 				const keyFrame = await capture(frameHandle, req.bbox, frameWidth, frameHeight, req.padding, req.maxWidth);
 				if (!keyFrame) return;
@@ -13175,6 +13699,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						error: errMsg(err)
 					}
 				});
+			} finally {
+				this.keyFrameInFlight.delete(trackId);
 			}
 		}));
 	}
@@ -13236,6 +13762,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	buildSnapshotTargets(deviceId, tracked, timestamp, media, frameWidth, frameHeight) {
 		const targets = [];
 		for (const t of tracked) {
+			if (t.matchedThisFrame === false) continue;
 			const lastSnap = this.trackStore.lastSnapshotAt(t.trackId);
 			const dueSnapshot = media.saveThumbnails && evaluatePeriodicSnapshot({
 				lastSnapshotAt: lastSnap,
@@ -13267,7 +13794,10 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			});
 			if (plan.rollingLastFrame) this.lastFrameAtByTrack.set(t.trackId, timestamp);
 			if (plan.appendSnapshot) this.trackStore.markSnapshotPending(t.trackId, timestamp, t.bbox);
-			if (!plan.appendSnapshot && !plan.rollingLastFrame && !plan.bestThumbnail) continue;
+			const plausibleBox = isPlausibleThumbnailBox(t.bbox, frameWidth, frameHeight);
+			const bestThumbnail = plan.bestThumbnail && plausibleBox && !this.thumbnailInFlight.has(t.trackId);
+			const keyFrame = isNewBest && plausibleBox;
+			if (!plan.appendSnapshot && !plan.rollingLastFrame && !bestThumbnail && !keyFrame) continue;
 			targets.push({
 				trackId: t.trackId,
 				timestamp,
@@ -13275,7 +13805,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				...t.label ? { label: t.label } : {},
 				appendSnapshot: plan.appendSnapshot,
 				rollingLastFrame: plan.rollingLastFrame,
-				bestThumbnail: plan.bestThumbnail
+				bestThumbnail,
+				keyFrame
 			});
 		}
 		return targets;
@@ -13582,6 +14113,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				this.objectEmbeddingBestSelector.delete(t.trackId);
 				this.lastFrameAtByTrack.delete(t.trackId);
 				this.thumbnailLandedTracks.delete(t.trackId);
+				this.thumbnailInFlight.delete(t.trackId);
+				this.keyFrameInFlight.delete(t.trackId);
 				this.detailDispatcher?.onTrackEnded(t.deviceId, t.trackId);
 				this.overlayState.onTrackEnded(t.deviceId, t.trackId);
 				if ((this.trackStore?.getActive(t.deviceId).length ?? 0) === 0) {
@@ -13844,6 +14377,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.objectEmbeddingBestSelector.delete(track.trackId);
 		this.lastFrameAtByTrack.delete(track.trackId);
 		this.thumbnailLandedTracks.delete(track.trackId);
+		this.thumbnailInFlight.delete(track.trackId);
+		this.keyFrameInFlight.delete(track.trackId);
 		this.trackLifecycleUpdateMem.delete(track.trackId);
 		this.detailDispatcher?.onTrackEnded(deviceId, track.trackId);
 		this.overlayState.onTrackEnded(deviceId, track.trackId);
@@ -13877,7 +14412,34 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				rescueCentroidFactor: trk.rescueCentroidFactor,
 				resurrectionWindowMs: trk.resurrectionWindowMs,
 				stationarySpeedPx: trk.stationarySpeedPx,
-				maxTrackLifetimeMs: trk.maxTrackLifetimeSec * 1e3
+				maxTrackLifetimeMs: trk.maxTrackLifetimeSec * 1e3,
+				dedupEnabled: trk.dedupEnabled,
+				dedupSpawnIou: trk.dedupSpawnIou,
+				dedupMergeIou: trk.dedupMergeIou,
+				dedupMergeFrames: trk.dedupMergeFrames,
+				personAnimalDedup: trk.personAnimalDedup,
+				animalOverPersonMaxScore: trk.animalOverPersonMaxScore,
+				animalOverPersonIou: trk.animalOverPersonIou,
+				classVotingEnabled: trk.classVotingEnabled,
+				classVoteMinFraction: trk.classVoteMinFraction,
+				perClassMinScoreEnabled: trk.perClassMinScoreEnabled,
+				classMinScores: {
+					person: trk.minScorePerson,
+					animal: trk.minScoreAnimal,
+					vehicle: trk.minScoreVehicle
+				},
+				confirmBypassEnabled: trk.confirmBypassEnabled,
+				confirmBypassScore: trk.confirmBypassScore,
+				byteTrackEnabled: trk.byteTrackEnabled,
+				byteTrackHighThreshold: trk.byteTrackHighThreshold,
+				byteTrackLowIouThreshold: trk.byteTrackLowIouThreshold,
+				minSpawnAreaEnabled: trk.minSpawnAreaEnabled,
+				classSpawnAreaFracs: {
+					person: trk.minSpawnAreaFracPerson,
+					animal: trk.minSpawnAreaFracAnimal,
+					vehicle: trk.minSpawnAreaFracVehicle
+				},
+				classGroupAssoc: trk.classGroupAssoc
 			}, { stationaryThresholdSec }, {
 				minTrackAge,
 				cooldownSec,
@@ -15180,6 +15742,69 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						default: TRACKING_DEFAULTS.occlusionMaxMissedMs,
 						unit: "ms"
 					},
+					{
+						type: "boolean",
+						key: "dedupEnabled",
+						label: "Duplicate-track suppression",
+						description: "Suppress and merge concurrent duplicate tracks. Stops one subject the detector double-fires (two boxes for one object, or a person misdetected as an animal) from becoming several time-overlapping tracks that each fire their own event. Off = legacy behaviour.",
+						default: TRACKING_DEFAULTS.dedupEnabled
+					},
+					{
+						type: "number",
+						key: "dedupSpawnIou",
+						label: "Duplicate spawn IoU",
+						description: "Overlap at/above which a NEW track is treated as a duplicate of a concurrent same-kind track and not created. High so two distinct subjects appearing close together are still tracked separately.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.dedupSpawnIou
+					},
+					{
+						type: "number",
+						key: "dedupMergeIou",
+						label: "Duplicate merge IoU",
+						description: "Overlap at/above which two concurrent same-kind tracks count as overlapping for the sustained-merge test.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.dedupMergeIou
+					},
+					{
+						type: "number",
+						key: "dedupMergeFrames",
+						label: "Duplicate merge frames",
+						description: "Consecutive overlapping frames before two concurrent tracks are merged (the shorter / lower-importance one is dropped). Higher = more conservative (only merge sustained overlaps).",
+						min: 1,
+						step: 1,
+						default: TRACKING_DEFAULTS.dedupMergeFrames
+					},
+					{
+						type: "boolean",
+						key: "personAnimalDedup",
+						label: "Person/animal duplicate merge",
+						description: "Treat an animal track overlapping a person track as the same subject (a person in a crouching / bending pose is often misdetected as an animal). The person track wins.",
+						default: TRACKING_DEFAULTS.personAnimalDedup
+					},
+					{
+						type: "number",
+						key: "animalOverPersonMaxScore",
+						label: "Animal-over-person max score",
+						description: "A low-confidence animal detection (score below this) sitting on a concurrent person track is suppressed — the common person-in-odd-pose false animal.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.animalOverPersonMaxScore
+					},
+					{
+						type: "number",
+						key: "animalOverPersonIou",
+						label: "Animal-over-person IoU",
+						description: "Overlap with a concurrent person track that triggers the low-confidence animal spawn suppression.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.animalOverPersonIou
+					},
 					{
 						type: "boolean",
 						key: "dropoutSkipEnabled",
@@ -15195,6 +15820,148 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						min: 0,
 						step: 1,
 						default: TRACKING_DEFAULTS.dropoutMaxSkipFrames
+					},
+					{
+						type: "boolean",
+						key: "classVotingEnabled",
+						label: "Per-track class voting",
+						description: "Report a track’s class by a confidence-weighted majority over its whole life instead of the latest frame — a person read as an animal on a single crouch/bend frame keeps the person label.",
+						default: TRACKING_DEFAULTS.classVotingEnabled
+					},
+					{
+						type: "number",
+						key: "classVoteMinFraction",
+						label: "Class-vote min fraction",
+						description: "The winning class must hold at least this fraction of a track’s total vote weight to override the latest frame; below it the latest frame wins (so a genuine mid-life reclassification is not frozen out).",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.classVoteMinFraction
+					},
+					{
+						type: "boolean",
+						key: "perClassMinScoreEnabled",
+						label: "Per-class spawn confidence",
+						description: "Require a per-class minimum detection score before a NEW track is created. Kills static-object / reflection false spawns from the FP-prone classes. An already-tracked object still matches on a low-confidence frame.",
+						default: TRACKING_DEFAULTS.perClassMinScoreEnabled
+					},
+					{
+						type: "number",
+						key: "minScorePerson",
+						label: "Min spawn score — person",
+						description: "Minimum score to spawn a person track. 0 keeps person fully sensitive.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.minScorePerson
+					},
+					{
+						type: "number",
+						key: "minScoreAnimal",
+						label: "Min spawn score — animal",
+						description: "Minimum score to spawn an animal track (FP-prone — a higher floor drops low-confidence static-object false animals).",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.minScoreAnimal
+					},
+					{
+						type: "number",
+						key: "minScoreVehicle",
+						label: "Min spawn score — vehicle",
+						description: "Minimum score to spawn a vehicle track (FP-prone — a higher floor drops low-confidence false vehicles).",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.minScoreVehicle
+					},
+					{
+						type: "boolean",
+						key: "confirmBypassEnabled",
+						label: "Fast high-confidence confirm",
+						description: "Let a single very-high-confidence detection confirm a track for events before it reaches the min-hits gate, so a fast subject crossing in 1-2 frames (a passing car) still registers. Off by default (strict N-hit confirmation).",
+						default: TRACKING_DEFAULTS.confirmBypassEnabled
+					},
+					{
+						type: "number",
+						key: "confirmBypassScore",
+						label: "Fast-confirm score",
+						description: "Score at/above which a detection confirms its track immediately, bypassing min-hits. Only used when fast high-confidence confirm is on.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.confirmBypassScore
+					},
+					{
+						type: "boolean",
+						key: "byteTrackEnabled",
+						label: "Two-stage association (ByteTrack)",
+						description: "Match high-confidence detections first, then recover coasting tracks with the low-confidence leftovers before they die. The single biggest fix for a subject fragmenting into many tracks. Off = legacy single pass.",
+						default: TRACKING_DEFAULTS.byteTrackEnabled
+					},
+					{
+						type: "number",
+						key: "byteTrackHighThreshold",
+						label: "Two-stage high threshold",
+						description: "Score at/above which a detection is matched in the first stage. Below it a detection is LOW and gets a second, looser recovery match against still-unmatched (coasting) tracks. This does not change which detections can start a track (the spawn confidence/size floors do). Only used with two-stage association.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.byteTrackHighThreshold
+					},
+					{
+						type: "number",
+						key: "byteTrackLowIouThreshold",
+						label: "Two-stage low IoU",
+						description: "Looser overlap gate for re-attaching a low-confidence detection to a coasting track in the second stage. Only used with two-stage association.",
+						min: 0,
+						max: 1,
+						step: .05,
+						default: TRACKING_DEFAULTS.byteTrackLowIouThreshold
+					},
+					{
+						type: "boolean",
+						key: "minSpawnAreaEnabled",
+						label: "Minimum spawn size",
+						description: "Require a new track’s box to cover at least a minimum fraction of the frame before it is created — stops tiny far-field / vanishing-point blips from spawning full tracks. An already-tracked subject that shrinks into the distance is unaffected.",
+						default: TRACKING_DEFAULTS.minSpawnAreaEnabled
+					},
+					{
+						type: "number",
+						key: "minSpawnAreaFracPerson",
+						label: "Min spawn area — person",
+						description: "Smallest person box (as a fraction of the frame area) allowed to start a NEW track. 0 = ungated. Conservative default (0.0005 = 0.05% of frame) drops only vanishing-point noise. Raise on cameras with a distant road / horizon.",
+						min: 0,
+						max: 1,
+						step: 5e-4,
+						default: TRACKING_DEFAULTS.minSpawnAreaFracPerson
+					},
+					{
+						type: "number",
+						key: "minSpawnAreaFracAnimal",
+						label: "Min spawn area — animal",
+						description: "Smallest animal box (fraction of frame area) allowed to start a NEW track. 0 = ungated (animal already has a spawn-score floor).",
+						min: 0,
+						max: 1,
+						step: 5e-4,
+						default: TRACKING_DEFAULTS.minSpawnAreaFracAnimal
+					},
+					{
+						type: "number",
+						key: "minSpawnAreaFracVehicle",
+						label: "Min spawn area — vehicle",
+						description: "Smallest vehicle box (fraction of frame area) allowed to start a NEW track. 0 = ungated (vehicle already has a spawn-score floor).",
+						min: 0,
+						max: 1,
+						step: 5e-4,
+						default: TRACKING_DEFAULTS.minSpawnAreaFracVehicle
+					},
+					{
+						type: "boolean",
+						key: "classGroupAssoc",
+						label: "Person/animal group matching",
+						description: "Let a detection that flips between person and animal for a frame (a crouching / bending person is often read as an animal) re-match its existing track instead of spawning a concurrent animal track. The reported class is still decided by the per-track class vote.",
+						default: TRACKING_DEFAULTS.classGroupAssoc
 					}
 				]
 			},
@@ -15270,7 +16037,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		const raw = await this.ctx?.settings?.readDeviceStore(input.deviceId) ?? {};
 		const baseSections = schema ? hydrateSchema({
 			...schema,
-			sections: stripGlobalOnlyFields(toAnalyticsDeviceSections(schema.sections))
+			sections: retagDetectionSections(stripGlobalOnlyFields(toAnalyticsDeviceSections(schema.sections)))
 		}, raw).sections : [];
 		const liveStatsSection = {
 			id: "live-stats",
@@ -15319,4 +16086,4 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { PipelineAnalyticsAddon as default, pickCleanMedia, stripGlobalOnlyFields, toAnalyticsDeviceSections };
+export { DETECTION_PIPELINE_SECTION_IDS, PipelineAnalyticsAddon as default, pickCleanMedia, retagDetectionSections, stripGlobalOnlyFields, toAnalyticsDeviceSections };