@camstack/addon-post-analysis 1.1.36 → 1.1.38

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-Bc4L7FGf.js");
+const require_dist = require("../dist-_h-RM5Lr.js");
 let node_crypto = require("node:crypto");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
@@ -1125,8 +1125,29 @@ 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
 };
+/** 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));
@@ -1149,16 +1170,102 @@ 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}`;
+	}
+	/**
+	* 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
@@ -1193,6 +1300,46 @@ var SortTracker = class {
 		const diag = Math.hypot(track.bbox.w, track.bbox.h);
 		return dist <= this.config.rescueCentroidFactor * diag;
 	}
+	/** 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;
+			}
+		}
+		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;
+	}
 	update(detections, timestamp) {
 		if (this.config.maxTrackLifetimeMs > 0) {
 			const alive = [];
@@ -1277,6 +1424,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);
@@ -1326,13 +1474,30 @@ 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.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: (0, node_crypto.randomUUID)(),
 				bbox: det.bbox,
@@ -1350,12 +1515,14 @@ 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,
@@ -1384,6 +1551,7 @@ var SortTracker = class {
 	reset() {
 		this.tracks = [];
 		this.lostTracks = [];
+		this.dupStreaks.clear();
 	}
 };
 //#endregion
@@ -2137,6 +2305,29 @@ function isEdgeClear(input) {
 	return true;
 }
 /**
+* Centeredness of a bbox: 1 when the subject's centre sits exactly at the frame
+* centre, decaying toward 0 as it approaches a corner. Pure geometry (no pixels)
+* — a cheap proxy for "is the subject well-framed?" used as the best-frame
+* tie-breaker so a low-importance short track stops locking in an edge-of-frame
+* subject when a better-centred, near-equal-confidence frame is available.
+*
+* The score is `1 - normalizedDistance(centre → frameCentre)`, where the
+* distance is normalised by the max possible (centre → corner) so it is
+* scale-invariant. Degenerate/unknown dims (≤ 0) return 1 (neutral — the gate
+* falls back to pure confidence, matching {@link isEdgeClear}).
+*/
+function bboxCenterScore(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return 1;
+	const cx = bbox.x + bbox.w / 2;
+	const cy = bbox.y + bbox.h / 2;
+	const fcx = frameWidth / 2;
+	const fcy = frameHeight / 2;
+	const dx = (cx - fcx) / fcx;
+	const dy = (cy - fcy) / fcy;
+	const dist = Math.hypot(dx, dy) / Math.SQRT2;
+	return Math.max(0, Math.min(1, 1 - dist));
+}
+/**
 * Edge-aware "is `candidate` a new best over `current`?" comparator.
 *
 * Tier order: edge-clear ALWAYS outranks edge-touching (a whole subject beats a
@@ -2144,13 +2335,25 @@ function isEdgeClear(input) {
 * confidence past the `hysteresis` margin wins. The tier upgrade
 * (touching → clear) bypasses hysteresis — the first clear frame is always taken.
 *
+* CENTERING TIE-BREAK (#27-D): within the same tier, when neither frame clearly
+* wins on confidence (the two are within the `hysteresis` band) but the
+* candidate is meaningfully better CENTRED ({@link CENTER_TIE_BREAK_MARGIN}), the
+* candidate wins. This only engages when both sides carry a `centerScore` (the
+* best-frame path), so low-importance short tracks stop keeping an edge-of-frame
+* subject over an equally-confident, better-framed one. The face /
+* object-embedding callers omit `centerScore` → identical legacy behaviour.
+*
 * Time gating (`minGapMs`) is applied by the caller (`BestDetectionTracker`),
 * not here, so this stays a pure value comparison.
 */
 function isEdgeAwareNewBest(current, candidate, hysteresis) {
 	if (candidate.edgeClear && !current.edgeClear) return true;
 	if (!candidate.edgeClear && current.edgeClear) return false;
-	return candidate.confidence > current.confidence + hysteresis;
+	if (candidate.confidence > current.confidence + hysteresis) return true;
+	if (candidate.centerScore !== void 0 && current.centerScore !== void 0) {
+		if (Math.abs(candidate.confidence - current.confidence) <= hysteresis && candidate.centerScore > current.centerScore + .1) return true;
+	}
+	return false;
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/best-detection-tracker.ts
@@ -2186,6 +2389,10 @@ var BestDetectionTracker = class {
 	*  the edge tier is not in play for the track (treated as clear → the legacy
 	*  pure-confidence policy). */
 	edgeClear = /* @__PURE__ */ new Map();
+	/** Held peak's centeredness (0..1), PARALLEL to `best`. Absent = the caller
+	*  does not supply centering (face / object-embedding paths) → the centering
+	*  tie-break is disabled and the legacy confidence policy applies. */
+	centerScore = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.hysteresis = options.hysteresis ?? 0;
 		this.minGapMs = options.minGapMs ?? 0;
@@ -2202,7 +2409,7 @@ var BestDetectionTracker = class {
 	* the classic policy holds: a confidence past the `hysteresis` margin that also
 	* respects `minGapMs` wins. On acceptance the held peak advances.
 	*/
-	observe(trackId, confidence, timestamp, edgeClear) {
+	observe(trackId, confidence, timestamp, edgeClear, centerScore) {
 		const cur = this.best.get(trackId);
 		if (cur === void 0) {
 			this.best.set(trackId, {
@@ -2210,16 +2417,20 @@ var BestDetectionTracker = class {
 				atMs: timestamp
 			});
 			if (edgeClear !== void 0) this.edgeClear.set(trackId, edgeClear);
+			if (centerScore !== void 0) this.centerScore.set(trackId, centerScore);
 			return true;
 		}
 		const curClear = this.edgeClear.get(trackId) ?? true;
 		const candClear = edgeClear ?? true;
+		const curCenter = this.centerScore.get(trackId);
 		const isNewBest = candClear && !curClear ? true : isEdgeAwareNewBest({
 			confidence: cur.confidence,
-			edgeClear: curClear
+			edgeClear: curClear,
+			...curCenter !== void 0 ? { centerScore: curCenter } : {}
 		}, {
 			confidence,
-			edgeClear: candClear
+			edgeClear: candClear,
+			...centerScore !== void 0 ? { centerScore } : {}
 		}, this.hysteresis) && timestamp - cur.atMs >= this.minGapMs;
 		if (isNewBest) {
 			this.best.set(trackId, {
@@ -2227,6 +2438,7 @@ var BestDetectionTracker = class {
 				atMs: timestamp
 			});
 			if (edgeClear !== void 0) this.edgeClear.set(trackId, edgeClear);
+			if (centerScore !== void 0) this.centerScore.set(trackId, centerScore);
 		}
 		return isNewBest;
 	}
@@ -2238,10 +2450,12 @@ var BestDetectionTracker = class {
 	delete(trackId) {
 		this.best.delete(trackId);
 		this.edgeClear.delete(trackId);
+		this.centerScore.delete(trackId);
 	}
 	clear() {
 		this.best.clear();
 		this.edgeClear.clear();
+		this.centerScore.clear();
 	}
 };
 //#endregion
@@ -2394,6 +2608,9 @@ var WAKE_ASSOC_IOU = .1;
 * long) so a freshly-spawned static blob isn't promoted instantly.
 */
 var PROMOTION_WINDOW_MS = 3e4;
+/** Unconfirmed-entry time-to-live: if no detection confirms an entry for this
+*  long (object removed while unobserved, or a long occlusion) → retire it. */
+var ENTRY_TTL_MS = 5 * 6e4;
 var DEFAULT_MATCH_CONFIG = {
 	suppressIou: SUPPRESS_IOU,
 	wakeAssocIou: WAKE_ASSOC_IOU
@@ -2601,6 +2818,7 @@ var StationaryObjectRegistry = class {
 	logger;
 	matchConfig;
 	entryTtlMs;
+	ttlForDevice;
 	onChange;
 	/** Latest processed-frame timestamp per device — expiry counts OBSERVED
 	*  time, not wall-clock. A session-dispatch camera produces no frames
@@ -2612,6 +2830,7 @@ var StationaryObjectRegistry = class {
 		this.logger = deps.logger;
 		this.matchConfig = deps.matchConfig ?? DEFAULT_MATCH_CONFIG;
 		this.entryTtlMs = deps.entryTtlMs ?? 3e5;
+		this.ttlForDevice = deps.ttlForDevice;
 		this.onChange = deps.onChange;
 	}
 	static async declare(store) {
@@ -2667,7 +2886,7 @@ var StationaryObjectRegistry = class {
 	* entries. PURE with respect to registry state — apply the outcome with
 	* {@link applyFrameOutcome} once the frame result is assembled.
 	*/
-	filter(input) {
+	filter(input, config) {
 		const entries = this.list(input.deviceId);
 		if (entries.length === 0) return {
 			suppressedIndices: /* @__PURE__ */ new Set(),
@@ -2677,7 +2896,7 @@ var StationaryObjectRegistry = class {
 		return partitionDetectionsAgainstRegistry({
 			entries,
 			detections: input.detections,
-			config: this.matchConfig
+			config: config ?? this.matchConfig
 		});
 	}
 	/** Fold a frame's gate result back into state: advance confirmed entries'
@@ -2746,7 +2965,8 @@ var StationaryObjectRegistry = class {
 		for (const [deviceId, m] of this.byDevice) {
 			const observedAt = this.lastFrameAtByDevice.get(deviceId);
 			if (observedAt === void 0) continue;
-			for (const [id, e] of m) if (observedAt - e.lastConfirmedAt > this.entryTtlMs) {
+			const ttl = this.ttlForDevice?.(deviceId) ?? this.entryTtlMs;
+			for (const [id, e] of m) if (observedAt - e.lastConfirmedAt > ttl) {
 				m.delete(id);
 				this.dirty.delete(id);
 				retired.push(e);
@@ -2895,6 +3115,55 @@ function computeStationaryEntryZones(entry, zones) {
 	return matched;
 }
 //#endregion
+//#region src/pipeline-analytics/stationary-settings.ts
+/**
+* Per-device stationary-object (parked/idle suppression) settings. Cascade: a
+* per-device override on top of the global default, resolved per field (an
+* invalid/missing value falls back to its default — parse never throws).
+* Mirrors `media-settings` / `tracking-settings`.
+*
+* The defaults are the SAME constants the registry uses at runtime
+* (`stationary-types.ts`), imported (not copied) so an unset value and a reset
+* value both resolve to exactly today's behaviour — "reset == unset == today",
+* with no drift. Guarded by a unit test asserting the equality.
+*/
+var StationarySettingsSchema = require_dist.object({
+	/** Master switch. Off ⇒ no promotion + no suppression for this camera (every
+	*  parked object keeps spawning normal tracks). */
+	enabled: require_dist.boolean().default(true),
+	/** IoU at/above which a detection is the same parked object, unmoved →
+	*  suppress its spawn. `SUPPRESS_IOU`. */
+	suppressIou: require_dist.number().min(.3).max(.9).default(SUPPRESS_IOU),
+	/** Minimum IoU for a detection to be ASSOCIATED with an entry (confirm or
+	*  wake it) — the overlap gate that stops a different vehicle from waking a
+	*  parked entry (the 617 flood fix). `WAKE_ASSOC_IOU`. */
+	wakeAssocIou: require_dist.number().min(.02).max(.5).default(WAKE_ASSOC_IOU),
+	/** Recent-window stillness a track must hold to be PROMOTED to a parked
+	*  entry (also the minimum track age). `PROMOTION_WINDOW_MS`. */
+	promotionWindowMs: require_dist.number().int().min(5e3).max(12e4).default(PROMOTION_WINDOW_MS),
+	/** Observed-time TTL: retire an entry unconfirmed for this long (measured on
+	*  frames-flowing time, not wall-clock). `ENTRY_TTL_MS`. */
+	entryTtlMs: require_dist.number().int().min(6e4).max(18e5).default(ENTRY_TTL_MS)
+});
+var STATIONARY_DEFAULTS = StationarySettingsSchema.parse({});
+/**
+* Resolve a per-device store blob into typed stationary settings. Unknown/invalid
+* fields fall back to the default for that field (never throws on a bad blob).
+*/
+function resolveStationarySettings(raw) {
+	const pick = (key) => {
+		const parsed = StationarySettingsSchema.shape[key].safeParse(raw[key]);
+		return parsed.success ? parsed.data : STATIONARY_DEFAULTS[key];
+	};
+	return {
+		enabled: pick("enabled"),
+		suppressIou: pick("suppressIou"),
+		wakeAssocIou: pick("wakeAssocIou"),
+		promotionWindowMs: pick("promotionWindowMs"),
+		entryTtlMs: pick("entryTtlMs")
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/track-appearance.ts
 /**
 * Pure: no side effects. `continuing` = still active from last frame;
@@ -5828,6 +6097,22 @@ async function ingestSensorStateChange(deps, data, timestamp) {
 	}
 	return inserted;
 }
+/** JPEG quality for the downscaled full frame — matches the crop path. */
+var FULL_FRAME_QUALITY = 80;
+/**
+* Downscale an already-encoded JPEG full frame to FIT WITHIN
+* {@link FULL_FRAME_MAX_WIDTH}×{@link FULL_FRAME_MAX_HEIGHT}, preserving aspect
+* ratio (`fit: 'inside'`) and never enlarging a source already smaller than the
+* box. Re-encodes as JPEG. Used before persisting a synthetic sensor/control
+* track's whole-scene snapshot so a raw native-resolution frame (a 4K bedroom
+* at night) is never stored or served — the privacy fix moved to CAPTURE time.
+*/
+async function downscaleFullFrameJpeg(jpeg, maxWidth = 640, maxHeight = 360) {
+	return (0, sharp.default)(Buffer.from(jpeg)).resize(maxWidth, maxHeight, {
+		fit: "inside",
+		withoutEnlargement: true
+	}).jpeg({ quality: FULL_FRAME_QUALITY }).toBuffer();
+}
 //#endregion
 //#region src/pipeline-analytics/services/synthetic-sensor-track.ts
 /**
@@ -5892,7 +6177,13 @@ var SyntheticSensorTrackMaterializer = class {
 				force: true
 			});
 			if (snap !== null) {
-				const data = Buffer.from(snap.base64, "base64");
+				const raw = Buffer.from(snap.base64, "base64");
+				let data = raw;
+				try {
+					data = await downscaleFullFrameJpeg(raw);
+				} catch (err) {
+					this.deps.onError?.("downscaleSnapshot", err);
+				}
 				mediaKey = await this.deps.media.put({
 					deviceId: input.cameraId,
 					ownerKind: "track",
@@ -5978,6 +6269,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 = require_dist.DEFAULT_EVENT_COLOR;
@@ -6055,10 +6365,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;
@@ -6111,7 +6431,10 @@ var EventMediaDispatcher = class {
 	async captureForFrame(input) {
 		const { deviceId, frameHandle, events, trackFrames } = input;
 		const snapshots = input.snapshots ?? [];
-		const empty = { storedSnapshots: [] };
+		const empty = {
+			storedSnapshots: [],
+			thumbnailTrackIds: []
+		};
 		if (events.length === 0 && trackFrames.length === 0 && snapshots.length === 0) return empty;
 		let decoded;
 		try {
@@ -6162,14 +6485,19 @@ 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 stored = await this.writeTrackSnapshot(deviceId, frameData, fw, fh, sn, input.cropPadding);
-			if (stored) storedSnapshots.push(stored);
+			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);
 		}
-		return { storedSnapshots };
+		return {
+			storedSnapshots,
+			thumbnailTrackIds
+		};
 	}
 	/**
 	* Periodic per-track media (§5). The boxed FULL frame is encoded once and
@@ -6180,10 +6508,14 @@ var EventMediaDispatcher = class {
 	* object event, and a full frame there shows the scene (e.g. a foreground
 	* parked car), not the track's subject. Returns the appended snapshot for
 	* TrackStore wiring (null when `appendSnapshot` is false or the encode
-	* failed).
+	* 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) {
-		if (!sn.appendSnapshot && !sn.rollingLastFrame && !sn.bestThumbnail) return null;
+	async writeTrackSnapshot(deviceId, frameHandle, frameData, fw, fh, sn, cropPadding) {
+		if (!sn.appendSnapshot && !sn.rollingLastFrame && !sn.bestThumbnail) return {
+			storedSnapshot: null,
+			thumbnailWritten: false
+		};
 		let boxed = null;
 		if (sn.appendSnapshot || sn.rollingLastFrame) try {
 			boxed = await drawBoxedFrame(frameData, fw, fh, [{
@@ -6218,9 +6550,10 @@ var EventMediaDispatcher = class {
 			};
 		} catch {}
 		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);
-			await this.replaceKind(deviceId, sn.trackId, "thumbnail", sn.timestamp, crop);
+			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", {
 				tags: { deviceId },
@@ -6230,17 +6563,46 @@ var EventMediaDispatcher = class {
 					error: err instanceof Error ? err.message : String(err)
 				}
 			});
-			if (boxed) await this.replaceKind(deviceId, sn.trackId, "thumbnail", sn.timestamp, boxed);
+			if (boxed) thumbnailWritten = await this.replaceKind(deviceId, sn.trackId, "thumbnail", sn.timestamp, boxed);
 		}
-		return stored;
+		return {
+			storedSnapshot: stored,
+			thumbnailWritten
+		};
 	}
 	/**
-	* 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(frameData, fw, fh, bbox, cropPadding) {
+	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 cropSubjectRegionLocal(frameData, fw, fh, bbox, cropPadding) {
 		const region = squareSafeCropRegion(bbox, {
 			W: fw,
 			H: fh
@@ -6270,6 +6632,7 @@ var EventMediaDispatcher = class {
 				timestamp,
 				data
 			});
+			return true;
 		} catch (err) {
 			this.deps.logger.debug(`event media: ${kind} replace failed`, {
 				tags: { deviceId },
@@ -6279,15 +6642,16 @@ var EventMediaDispatcher = class {
 					error: err instanceof Error ? err.message : String(err)
 				}
 			});
+			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",
@@ -6347,24 +6711,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 (0, sharp.default)(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",
@@ -7525,6 +7872,56 @@ var TrackingSettingsSchema = require_dist.object({
 	/** Speed (px/frame) below which a track's prediction is frozen (stationary
 	*  jitter can't drift the box off a sitting object). */
 	stationarySpeedPx: require_dist.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: require_dist.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: require_dist.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: require_dist.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: require_dist.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: require_dist.boolean().default(true),
+	/** A low-confidence `animal` (score below this) overlapping a concurrent
+	*  person track is suppressed at spawn. */
+	animalOverPersonMaxScore: require_dist.number().min(0).max(1).default(.6),
+	/** IoU with a concurrent person track that triggers the low-confidence animal
+	*  spawn suppression. */
+	animalOverPersonIou: require_dist.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: require_dist.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: require_dist.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: require_dist.boolean().default(true),
+	/** Minimum spawn score for `person`. 0 = ungated (kept sensitive). */
+	minScorePerson: require_dist.number().min(0).max(1).default(0),
+	/** Minimum spawn score for `animal` (FP-prone — higher floor). */
+	minScoreAnimal: require_dist.number().min(0).max(1).default(.45),
+	/** Minimum spawn score for `vehicle` (FP-prone — higher floor). */
+	minScoreVehicle: require_dist.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: require_dist.boolean().default(false),
+	/** Score at/above which a detection confirms its track immediately (bypasses
+	*  `minHits`). Only consulted when `confirmBypassEnabled`. */
+	confirmBypassScore: require_dist.number().min(0).max(1).default(.9),
 	/** Skip frames where detections suddenly drop to zero (detector glitch). */
 	dropoutSkipEnabled: require_dist.boolean().default(true),
 	/** Max consecutive all-zero frames absorbed as a glitch before the scene is
@@ -7559,6 +7956,21 @@ 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)
 	};
@@ -7581,15 +7993,30 @@ var FaceSettingsSchema = require_dist.object({
 	*/
 	enabled: require_dist.boolean().default(true),
 	/** Cosine similarity (on L2-normalized arcface vectors) required to match. */
-	similarityThreshold: require_dist.number().min(0).max(1).default(.45),
+	similarityThreshold: require_dist.number().min(0).max(1).default(.55),
 	/** Reject ambiguous matches: require best − secondBest ≥ margin. */
-	margin: require_dist.number().min(0).max(1).default(.05),
+	margin: require_dist.number().min(0).max(1).default(.1),
 	/** Minimum face-detection confidence for a face to be considered. */
 	minFaceConfidence: require_dist.number().min(0).max(1).default(.5),
+	/**
+	* Minimum face bbox size (px, shorter side of the face box in detection-frame
+	* space) for a face to be eligible for embedding-based auto-matching. Below
+	* this, ArcFace resolution is unreliable and auto-assignment produces the
+	* observed false positives (tiny/distant faces collapsing onto one identity).
+	* Such faces are dropped BEFORE matching/enrolment (#26.1).
+	*/
+	minFacePx: require_dist.number().min(0).default(30),
+	/**
+	* Minimum enrolled-sample count an identity must have before it can be an
+	* AUTO-MATCH target. A single-sample identity is an unreliable sink (one noisy
+	* enrolment attracted 81% of matches); identities below this are excluded from
+	* automatic matching until more samples are enrolled (#26.3).
+	*/
+	minIdentitySamples: require_dist.number().int().min(1).default(2),
 	/** Frames an identity must be confirmed before a track is assigned. Floor of
 	*  1 (0 confirmations would assign on a single noisy frame — nonsensical;
 	*  such a value falls back to the default). */
-	confirmFrames: require_dist.number().int().min(1).default(2),
+	confirmFrames: require_dist.number().int().min(1).default(3),
 	/** Recent-faces buffer retention (days). */
 	bufferRetentionDays: require_dist.number().min(0).default(3),
 	/** Max buffered faces kept per device. */
@@ -7606,6 +8033,8 @@ function resolveFaceSettings(raw) {
 		similarityThreshold: pick("similarityThreshold"),
 		margin: pick("margin"),
 		minFaceConfidence: pick("minFaceConfidence"),
+		minFacePx: pick("minFacePx"),
+		minIdentitySamples: pick("minIdentitySamples"),
 		confirmFrames: pick("confirmFrames"),
 		bufferRetentionDays: pick("bufferRetentionDays"),
 		bufferMaxPerDevice: pick("bufferMaxPerDevice")
@@ -7941,13 +8370,49 @@ function evaluatePeriodicSnapshot(input) {
 */
 function planPeriodicMedia(input) {
 	const appendSnapshot = input.dueSnapshot;
+	const rollingLastFrame = input.saveThumbnails && input.now - input.lastFrameAt >= input.intervalMs && !appendSnapshot;
+	const thumbnailLanded = input.thumbnailLanded ?? true;
 	return {
 		appendSnapshot,
-		rollingLastFrame: input.saveThumbnails && input.now - input.lastFrameAt >= input.intervalMs && !appendSnapshot,
-		bestThumbnail: input.isNewBest
+		rollingLastFrame,
+		bestThumbnail: input.isNewBest || !thumbnailLanded
 	};
 }
 //#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
@@ -8927,6 +9392,21 @@ var ObjectEmbeddingStore = class {
 //#endregion
 //#region src/pipeline-analytics/pipeline/face-matcher.ts
 /**
+* Count enrolled samples per identity for probes of a matching model+dimension.
+* Only identities meeting `minIdentitySamples` are eligible auto-match targets.
+*/
+function eligibleIdentities(gallery, probeModelId, probeDim, minIdentitySamples) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const s of gallery) {
+		if (s.modelId !== probeModelId) continue;
+		if (s.embedding.length !== probeDim) continue;
+		counts.set(s.identityId, (counts.get(s.identityId) ?? 0) + 1);
+	}
+	const eligible = /* @__PURE__ */ new Set();
+	for (const [id, count] of counts) if (count >= minIdentitySamples) eligible.add(id);
+	return eligible;
+}
+/**
 * Assign at most one identity per track AND at most one track per identity for
 * a single frame. Greedy by score: compute every candidate's full ranked match
 * list, then repeatedly take the globally-highest (track, identity) pair whose
@@ -8937,10 +9417,12 @@ function assignUniquePerFrame(candidates, gallery, opts) {
 	const pairs = [];
 	candidates.forEach((c, trackIdx) => {
 		const probeVec = new Float32Array(c.embedding);
+		const eligible = eligibleIdentities(gallery, c.modelId, c.embedding.length, opts.minIdentitySamples ?? 1);
 		const bestByIdentity = /* @__PURE__ */ new Map();
 		for (const s of gallery) {
 			if (s.modelId !== c.modelId) continue;
 			if (s.embedding.length !== c.embedding.length) continue;
+			if (!eligible.has(s.identityId)) continue;
 			const score = require_dist.cosineSimilarity(probeVec, new Float32Array(s.embedding));
 			const prev = bestByIdentity.get(s.identityId);
 			if (prev === void 0 || score > prev) bestByIdentity.set(s.identityId, score);
@@ -9086,7 +9568,7 @@ var FaceRecognizer = class {
 	}
 	async processFrame(input) {
 		const { settings } = input;
-		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence);
+		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence && (t.faceBbox === void 0 || Math.min(t.faceBbox.w, t.faceBbox.h) >= settings.minFacePx));
 		if (candidates.length === 0) return;
 		this.deps.logger.debug("face: frame candidates", {
 			tags: { deviceId: input.deviceId },
@@ -9102,7 +9584,8 @@ var FaceRecognizer = class {
 			modelId: c.embeddingModelId
 		})), this.gallery, {
 			threshold: settings.similarityThreshold,
-			margin: settings.margin
+			margin: settings.margin,
+			minIdentitySamples: settings.minIdentitySamples
 		}) : /* @__PURE__ */ new Map();
 		const labelWork = [];
 		for (const c of candidates) {
@@ -11237,6 +11720,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
@@ -11349,6 +11861,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	faceGlobalEnabledCache = null;
 	mediaCacheByDevice = /* @__PURE__ */ new Map();
 	packageDropCacheByDevice = /* @__PURE__ */ new Map();
+	/** Per-device stationary settings cache (#31), TTL-mirrored like media/tracking.
+	*  The registry is a single shared instance, so per-(device) suppress/wake IoU,
+	*  promotion window, TTL and the master toggle are resolved from this cache at
+	*  the partition + promotion + sweep call sites — an operator change takes
+	*  effect within one SETTINGS_CACHE_TTL_MS tick without an addon restart. */
+	stationaryCacheByDevice = /* @__PURE__ */ new Map();
 	/** Turns stationary appear/depart into package-delivered/picked-up events. */
 	packageDropDetector = null;
 	/** Consecutive detector-dropout frames skipped per (deviceId, source) key. */
@@ -11381,6 +11899,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  where no `snapshot` is appended, so it is never byte-identical to a stored
 	*  `snapshot` (kills the end-of-track duplicate). Cleared on track end. */
 	lastFrameAtByTrack = /* @__PURE__ */ new Map();
+	/** Track ids whose best `thumbnail` has ACTUALLY been persisted (#27-A). A
+	*  track absent here keeps forcing a best-thumbnail capture every frame until
+	*  one lands, so a short / high-churn track whose first capture was dropped
+	*  (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();
 	/** 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
@@ -11438,7 +11962,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-BRwocT7C.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-BiZGDArd.js"));
 			storage = new FilesystemStorageProvider(mediaRoot);
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -11452,6 +11976,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.stationaryRegistry = new StationaryObjectRegistry({
 			store: api.settingsStore,
 			logger: logger.child("StationaryRegistry"),
+			ttlForDevice: (deviceId) => this.stationarySettingsFromCache(deviceId).entryTtlMs,
 			onChange: ({ phase, entry, timestamp }) => {
 				this.ctx.eventBus.emit({
 					id: `pa-stationary-${entry.id}-${phase}`,
@@ -11605,11 +12130,6 @@ var PipelineAnalyticsAddon = class extends require_dist.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;
@@ -11641,6 +12161,17 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				return null;
 			}
 		};
+		const getNativeCropJpeg = async (frameHandle, normalizedBbox, maxWidth) => {
+			const jpeg = await tryNativeCrop(frameHandle, normalizedBbox, maxWidth);
+			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({
@@ -11827,6 +12358,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				this.faceCacheByDevice.delete(data.deviceId);
 				this.mediaCacheByDevice.delete(data.deviceId);
 				this.packageDropCacheByDevice.delete(data.deviceId);
+				this.stationaryCacheByDevice.delete(data.deviceId);
 			}
 		});
 		this.unsubDeviceUnreg = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceUnregistered }, (ev) => {
@@ -11843,6 +12375,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			this.faceCacheByDevice.delete(deviceId);
 			this.mediaCacheByDevice.delete(deviceId);
 			this.packageDropCacheByDevice.delete(deviceId);
+			this.stationaryCacheByDevice.delete(deviceId);
 			this.bindingCache?.invalidate(deviceId);
 			this.zoneAnalytics?.forgetDevice(deviceId);
 			this.audioMetrics?.forgetDevice(deviceId);
@@ -12181,6 +12714,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.dropoutSkipsByKey.clear();
 		this.bestFrameTracker.clear();
 		this.lastFrameAtByTrack.clear();
+		this.thumbnailLandedTracks.clear();
 		this.trackLifecycleUpdateMem.clear();
 		this.objectEmbeddingBestSelector.clear();
 		this.levelStateByDevice.clear();
@@ -12191,6 +12725,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.faceGlobalEnabledCache = null;
 		this.mediaCacheByDevice.clear();
 		this.packageDropCacheByDevice.clear();
+		this.stationaryCacheByDevice.clear();
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
@@ -12235,6 +12770,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			return;
 		}
 		this.dropoutSkipsByKey.set(key, 0);
+		if (source === "pipeline" && this.stationaryRegistry) await this.resolveDeviceStationarySettings(deviceId);
 		const processor = await this.getOrCreateProcessor(deviceId, source);
 		const proxy = await this.ensureProxy(deviceId);
 		const liveZones = proxy?.state.zones.value?.zones ?? [];
@@ -12374,10 +12910,15 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			} });
 		}
 		this.lastActiveTrackIds.set(key, currentTrackIds);
-		if (source === "pipeline" && this.stationaryRegistry) {
+		const stationarySettings = this.stationarySettingsFromCache(deviceId);
+		if (source === "pipeline" && this.stationaryRegistry && stationarySettings.enabled) {
 			const dims = this.lastFrameDimsByDevice.get(deviceId);
 			if (dims && dims.w > 0 && dims.h > 0) {
 				const refDiag = Math.hypot(dims.w, dims.h);
+				const promotionConfig = {
+					...DEFAULT_PROMOTION_CONFIG,
+					windowMs: stationarySettings.promotionWindowMs
+				};
 				for (const t of result.tracked) {
 					const active = this.trackStore.peekActive(t.trackId);
 					if (!active) continue;
@@ -12385,7 +12926,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						positions: active.positions,
 						referenceDiagonalPx: refDiag,
 						now: result.timestamp,
-						config: DEFAULT_PROMOTION_CONFIG
+						config: promotionConfig
 					});
 					if (!promote) continue;
 					this.promoteToStationary({
@@ -12512,6 +13053,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						},
 						mediaKey: s.mediaKey
 					});
+					for (const trackId of res.thumbnailTrackIds) this.thumbnailLandedTracks.add(trackId);
 				}).catch(() => {});
 			}
 		}
@@ -12666,6 +13208,20 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		return settings;
 	}
+	async resolveDeviceStationarySettings(deviceId) {
+		const now = Date.now();
+		const cached = this.stationaryCacheByDevice.get(deviceId);
+		if (cached && now < cached.expiresAt) return cached.settings;
+		const settings = resolveStationarySettings(await this.ctx?.settings?.readDeviceStore(deviceId) ?? {});
+		this.stationaryCacheByDevice.set(deviceId, {
+			settings,
+			expiresAt: now + SETTINGS_CACHE_TTL_MS
+		});
+		return settings;
+	}
+	stationarySettingsFromCache(deviceId) {
+		return this.stationaryCacheByDevice.get(deviceId)?.settings ?? STATIONARY_DEFAULTS;
+	}
 	async resolveDevicePackageDropSettings(deviceId) {
 		const now = Date.now();
 		const cached = this.packageDropCacheByDevice.get(deviceId);
@@ -12763,6 +13319,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		if (!this.faceRecognizer || detail.embedding === void 0) return;
 		if (!await this.resolveGlobalFaceEnabled()) return;
 		const [settings, media] = await Promise.all([this.resolveDeviceFaceSettings(deviceId), this.resolveDeviceMediaSettings(deviceId)]);
+		if (detail.bbox !== void 0 && Math.min(detail.bbox.w, detail.bbox.h) < settings.minFacePx) return;
 		await this.faceRecognizer.ingestFaceDetail({
 			deviceId,
 			trackId,
@@ -13041,19 +13598,22 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				frameWidth,
 				frameHeight
 			});
-			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp, edgeClear);
+			const centerScore = bboxCenterScore(t.bbox, frameWidth, frameHeight);
+			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp, edgeClear, centerScore);
 			this.maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest);
 			const plan = planPeriodicMedia({
 				saveThumbnails: media.saveThumbnails,
 				dueSnapshot,
 				isNewBest,
+				thumbnailLanded: this.thumbnailLandedTracks.has(t.trackId),
 				lastFrameAt: this.lastFrameAtByTrack.get(t.trackId) ?? 0,
 				now: timestamp,
 				intervalMs: media.snapshotIntervalMs
 			});
 			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 bestThumbnail = plan.bestThumbnail && isPlausibleThumbnailBox(t.bbox, frameWidth, frameHeight);
+			if (!plan.appendSnapshot && !plan.rollingLastFrame && !bestThumbnail) continue;
 			targets.push({
 				trackId: t.trackId,
 				timestamp,
@@ -13061,7 +13621,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				...t.label ? { label: t.label } : {},
 				appendSnapshot: plan.appendSnapshot,
 				rollingLastFrame: plan.rollingLastFrame,
-				bestThumbnail: plan.bestThumbnail
+				bestThumbnail
 			});
 		}
 		return targets;
@@ -13367,6 +13927,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				this.bestFrameTracker.delete(t.trackId);
 				this.objectEmbeddingBestSelector.delete(t.trackId);
 				this.lastFrameAtByTrack.delete(t.trackId);
+				this.thumbnailLandedTracks.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) {
@@ -13628,6 +14189,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.bestFrameTracker.delete(track.trackId);
 		this.objectEmbeddingBestSelector.delete(track.trackId);
 		this.lastFrameAtByTrack.delete(track.trackId);
+		this.thumbnailLandedTracks.delete(track.trackId);
 		this.trackLifecycleUpdateMem.delete(track.trackId);
 		this.detailDispatcher?.onTrackEnded(deviceId, track.trackId);
 		this.overlayState.onTrackEnded(deviceId, track.trackId);
@@ -13661,7 +14223,24 @@ var PipelineAnalyticsAddon = class extends require_dist.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
 			}, { stationaryThresholdSec }, {
 				minTrackAge,
 				cooldownSec,
@@ -13669,15 +14248,27 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			}, source);
 			if (source === "pipeline" && this.stationaryRegistry) {
 				const registry = this.stationaryRegistry;
-				p.setStationaryGate({ filter: (input) => registry.filter({
-					deviceId,
-					detections: input.detections.map((d) => ({
-						bbox: d.bbox,
-						className: d.class
-					})),
-					frameWidth: input.frameWidth,
-					frameHeight: input.frameHeight
-				}) });
+				p.setStationaryGate({ filter: (input) => {
+					const s = this.stationarySettingsFromCache(deviceId);
+					if (!s.enabled) return {
+						suppressedIndices: /* @__PURE__ */ new Set(),
+						confirmed: [],
+						wokenEntryIds: []
+					};
+					const matchConfig = {
+						suppressIou: s.suppressIou,
+						wakeAssocIou: s.wakeAssocIou
+					};
+					return registry.filter({
+						deviceId,
+						detections: input.detections.map((d) => ({
+							bbox: d.bbox,
+							className: d.class
+						})),
+						frameWidth: input.frameWidth,
+						frameHeight: input.frameHeight
+					}, matchConfig);
+				} });
 			}
 			this.processors.set(key, p);
 		}
@@ -14740,6 +15331,25 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						step: .05,
 						default: FACE_DEFAULTS.minFaceConfidence
 					},
+					{
+						type: "number",
+						key: "minFacePx",
+						label: "Min face size",
+						description: "Minimum face box size (shorter side, pixels) for a face to be eligible for auto-matching. Faces smaller than this are too low-resolution for reliable recognition and are ignored. Raise it to suppress false matches on tiny/distant faces.",
+						min: 0,
+						step: 1,
+						default: FACE_DEFAULTS.minFacePx,
+						unit: "px"
+					},
+					{
+						type: "number",
+						key: "minIdentitySamples",
+						label: "Min identity samples",
+						description: "Minimum enrolled sample count before an identity can be an automatic match target. Identities with fewer samples are ignored by auto-matching (prevents a single unreliable sample from attracting many faces).",
+						min: 1,
+						step: 1,
+						default: FACE_DEFAULTS.minIdentitySamples
+					},
 					{
 						type: "number",
 						key: "confirmFrames",
@@ -14933,6 +15543,69 @@ var PipelineAnalyticsAddon = class extends require_dist.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",
@@ -14948,6 +15621,141 @@ var PipelineAnalyticsAddon = class extends require_dist.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
+					}
+				]
+			},
+			{
+				id: "stationary-objects",
+				title: "Stationary objects",
+				tab: "analytics",
+				description: "Parked / idle object suppression — keeps a stopped car from re-spawning tracks and re-flooding events. Per-device overrides on each camera. Defaults match today’s behaviour.",
+				columns: 2,
+				fields: [
+					{
+						type: "boolean",
+						key: "enabled",
+						label: "Suppress parked objects",
+						description: "Promote a stopped object to a lightweight registry entry and suppress its detections from re-spawning tracks. Off = every parked object keeps spawning normal tracks on this camera.",
+						default: STATIONARY_DEFAULTS.enabled
+					},
+					{
+						type: "slider",
+						key: "suppressIou",
+						label: "Suppress IoU",
+						description: "Overlap at/above which a detection is the SAME parked object (unmoved) → its spawn is suppressed. Lower can suppress genuine new tracks near a parked object.",
+						min: .3,
+						max: .9,
+						step: .05,
+						default: STATIONARY_DEFAULTS.suppressIou,
+						showValue: true
+					},
+					{
+						type: "slider",
+						key: "wakeAssocIou",
+						label: "Wake / associate IoU",
+						description: "Minimum overlap for a detection to be treated as a parked entry’s OWN object (confirm or wake it). Too low lets a passing object wake a parked entry (re-flood); too high can miss the real departure.",
+						min: .02,
+						max: .5,
+						step: .02,
+						default: STATIONARY_DEFAULTS.wakeAssocIou,
+						showValue: true
+					},
+					{
+						type: "slider",
+						key: "promotionWindowMs",
+						label: "Promotion stillness window",
+						description: "How long (ms) an object must stay put — and the track must have existed — before it is promoted to a parked entry. Longer = slower to stop a re-spawn flood.",
+						min: 5e3,
+						max: 12e4,
+						step: 1e3,
+						default: STATIONARY_DEFAULTS.promotionWindowMs,
+						showValue: true,
+						unit: "s",
+						displayScale: 1e3
+					},
+					{
+						type: "slider",
+						key: "entryTtlMs",
+						label: "Observed-time TTL",
+						description: "Retire a parked entry after this much OBSERVED (frames-flowing) time without a confirming detection — the object was removed while watched, or a long occlusion.",
+						min: 6e4,
+						max: 18e5,
+						step: 3e4,
+						default: STATIONARY_DEFAULTS.entryTtlMs,
+						showValue: true,
+						unit: "s",
+						displayScale: 1e3
 					}
 				]
 			}
@@ -14959,7 +15767,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const raw = await this.ctx?.settings?.readDeviceStore(input.deviceId) ?? {};
 		const baseSections = schema ? require_dist.hydrateSchema({
 			...schema,
-			sections: stripGlobalOnlyFields(toAnalyticsDeviceSections(schema.sections))
+			sections: retagDetectionSections(stripGlobalOnlyFields(toAnalyticsDeviceSections(schema.sections)))
 		}, raw).sections : [];
 		const liveStatsSection = {
 			id: "live-stats",
@@ -15008,7 +15816,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
+exports.DETECTION_PIPELINE_SECTION_IDS = DETECTION_PIPELINE_SECTION_IDS;
 exports.default = PipelineAnalyticsAddon;
 exports.pickCleanMedia = pickCleanMedia;
+exports.retagDetectionSections = retagDetectionSections;
 exports.stripGlobalOnlyFields = stripGlobalOnlyFields;
 exports.toAnalyticsDeviceSections = toAnalyticsDeviceSections;