@camstack/addon-post-analysis 1.1.36 → 1.1.37

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-8DTQLWKO.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-DPBet4IQ.mjs";
 import { randomUUID } from "node:crypto";
 import sharp from "sharp";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -2132,6 +2132,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
@@ -2139,13 +2162,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
@@ -2181,6 +2216,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;
@@ -2197,7 +2236,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, {
@@ -2205,16 +2244,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, {
@@ -2222,6 +2265,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;
 	}
@@ -2233,10 +2277,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
@@ -2389,6 +2435,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
@@ -2596,6 +2645,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
@@ -2607,6 +2657,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) {
@@ -2662,7 +2713,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(),
@@ -2672,7 +2723,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'
@@ -2741,7 +2792,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);
@@ -2890,6 +2942,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 = object({
+	/** Master switch. Off ⇒ no promotion + no suppression for this camera (every
+	*  parked object keeps spawning normal tracks). */
+	enabled: boolean().default(true),
+	/** IoU at/above which a detection is the same parked object, unmoved →
+	*  suppress its spawn. `SUPPRESS_IOU`. */
+	suppressIou: 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: 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: 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: 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;
@@ -5823,6 +5924,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 sharp(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
 /**
@@ -5887,7 +6004,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",
@@ -6106,7 +6229,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 {
@@ -6160,11 +6286,16 @@ var EventMediaDispatcher = class {
 		for (const ev of events) await this.writeEventMedia(deviceId, 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, 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
@@ -6175,10 +6306,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;
+		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, [{
@@ -6213,9 +6348,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);
+			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 },
@@ -6225,9 +6361,12 @@ 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
@@ -6265,6 +6404,7 @@ var EventMediaDispatcher = class {
 				timestamp,
 				data
 			});
+			return true;
 		} catch (err) {
 			this.deps.logger.debug(`event media: ${kind} replace failed`, {
 				tags: { deviceId },
@@ -6274,6 +6414,7 @@ var EventMediaDispatcher = class {
 					error: err instanceof Error ? err.message : String(err)
 				}
 			});
+			return false;
 		}
 	}
 	async writeEventMedia(deviceId, frameData, fw, fh, ev, cropPadding) {
@@ -7576,15 +7717,30 @@ var FaceSettingsSchema = object({
 	*/
 	enabled: boolean().default(true),
 	/** Cosine similarity (on L2-normalized arcface vectors) required to match. */
-	similarityThreshold: number().min(0).max(1).default(.45),
+	similarityThreshold: number().min(0).max(1).default(.55),
 	/** Reject ambiguous matches: require best − secondBest ≥ margin. */
-	margin: number().min(0).max(1).default(.05),
+	margin: number().min(0).max(1).default(.1),
 	/** Minimum face-detection confidence for a face to be considered. */
 	minFaceConfidence: 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: 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: 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: number().int().min(1).default(2),
+	confirmFrames: number().int().min(1).default(3),
 	/** Recent-faces buffer retention (days). */
 	bufferRetentionDays: number().min(0).default(3),
 	/** Max buffered faces kept per device. */
@@ -7601,6 +7757,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")
@@ -7936,10 +8094,12 @@ 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
@@ -8922,6 +9082,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
@@ -8932,10 +9107,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 = cosineSimilarity(probeVec, new Float32Array(s.embedding));
 			const prev = bestByIdentity.get(s.identityId);
 			if (prev === void 0 || score > prev) bestByIdentity.set(s.identityId, score);
@@ -9081,7 +9258,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 },
@@ -9097,7 +9274,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) {
@@ -11344,6 +11522,12 @@ var PipelineAnalyticsAddon = class extends 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. */
@@ -11376,6 +11560,12 @@ var PipelineAnalyticsAddon = class extends 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
@@ -11447,6 +11637,7 @@ var PipelineAnalyticsAddon = class extends 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}`,
@@ -11822,6 +12013,7 @@ var PipelineAnalyticsAddon = class extends 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: EventCategory.DeviceUnregistered }, (ev) => {
@@ -11838,6 +12030,7 @@ var PipelineAnalyticsAddon = class extends 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);
@@ -12176,6 +12369,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.dropoutSkipsByKey.clear();
 		this.bestFrameTracker.clear();
 		this.lastFrameAtByTrack.clear();
+		this.thumbnailLandedTracks.clear();
 		this.trackLifecycleUpdateMem.clear();
 		this.objectEmbeddingBestSelector.clear();
 		this.levelStateByDevice.clear();
@@ -12186,6 +12380,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.faceGlobalEnabledCache = null;
 		this.mediaCacheByDevice.clear();
 		this.packageDropCacheByDevice.clear();
+		this.stationaryCacheByDevice.clear();
 		this.trackStore?.clearAll();
 		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
@@ -12230,6 +12425,7 @@ var PipelineAnalyticsAddon = class extends 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 ?? [];
@@ -12369,10 +12565,15 @@ var PipelineAnalyticsAddon = class extends 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;
@@ -12380,7 +12581,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						positions: active.positions,
 						referenceDiagonalPx: refDiag,
 						now: result.timestamp,
-						config: DEFAULT_PROMOTION_CONFIG
+						config: promotionConfig
 					});
 					if (!promote) continue;
 					this.promoteToStationary({
@@ -12507,6 +12708,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						},
 						mediaKey: s.mediaKey
 					});
+					for (const trackId of res.thumbnailTrackIds) this.thumbnailLandedTracks.add(trackId);
 				}).catch(() => {});
 			}
 		}
@@ -12661,6 +12863,20 @@ var PipelineAnalyticsAddon = class extends 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);
@@ -12758,6 +12974,7 @@ var PipelineAnalyticsAddon = class extends 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,
@@ -13036,12 +13253,14 @@ var PipelineAnalyticsAddon = class extends 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
@@ -13362,6 +13581,7 @@ var PipelineAnalyticsAddon = class extends 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) {
@@ -13623,6 +13843,7 @@ var PipelineAnalyticsAddon = class extends 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);
@@ -13664,15 +13885,27 @@ var PipelineAnalyticsAddon = class extends 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);
 		}
@@ -14735,6 +14968,25 @@ var PipelineAnalyticsAddon = class extends 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",
@@ -14945,6 +15197,70 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						default: TRACKING_DEFAULTS.dropoutMaxSkipFrames
 					}
 				]
+			},
+			{
+				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
+					}
+				]
 			}
 		] });
 	}