@camstack/addon-post-analysis 1.1.28 → 1.1.30

package/dist/pipeline-analytics/index.mjs

@@ -1,7 +1,6 @@
-import { S as string, _ as createEvent, b as number, c as nodePin, d as videoclipsCapability, f as zoneAnalyticsCapability, g as EventCategory, h as DeviceType, i as cosineSimilarity, l as pipelineAnalyticsCapability, m as BaseAddon, n as addonWidgetsSourceCapability, o as faceGalleryCapability, p as errMsg, r as audioMetricsCapability, t as EVENT_PAD_MS, u as plateGalleryCapability, v as hydrateSchema, x as object, y as boolean } from "../dist-Blpsv-M0.mjs";
+import { S as EventCategory, _ as hydrateSchema, b as object, c as nodePin, d as videoclipsCapability, f as zoneAnalyticsCapability, g as createEvent, h as DeviceType, i as cosineSimilarity, l as pipelineAnalyticsCapability, m as BaseAddon, n as addonWidgetsSourceCapability, o as faceGalleryCapability, p as errMsg, r as audioMetricsCapability, t as EVENT_PAD_MS, u as plateGalleryCapability, v as boolean, x as string, y as number } from "../dist-yPsKFcJL.mjs";
 import { randomUUID } from "node:crypto";
 import sharp from "sharp";
-import { FrameRingReaderCache } from "@camstack/shm-ring";
 //#region src/pipeline-analytics/videoclips-provider.ts
 var SOURCE = "analytics";
 function clipIdFor(eventId, startMs, endMs) {
@@ -146,6 +145,17 @@ var WEIGHT_IDENTITY = .05;
 var DWELL_FULL_MS = 6e4;
 /** Peak bbox area (as a fraction of frame area) that saturates the size term. */
 var SIZE_FULL = .15;
+/** A track whose net centroid displacement stays below this fraction of the
+*  frame diagonal over its whole life counts as stationary on the net signal. */
+var STATIC_DISPLACEMENT_FRAC = .02;
+/** ...and whose entire centroid path fits within this fraction of the frame
+*  diagonal counts as stationary on the span signal. Both must hold. */
+var STATIC_SPAN_FRAC = .04;
+/** Importance multiplier applied to a stationary track that has NO resolved
+*  identity — strongly demotes "ghost" detections on static objects (a pile of
+*  clothes read as a person, a kitchen object read as an animal) below the
+*  key-event threshold. Identified tracks (face/plate) are never suppressed. */
+var STATIC_IMPORTANCE_MULTIPLIER = .1;
 var CLASS_RANK_VEHICLE = .8;
 var CLASS_RANK_ANIMAL = .5;
 var CLASS_RANK_DEFAULT = .25;
@@ -220,6 +230,11 @@ function computeImportance(input) {
 		sum += term.value;
 		if (term.value > best.value) best = term;
 	}
+	const identified = input.label !== void 0 && input.label.length > 0;
+	if (input.netDisplacementFrac !== void 0 && input.pathSpanFrac !== void 0 && input.netDisplacementFrac < .02 && input.pathSpanFrac < .04 && !identified) return {
+		importance: clamp01(sum * STATIC_IMPORTANCE_MULTIPLIER),
+		reason: best.reason
+	};
 	return {
 		importance: clamp01(sum),
 		reason: best.reason
@@ -613,6 +628,20 @@ function normalizePlate(text) {
 	return text.toUpperCase().replace(/[^A-Z0-9]/g, "");
 }
 /**
+* Quality gate for a raw OCR plate read BEFORE it becomes a track label or a
+* gallery row. Distant/oblique parked plates produce junk reads ("N", "Idag",
+* "@em") that otherwise flood track labels (live-observed on the parking
+* camera, 2026-07-16). A plausible European plate is ≥{@link PLATE_MIN_LENGTH}
+* alphanumerics and mixes letters AND digits; anything else — or a read below
+* {@link PLATE_MIN_SCORE} — is discarded, not stored.
+*/
+function isPlausiblePlateRead(text, score) {
+	if (score < .4) return false;
+	const norm = normalizePlate(text);
+	if (norm.length < 4) return false;
+	return /[0-9]/.test(norm) && /[A-Z]/.test(norm);
+}
+/**
 * Fold characters that OCR routinely confuses onto a single canonical symbol, so
 * "AB0" and "ABO" compare as equal. Applied to BOTH operands of a distance
 * comparison only — never stored. Conservative set covering the common Latin
@@ -1097,7 +1126,7 @@ var MAX_PATH_LENGTH = 300;
 function clamp(value, min, max) {
 	return Math.max(min, Math.min(max, value));
 }
-function iou$1(a, b) {
+function iou$2(a, b) {
 	const ax1 = a.x, ay1 = a.y, ax2 = a.x + a.w, ay2 = a.y + a.h;
 	const bx1 = b.x, by1 = b.y, bx2 = b.x + b.w, by2 = b.y + b.h;
 	const ix1 = Math.max(ax1, bx1), iy1 = Math.max(ay1, by1);
@@ -1152,7 +1181,7 @@ var SortTracker = class {
 	*/
 	looseMatch(track, det) {
 		if (track.class !== det.class) return false;
-		if (iou$1(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return true;
+		if (iou$2(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return true;
 		const tc = bboxCentroid(track.bbox);
 		const dc = bboxCentroid(det.bbox);
 		const dist = Math.hypot(tc.x - dc.x, tc.y - dc.y);
@@ -1180,7 +1209,7 @@ var SortTracker = class {
 			for (let di = 0; di < detections.length; di++) {
 				const det = detections[di];
 				if (this.config.classGating && track.class !== det.class) continue;
-				const score = iou$1(pbox, det.bbox);
+				const score = iou$2(pbox, det.bbox);
 				if (score >= this.config.iouThreshold) pairs.push({
 					track,
 					detIdx: di,
@@ -1205,7 +1234,7 @@ var SortTracker = class {
 				rescuePairs.push({
 					track,
 					detIdx: di,
-					score: iou$1(track.bbox, det.bbox)
+					score: iou$2(track.bbox, det.bbox)
 				});
 			}
 		}
@@ -1270,7 +1299,7 @@ var SortTracker = class {
 				if (!lost.resurrectable) continue;
 				if (timestamp - lost.lostAt > this.config.resurrectionWindowMs) continue;
 				if (!this.looseMatch(lost, det)) continue;
-				const score = iou$1(lost.bbox, det.bbox);
+				const score = iou$2(lost.bbox, det.bbox);
 				if (score > bestScore) {
 					best = lost;
 					bestScore = score;
@@ -1331,6 +1360,16 @@ var SortTracker = class {
 			path: [...t.path]
 		}));
 	}
+	/**
+	* Remove a track from BOTH the live and graveyard sets so it neither emits
+	* nor resurrects. Used when a track is PROMOTED to a stationary-object
+	* registry entry: the registry now owns that parked object, and the tracker
+	* must forget it so the object's detections don't re-spawn a duplicate track.
+	*/
+	dropTrack(trackId) {
+		this.tracks = this.tracks.filter((t) => t.id !== trackId);
+		this.lostTracks = this.lostTracks.filter((t) => t.id !== trackId);
+	}
 	getActiveTracks() {
 		return this.tracks;
 	}
@@ -1744,6 +1783,9 @@ var FrameProcessor = class {
 	*/
 	detectionRules;
 	zoneEngine = new ZoneEngine();
+	/** Optional stationary-object gate (parked-object suppression). Null until
+	*  the addon wires it via {@link setStationaryGate}. */
+	stationaryGate = null;
 	constructor(deviceId, trackerConfig = {}, stateConfig = {}, emitterConfig = {}, source = "pipeline") {
 		this.deviceId = deviceId;
 		this.source = source;
@@ -1759,6 +1801,16 @@ var FrameProcessor = class {
 	setDetectionRules(rules) {
 		this.detectionRules = rules;
 	}
+	/** Wire (or clear) the stationary-object gate. Called by the addon per
+	*  device so parked-object suppression applies from the next frame. */
+	setStationaryGate(gate) {
+		this.stationaryGate = gate;
+	}
+	/** Forget a track in the underlying tracker (used when the addon promotes it
+	*  to a stationary-object registry entry). */
+	dropTrack(trackId) {
+		this.tracker.dropTrack(trackId);
+	}
 	process(input) {
 		const { timestamp, frame } = input;
 		const frameWidth = frame.width;
@@ -1837,7 +1889,17 @@ var FrameProcessor = class {
 		}
 		const { passed } = this.zoneEngine.filterDetections(flatDetections, this.zones, this.detectionRules, frameWidth, frameHeight, (fd) => fd.detection.class);
 		const filteredDetections = passed.map((fd) => fd.detection);
-		const trackedDetections = this.tracker.update(filteredDetections, timestamp);
+		const gate = this.stationaryGate ? this.stationaryGate.filter({
+			detections: filteredDetections,
+			frameWidth,
+			frameHeight
+		}) : {
+			suppressedIndices: /* @__PURE__ */ new Set(),
+			confirmed: [],
+			wokenEntryIds: []
+		};
+		const trackerInput = gate.suppressedIndices.size > 0 ? filteredDetections.filter((_, i) => !gate.suppressedIndices.has(i)) : filteredDetections;
+		const trackedDetections = this.tracker.update(trackerInput, timestamp);
 		const objectStates = this.stateAnalyzer.analyze(trackedDetections, timestamp);
 		const rawEvents = this.eventEmitter.emit(trackedDetections, objectStates, [], [], String(this.deviceId));
 		const zonesByTrack = /* @__PURE__ */ new Map();
@@ -1919,7 +1981,9 @@ var FrameProcessor = class {
 			frameHeight,
 			tracked,
 			objectEvents,
-			rawTrackedDetections: trackedDetections
+			rawTrackedDetections: trackedDetections,
+			stationaryConfirmed: gate.confirmed,
+			stationaryWoken: gate.wokenEntryIds
 		};
 	}
 };
@@ -1996,6 +2060,7 @@ function buildTrackLifecyclePayload(input) {
 		...input.positionsCount !== void 0 ? { positionsCount: input.positionsCount } : {},
 		...input.importance !== void 0 ? { importance: input.importance } : {},
 		...input.importanceReason !== void 0 ? { importanceReason: input.importanceReason } : {},
+		...input.audioLabels !== void 0 && input.audioLabels.length > 0 ? { audioLabels: input.audioLabels } : {},
 		...input.embeddingId !== void 0 ? { embeddingId: input.embeddingId } : {},
 		...input.embeddingModelId !== void 0 ? { embeddingModelId: input.embeddingModelId } : {},
 		...hasMedia ? { media } : {}
@@ -2112,6 +2177,583 @@ function resolveSearchThumbnailUrl(input) {
 	return `${input.baseUrl}/${encodeURIComponent(id)}`;
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/static-track-gate.ts
+/**
+* Net displacement + path span for a track's centroid path, normalized to
+* `referenceDiagonalPx`. Returns undefined when there is nothing meaningful to
+* measure (fewer than two points, or a degenerate ≤0 reference) so the caller
+* leaves the importance score untouched.
+*/
+function computeStaticTrackMetrics(centroids, referenceDiagonalPx) {
+	if (!(referenceDiagonalPx > 0) || centroids.length < 2) return void 0;
+	const first = centroids[0];
+	const last = centroids[centroids.length - 1];
+	const netDisplacementFrac = Math.hypot(last.x - first.x, last.y - first.y) / referenceDiagonalPx;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (const c of centroids) {
+		if (c.x < minX) minX = c.x;
+		if (c.x > maxX) maxX = c.x;
+		if (c.y < minY) minY = c.y;
+		if (c.y > maxY) maxY = c.y;
+	}
+	return {
+		netDisplacementFrac,
+		pathSpanFrac: Math.hypot(maxX - minX, maxY - minY) / referenceDiagonalPx
+	};
+}
+/** Average bbox diagonal (px) across a track's positions — the scale reference
+*  when frame dimensions aren't available. Returns 0 for an empty list. */
+function averageBboxDiagonal(boxes) {
+	if (boxes.length === 0) return 0;
+	let sum = 0;
+	for (const b of boxes) sum += Math.hypot(b.w, b.h);
+	return sum / boxes.length;
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/stationary/stationary-types.ts
+function entryToView(e) {
+	return {
+		id: e.id,
+		className: e.className,
+		bbox: { ...e.bbox },
+		frameWidth: e.frameWidth,
+		frameHeight: e.frameHeight,
+		firstSeenAt: e.firstSeenAt,
+		becameStationaryAt: e.becameStationaryAt,
+		lastConfirmedAt: e.lastConfirmedAt,
+		...e.label !== void 0 ? { label: e.label } : {},
+		...e.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: e.keyFrameMediaKey } : {}
+	};
+}
+/** IoU at/above which a detection is "the same parked object" → suppress its
+*  spawn and refresh the entry's `lastConfirmedAt`. Matches decision #2 (0.6). */
+var SUPPRESS_IOU = .6;
+/** Centroid move (fraction of the frame diagonal) beyond which a near
+*  same-class detection means the parked object actually MOVED → wake. */
+var WAKE_MOVE_FRAC = .08;
+/** How near (fraction of frame diagonal) a same-class detection's centroid must
+*  be to an entry to be considered "this entry's object" when testing for a
+*  wake. Keeps an unrelated object elsewhere in the frame from waking it. */
+var WAKE_SEARCH_FRAC = .5;
+/**
+* Look-back window over which a track must have stayed put to be PROMOTED. A
+* car that drives in then parks has a large whole-life displacement but a tiny
+* last-`windowMs` displacement — so promotion is judged on the recent window,
+* not the full path. Also the minimum age (the track must have EXISTED this
+* long) so a freshly-spawned static blob isn't promoted instantly.
+*/
+var PROMOTION_WINDOW_MS = 3e4;
+var DEFAULT_MATCH_CONFIG = {
+	suppressIou: SUPPRESS_IOU,
+	wakeMoveFrac: WAKE_MOVE_FRAC,
+	wakeSearchFrac: WAKE_SEARCH_FRAC
+};
+//#endregion
+//#region src/pipeline-analytics/pipeline/stationary/stationary-match.ts
+/**
+* stationary-match — PURE geometry for the stationary-object registry.
+*
+* Two decisions, both unit-testable in isolation:
+*
+*  1. `partitionDetectionsAgainstRegistry` — given the current registry entries
+*     and this frame's (zone-filtered) detections, decides which detections are
+*     suppressed (they keep confirming a known parked object → no track spawns),
+*     which entries are confirmed present, and which entries WOKE (their object
+*     moved → retire the entry and let the detection spawn a normal track).
+*
+*  2. `evaluateStationaryPromotion` — given a track's recent centroid path,
+*     decides whether it has stayed put long enough to become a stationary
+*     entry. Reuses the static-track-gate metrics (net displacement + path span
+*     normalised to the frame diagonal) over the recent look-back window.
+*/
+/** Default promotion tunables — static thresholds shared with the key-event
+*  static gate so "stationary" means the same thing in both places. */
+var DEFAULT_PROMOTION_CONFIG = {
+	windowMs: PROMOTION_WINDOW_MS,
+	netFracMax: STATIC_DISPLACEMENT_FRAC,
+	spanFracMax: STATIC_SPAN_FRAC,
+	minPoints: 4
+};
+function iou$1(a, b) {
+	const ax2 = a.x + a.w;
+	const ay2 = a.y + a.h;
+	const bx2 = b.x + b.w;
+	const by2 = b.y + b.h;
+	const ix1 = Math.max(a.x, b.x);
+	const iy1 = Math.max(a.y, b.y);
+	const ix2 = Math.min(ax2, bx2);
+	const iy2 = Math.min(ay2, by2);
+	const inter = Math.max(0, ix2 - ix1) * Math.max(0, iy2 - iy1);
+	const union = a.w * a.h + b.w * b.h - inter;
+	return union > 0 ? inter / union : 0;
+}
+function centroid(b) {
+	return {
+		x: b.x + b.w / 2,
+		y: b.y + b.h / 2
+	};
+}
+function diagonalOf(width, height) {
+	return Math.hypot(width, height);
+}
+/**
+* Decide, per stationary entry, whether the current frame confirms it, wakes
+* it, or misses it (no matching detection — leave it for the TTL sweep).
+*
+* Per entry, over same-class detections:
+*  - best IoU ≥ `suppressIou` → SUPPRESS the best-overlap detection (it is the
+*    parked object, unmoved) and mark the entry confirmed.
+*  - else if a same-class detection sits within `wakeSearchFrac × diag` of the
+*    entry centroid but has moved > `wakeMoveFrac × diag` → WAKE the entry (the
+*    object slid out of its parked box). The detection is NOT suppressed, so it
+*    spawns a fresh moving track.
+*  - else → MISS (occlusion / brief absence): neither suppress nor wake.
+*
+* A detection can suppress at most one spawn even if it overlaps two entries
+* (`suppressedIndices` is a set).
+*/
+function partitionDetectionsAgainstRegistry(input) {
+	const { entries, detections, referenceDiagonalPx, config } = input;
+	const suppressed = /* @__PURE__ */ new Set();
+	const confirmed = [];
+	const woken = [];
+	const diag = referenceDiagonalPx;
+	for (const entry of entries) {
+		const ec = centroid(entry.bbox);
+		let bestIou = 0;
+		let bestIdx = -1;
+		let wakeCandidate = false;
+		for (let di = 0; di < detections.length; di++) {
+			const det = detections[di];
+			if (det.className !== entry.className) continue;
+			const o = iou$1(entry.bbox, det.bbox);
+			if (o > bestIou) {
+				bestIou = o;
+				bestIdx = di;
+			}
+			if (diag > 0) {
+				const dc = centroid(det.bbox);
+				const dist = Math.hypot(dc.x - ec.x, dc.y - ec.y);
+				if (dist <= config.wakeSearchFrac * diag && dist > config.wakeMoveFrac * diag) wakeCandidate = true;
+			}
+		}
+		if (bestIou >= config.suppressIou && bestIdx >= 0) {
+			suppressed.add(bestIdx);
+			confirmed.push({
+				entryId: entry.id,
+				className: entry.className,
+				bbox: { ...entry.bbox }
+			});
+		} else if (wakeCandidate) woken.push(entry.id);
+	}
+	return {
+		suppressedIndices: suppressed,
+		confirmed,
+		wokenEntryIds: woken
+	};
+}
+/**
+* A track is promoted when, over the recent `windowMs`, its centroid barely
+* moved (both net displacement and path span below the static thresholds) AND
+* the track has actually EXISTED for at least `windowMs` (so a car that just
+* arrived isn't parked yet). Judging on the recent window — not the whole life
+* — is what lets a car that drove in then parked be recognised as stationary.
+*/
+function evaluateStationaryPromotion(input) {
+	const { positions, referenceDiagonalPx, now, config } = input;
+	if (!(referenceDiagonalPx > 0) || positions.length === 0) return { promote: false };
+	if (now - positions[0].timestamp < config.windowMs) return { promote: false };
+	const cutoff = now - config.windowMs;
+	const window = positions.filter((p) => p.timestamp >= cutoff);
+	if (window.length < config.minPoints) return { promote: false };
+	const metrics = computeStaticTrackMetrics(window.map((p) => ({
+		x: p.x,
+		y: p.y
+	})), referenceDiagonalPx);
+	if (metrics === void 0) return { promote: false };
+	return {
+		promote: metrics.netDisplacementFrac < config.netFracMax && metrics.pathSpanFrac < config.spanFracMax,
+		netFrac: metrics.netDisplacementFrac,
+		spanFrac: metrics.pathSpanFrac
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/stationary/stationary-registry.ts
+var STATIONARY_COLLECTION = "pipeline-analytics:stationary-objects";
+var STATIONARY_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "className",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "bbox",
+		type: "JSON"
+	},
+	{
+		name: "frameWidth",
+		type: "INTEGER"
+	},
+	{
+		name: "frameHeight",
+		type: "INTEGER"
+	},
+	{
+		name: "firstSeenAt",
+		type: "INTEGER"
+	},
+	{
+		name: "becameStationaryAt",
+		type: "INTEGER"
+	},
+	{
+		name: "lastConfirmedAt",
+		type: "INTEGER"
+	},
+	{
+		name: "sourceTrackId",
+		type: "TEXT"
+	},
+	{
+		name: "label",
+		type: "TEXT"
+	},
+	{
+		name: "keyFrameMediaKey",
+		type: "TEXT"
+	}
+];
+var STATIONARY_INDEXES = [{
+	name: "idx_stationary_device",
+	columns: ["deviceId"]
+}];
+var StationaryObjectRegistry = class {
+	byDevice = /* @__PURE__ */ new Map();
+	dirty = /* @__PURE__ */ new Set();
+	store;
+	logger;
+	matchConfig;
+	entryTtlMs;
+	onChange;
+	/** Latest processed-frame timestamp per device — expiry counts OBSERVED
+	*  time, not wall-clock. A session-dispatch camera produces no frames
+	*  between motion sessions; that silence is not evidence the object left,
+	*  so quiet minutes must not age the entries (see {@link sweep}). */
+	lastFrameAtByDevice = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+		this.matchConfig = deps.matchConfig ?? DEFAULT_MATCH_CONFIG;
+		this.entryTtlMs = deps.entryTtlMs ?? 3e5;
+		this.onChange = deps.onChange;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: STATIONARY_COLLECTION,
+			columns: [...STATIONARY_COLUMNS],
+			indexes: [...STATIONARY_INDEXES]
+		});
+	}
+	/** Hydrate all persisted entries into memory (call once at boot, after
+	*  `declare`). Best-effort — a query failure leaves the registry empty. */
+	async load() {
+		try {
+			const rows = await this.store.query.query({
+				collection: STATIONARY_COLLECTION,
+				filter: { limit: 1e5 }
+			});
+			for (const row of rows) {
+				const entry = rowToEntry(row.id, row.data);
+				if (!entry) continue;
+				this.deviceMap(entry.deviceId).set(entry.id, entry);
+			}
+			this.logger.info("stationary registry loaded", { meta: { entries: rows.length } });
+		} catch (err) {
+			this.logger.warn("stationary registry load failed", { meta: { error: String(err) } });
+		}
+	}
+	list(deviceId) {
+		const m = this.byDevice.get(deviceId);
+		return m ? [...m.values()] : [];
+	}
+	listViews(deviceId) {
+		return this.list(deviceId).map(entryToView);
+	}
+	count(deviceId) {
+		return this.byDevice.get(deviceId)?.size ?? 0;
+	}
+	/** Device ids that currently hold at least one parked entry — drives the
+	*  occupancy baseline sampler (a detached camera with parked cars still
+	*  gets a flat history baseline). */
+	deviceIds() {
+		const ids = [];
+		for (const [deviceId, m] of this.byDevice) if (m.size > 0) ids.push(deviceId);
+		return ids;
+	}
+	/** Record that a frame was processed for a device — advances the OBSERVED
+	*  clock that drives entry expiry in {@link sweep}. */
+	noteFrame(deviceId, timestamp) {
+		if (timestamp > (this.lastFrameAtByDevice.get(deviceId) ?? 0)) this.lastFrameAtByDevice.set(deviceId, timestamp);
+	}
+	/**
+	* Per-frame gate: partition this frame's detections against the device's
+	* entries. PURE with respect to registry state — apply the outcome with
+	* {@link applyFrameOutcome} once the frame result is assembled.
+	*/
+	filter(input) {
+		const entries = this.list(input.deviceId);
+		if (entries.length === 0) return {
+			suppressedIndices: /* @__PURE__ */ new Set(),
+			confirmed: [],
+			wokenEntryIds: []
+		};
+		return partitionDetectionsAgainstRegistry({
+			entries,
+			detections: input.detections,
+			referenceDiagonalPx: diagonalOf(input.frameWidth, input.frameHeight),
+			config: this.matchConfig
+		});
+	}
+	/** Fold a frame's gate result back into state: advance confirmed entries'
+	*  `lastConfirmedAt` and retire woken entries (their object departed). */
+	applyFrameOutcome(input) {
+		const m = this.byDevice.get(input.deviceId);
+		if (!m) return;
+		for (const c of input.confirmed) {
+			const e = m.get(c.entryId);
+			if (!e) continue;
+			m.set(c.entryId, {
+				...e,
+				lastConfirmedAt: input.timestamp
+			});
+			this.dirty.add(c.entryId);
+		}
+		for (const id of input.wokenEntryIds) {
+			const e = m.get(id);
+			if (!e) continue;
+			m.delete(id);
+			this.dirty.delete(id);
+			this.deletePersisted(id);
+			this.onChange?.({
+				phase: "departed",
+				entry: e,
+				timestamp: input.timestamp
+			});
+		}
+	}
+	/** Promote a parked track into a persisted stationary entry. */
+	async promote(entry) {
+		this.deviceMap(entry.deviceId).set(entry.id, entry);
+		this.dirty.delete(entry.id);
+		try {
+			await this.persist(entry);
+		} catch (err) {
+			this.logger.warn("stationary promote persist failed", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					entryId: entry.id,
+					error: String(err)
+				}
+			});
+		}
+		this.onChange?.({
+			phase: "appeared",
+			entry,
+			timestamp: entry.becameStationaryAt
+		});
+	}
+	/**
+	* Retire entries unconfirmed for longer than the TTL of OBSERVED time, and
+	* flush any advanced `lastConfirmedAt`s to the store. Returns retired
+	* entries (for logging).
+	*
+	* Expiry is measured against the device's latest processed-frame timestamp
+	* ({@link noteFrame}), NOT the wall clock: a session-dispatch camera emits
+	* no frames between motion sessions, and that silence says nothing about
+	* the object. Only when the camera has actually been WATCHING for `ttl`
+	* beyond the last confirmation (frames flowed, object never matched) is the
+	* object considered removed. A device with no recorded frame yet never
+	* expires its entries. `now` only stamps the departed telemetry.
+	*/
+	async sweep(now) {
+		const retired = [];
+		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) {
+				m.delete(id);
+				this.dirty.delete(id);
+				retired.push(e);
+				this.deletePersisted(id);
+				this.onChange?.({
+					phase: "departed",
+					entry: e,
+					timestamp: now
+				});
+			}
+			if (m.size === 0) this.byDevice.delete(deviceId);
+		}
+		for (const id of [...this.dirty]) {
+			this.dirty.delete(id);
+			const entry = this.findById(id);
+			if (!entry) continue;
+			try {
+				await this.store.update.mutate({
+					collection: STATIONARY_COLLECTION,
+					id,
+					data: { lastConfirmedAt: entry.lastConfirmedAt }
+				});
+			} catch (err) {
+				this.logger.debug("stationary lastConfirmedAt flush failed", { meta: {
+					entryId: id,
+					error: String(err)
+				} });
+			}
+		}
+		return retired;
+	}
+	/** Drop a device's entries from memory WITHOUT deleting persisted rows.
+	*  Used on device unbind; a rebind reloads from the store. */
+	forgetDevice(deviceId) {
+		this.lastFrameAtByDevice.delete(deviceId);
+		const m = this.byDevice.get(deviceId);
+		if (!m) return;
+		for (const id of m.keys()) this.dirty.delete(id);
+		this.byDevice.delete(deviceId);
+	}
+	/** Delete every persisted + in-memory entry for a device (operator wipe). */
+	async clearDevice(deviceId) {
+		this.lastFrameAtByDevice.delete(deviceId);
+		const m = this.byDevice.get(deviceId);
+		if (m) {
+			for (const id of [...m.keys()]) {
+				this.dirty.delete(id);
+				this.deletePersisted(id);
+			}
+			this.byDevice.delete(deviceId);
+		}
+	}
+	deviceMap(deviceId) {
+		let m = this.byDevice.get(deviceId);
+		if (!m) {
+			m = /* @__PURE__ */ new Map();
+			this.byDevice.set(deviceId, m);
+		}
+		return m;
+	}
+	findById(id) {
+		for (const m of this.byDevice.values()) {
+			const e = m.get(id);
+			if (e) return e;
+		}
+	}
+	async persist(e) {
+		await this.store.set.mutate({
+			collection: STATIONARY_COLLECTION,
+			key: e.id,
+			value: {
+				deviceId: e.deviceId,
+				className: e.className,
+				bbox: { ...e.bbox },
+				frameWidth: e.frameWidth,
+				frameHeight: e.frameHeight,
+				firstSeenAt: e.firstSeenAt,
+				becameStationaryAt: e.becameStationaryAt,
+				lastConfirmedAt: e.lastConfirmedAt,
+				...e.sourceTrackId !== void 0 ? { sourceTrackId: e.sourceTrackId } : {},
+				...e.label !== void 0 ? { label: e.label } : {},
+				...e.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: e.keyFrameMediaKey } : {}
+			}
+		});
+	}
+	async deletePersisted(id) {
+		try {
+			await this.store.delete.mutate({
+				collection: STATIONARY_COLLECTION,
+				key: id
+			});
+		} catch (err) {
+			this.logger.debug("stationary delete failed", { meta: {
+				entryId: id,
+				error: String(err)
+			} });
+		}
+	}
+};
+function rowToEntry(id, data) {
+	const deviceId = Number(data["deviceId"]);
+	const className = data["className"];
+	const bbox = data["bbox"];
+	if (!Number.isFinite(deviceId) || typeof className !== "string" || !bbox) return null;
+	const sourceTrackId = data["sourceTrackId"];
+	const label = data["label"];
+	const keyFrameMediaKey = data["keyFrameMediaKey"];
+	return {
+		id,
+		deviceId,
+		className,
+		bbox: {
+			x: Number(bbox.x),
+			y: Number(bbox.y),
+			w: Number(bbox.w),
+			h: Number(bbox.h)
+		},
+		frameWidth: Number(data["frameWidth"] ?? 0),
+		frameHeight: Number(data["frameHeight"] ?? 0),
+		firstSeenAt: Number(data["firstSeenAt"] ?? 0),
+		becameStationaryAt: Number(data["becameStationaryAt"] ?? 0),
+		lastConfirmedAt: Number(data["lastConfirmedAt"] ?? 0),
+		...typeof sourceTrackId === "string" ? { sourceTrackId } : {},
+		...typeof label === "string" ? { label } : {},
+		...typeof keyFrameMediaKey === "string" ? { keyFrameMediaKey } : {}
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/stationary/stationary-zones.ts
+/**
+* Zone ids whose 0–1 polygon contains the entry's normalised bbox centroid.
+* Empty when the entry has no frame dims (can't normalise) or no zone matches.
+*/
+function computeStationaryEntryZones(entry, zones) {
+	if (entry.frameWidth <= 0 || entry.frameHeight <= 0 || zones.length === 0) return [];
+	const centroidPx = bboxCentroid(entry.bbox);
+	const point = {
+		x: centroidPx.x / entry.frameWidth,
+		y: centroidPx.y / entry.frameHeight
+	};
+	const matched = [];
+	for (const zone of zones) {
+		if (zone.polygon.length < 3) continue;
+		if (pointInPolygon(point, zone.polygon)) matched.push(zone.id);
+	}
+	return matched;
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/track-appearance.ts
+/**
+* Pure: no side effects. `continuing` = still active from last frame;
+* `birth` = a brand-new track's first sighting; `resurrection` = a known track
+* re-entering the active set after being lost.
+*/
+function classifyTrackAppearance(input) {
+	if (input.inPrevActive) return "continuing";
+	return input.positionsCount > 1 ? "resurrection" : "birth";
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/key-event-query.ts
 async function rankKeyEvents(candidates, options, peakLookup) {
 	const scored = [];
@@ -2121,6 +2763,10 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 		let bestEventId = t.bestEventId;
 		if (importance === void 0) {
 			const peak = await peakLookup(t.trackId);
+			const staticMetrics = computeStaticTrackMetrics(t.positions.map((p) => ({
+				x: p.x,
+				y: p.y
+			})), averageBboxDiagonal(t.positions.map((p) => p.bbox)));
 			importance = computeImportance({
 				peakConfidence: peak.peakConfidence,
 				className: t.className,
@@ -2128,7 +2774,11 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 				peakBboxAreaFrac: peak.peakBboxAreaFrac,
 				totalDistance: t.totalDistance,
 				zonesVisited: t.zonesVisited,
-				...t.label !== void 0 ? { label: t.label } : {}
+				...t.label !== void 0 ? { label: t.label } : {},
+				...staticMetrics ? {
+					netDisplacementFrac: staticMetrics.netDisplacementFrac,
+					pathSpanFrac: staticMetrics.pathSpanFrac
+				} : {}
 			}).importance;
 			bestEventId = bestEventId ?? peak.bestEventId;
 		}
@@ -2140,7 +2790,7 @@ async function rankKeyEvents(candidates, options, peakLookup) {
 			className: t.className,
 			...t.label !== void 0 ? { label: t.label } : {},
 			importance,
-			bestEventId: bestEventId ?? "",
+			bestEventId: bestEventId ?? t.trackId,
 			windowMs: t.lastSeen - t.firstSeen
 		});
 	}
@@ -2377,6 +3027,10 @@ var TRACKS_COLUMNS = [
 	{
 		name: "importanceReason",
 		type: "TEXT"
+	},
+	{
+		name: "audioLabels",
+		type: "JSON"
 	}
 ];
 var TRACKS_INDEXES = [{
@@ -2386,6 +3040,17 @@ var TRACKS_INDEXES = [{
 	name: "idx_tracks_device_firstSeen",
 	columns: ["deviceId", "firstSeen"]
 }];
+/** Serialize the per-label aggregate map into the `Track.audioLabels`
+*  array shape, most-frequent label first. */
+function audioLabelsToArray(agg) {
+	return [...agg.entries()].map(([label, a]) => ({
+		label,
+		peakScore: a.peakScore,
+		count: a.count,
+		firstAt: a.firstAt,
+		lastAt: a.lastAt
+	})).sort((a, b) => b.count - a.count);
+}
 function cloneTrack(t) {
 	return {
 		trackId: t.trackId,
@@ -2412,7 +3077,8 @@ function cloneTrack(t) {
 		active: t.active,
 		...t.importance !== void 0 ? { importance: t.importance } : {},
 		...t.bestEventId !== void 0 ? { bestEventId: t.bestEventId } : {},
-		...t.importanceReason !== void 0 ? { importanceReason: t.importanceReason } : {}
+		...t.importanceReason !== void 0 ? { importanceReason: t.importanceReason } : {},
+		...t.audioLabels !== void 0 && t.audioLabels.size > 0 ? { audioLabels: audioLabelsToArray(t.audioLabels) } : {}
 	};
 }
 var TrackStore = class {
@@ -2473,25 +3139,81 @@ var TrackStore = class {
 		this.active.set(params.trackId, fresh);
 		return fresh;
 	}
+	/**
+	* Record one audio-classification EPISODE against every track currently
+	* active on the device — "what was heard on this camera while the track
+	* was alive". Called from the confident-classification audio-event insert
+	* (score ≥ device `classificationMinScore`, class-change-or-heartbeat
+	* coalesced), so counts stay episode-scaled rather than 30 Hz chunk-scaled.
+	*/
+	addAudioLabelEpisode(deviceId, label, score, timestamp) {
+		for (const t of this.active.values()) {
+			if (t.deviceId !== deviceId || !t.active) continue;
+			const agg = t.audioLabels ??= /* @__PURE__ */ new Map();
+			const entry = agg.get(label);
+			if (entry) {
+				entry.peakScore = Math.max(entry.peakScore, score);
+				entry.count += 1;
+				entry.lastAt = timestamp;
+			} else agg.set(label, {
+				peakScore: score,
+				count: 1,
+				firstAt: timestamp,
+				lastAt: timestamp
+			});
+		}
+	}
 	/** Attach a snapshot reference to an active track. */
 	addSnapshot(trackId, snapshot) {
 		const t = this.active.get(trackId);
 		if (!t) return;
 		t.snapshots.push(snapshot);
 		t.lastSnapshotAt = snapshot.timestamp;
+		t.lastSnapshotBbox = { ...snapshot.position.bbox };
+	}
+	/**
+	* Synchronously advance the periodic-snapshot gate reference (clock + bbox) at
+	* the MOMENT a snapshot write is DECIDED — before the async encode/dispatch
+	* lands the real snapshot via {@link addSnapshot}. Without it, `lastSnapshotAt`
+	* only advances when the dispatcher round-trip returns (~50-200ms of sharp
+	* encode), so at 10-25fps several consecutive frames pass
+	* `evaluatePeriodicSnapshot` before the clock moves → a burst of near-identical
+	* snapshots. Mirrors the synchronous `lastFrameAtByTrack` advance for the
+	* rolling `lastFrame`.
+	*
+	* No rollback: if the write later fails the slot is simply lost (a rare dropped
+	* snapshot is preferable to a burst). `addSnapshot` re-stamps the same
+	* clock/bbox when the real snapshot lands, so the two stay consistent. No-op for
+	* an unknown/expired track (the active entry is dropped on expiry, so there is
+	* no separate map to leak).
+	*/
+	markSnapshotPending(trackId, timestamp, bbox) {
+		const t = this.active.get(trackId);
+		if (!t) return;
+		t.lastSnapshotAt = timestamp;
+		t.lastSnapshotBbox = { ...bbox };
 	}
 	lastSnapshotAt(trackId) {
 		return this.active.get(trackId)?.lastSnapshotAt ?? 0;
 	}
+	/** Bbox reference of the last captured snapshot (or the seed bbox), for the
+	*  periodic-snapshot movement gate. Undefined until the clock is seeded. */
+	lastSnapshotBbox(trackId) {
+		const b = this.active.get(trackId)?.lastSnapshotBbox;
+		return b ? { ...b } : void 0;
+	}
 	/**
 	* Seed the snapshot cadence clock (once, at track start) WITHOUT appending a
 	* snapshot, so the first periodic snapshot fires ~snapshotIntervalMs after the
 	* track begins rather than immediately — the `firstFrame` already covers the
 	* track's start. No-op if a snapshot was already taken (clock already set).
 	*/
-	seedSnapshotClock(trackId, timestamp) {
+	seedSnapshotClock(trackId, timestamp, bbox) {
 		const t = this.active.get(trackId);
-		if (t && t.lastSnapshotAt === 0) t.lastSnapshotAt = timestamp;
+		if (t && t.lastSnapshotAt === 0) {
+			t.lastSnapshotAt = timestamp;
+			if (bbox) t.lastSnapshotBbox = { ...bbox };
+		}
 	}
 	getActive(deviceId) {
 		const out = [];
@@ -2502,6 +3224,21 @@ var TrackStore = class {
 		const t = this.active.get(trackId);
 		return t && t.active ? cloneTrack(t) : null;
 	}
+	/**
+	* Cheap read of an active track's promotion-relevant fields WITHOUT the deep
+	* clone `getActiveByTrack` does — the returned `positions` is the live
+	* internal array (read-only; callers must not mutate). Feeds the per-frame
+	* stationary-promotion check, called at inference fps. Null if unknown/expired.
+	*/
+	peekActive(trackId) {
+		const t = this.active.get(trackId);
+		if (!t || !t.active) return null;
+		return {
+			firstSeen: t.firstSeen,
+			positions: t.positions,
+			...t.label !== void 0 ? { label: t.label } : {}
+		};
+	}
 	/** Expire tracks whose `lastSeen` is older than TTL. Persists each
 	*  expired track to the declared collection and returns them. */
 	async expireStale(nowMs) {
@@ -2607,6 +3344,15 @@ var TrackStore = class {
 	clearAll() {
 		this.active.clear();
 	}
+	/**
+	* Drop a single active track WITHOUT persisting it as a historical row. Used
+	* when a track is PROMOTED to a stationary-object registry entry: the durable
+	* record for a parked object is the registry entry, not a Track, so the track
+	* must NOT land in the key-event feed. No-op for an unknown/expired track.
+	*/
+	dropActive(trackId) {
+		this.active.delete(trackId);
+	}
 	/** Delete the persisted track row (keyed by trackId) and drop the in-RAM
 	*  active entry if present. Used by the whole-track deletion cascade. */
 	async deletePersisted(trackId) {
@@ -2739,7 +3485,8 @@ var TrackStore = class {
 				state: t.state,
 				...t.importance !== void 0 ? { importance: t.importance } : {},
 				...t.bestEventId !== void 0 ? { bestEventId: t.bestEventId } : {},
-				...t.importanceReason !== void 0 ? { importanceReason: t.importanceReason } : {}
+				...t.importanceReason !== void 0 ? { importanceReason: t.importanceReason } : {},
+				...t.audioLabels !== void 0 ? { audioLabels: [...t.audioLabels] } : {}
 			}
 		});
 	}
@@ -2752,6 +3499,7 @@ var TrackStore = class {
 		const importance = data["importance"];
 		const bestEventId = data["bestEventId"];
 		const importanceReason = data["importanceReason"];
+		const audioLabels = data["audioLabels"];
 		return {
 			trackId: id,
 			deviceId: Number(data["deviceId"]),
@@ -2768,7 +3516,8 @@ var TrackStore = class {
 			active: false,
 			...typeof importance === "number" ? { importance } : {},
 			...typeof bestEventId === "string" ? { bestEventId } : {},
-			...typeof importanceReason === "string" ? { importanceReason } : {}
+			...typeof importanceReason === "string" ? { importanceReason } : {},
+			...Array.isArray(audioLabels) && audioLabels.length > 0 ? { audioLabels } : {}
 		};
 	}
 };
@@ -3881,13 +4630,10 @@ function stripNulls(data) {
 //#endregion
 //#region src/shared/frame/resolve-frame.ts
 /**
-* Resolve the pixels a `FrameHandle` refers to. Local shm read when the
-* handle's `nodeId` matches `deps.ownNodeId`, else routed via
-* `deps.getRemoteFrame`. Returns `null` when the frame is no longer
-* available (slot recycled locally, or the remote node reports no frame).
+* Resolve the pixels a `FrameHandle` refers to via the node-routed fetch.
+* Returns `null` when the frame is no longer available.
 */
 async function resolveFrame(handle, deps) {
-	if (handle.nodeId === deps.ownNodeId) return deps.readers.read(handle);
 	return deps.getRemoteFrame(handle);
 }
 //#endregion
@@ -4064,11 +4810,7 @@ var EventMediaDispatcher = class {
 		if (events.length === 0 && trackFrames.length === 0 && snapshots.length === 0) return empty;
 		let decoded;
 		try {
-			decoded = await resolveFrame(frameHandle, {
-				ownNodeId: this.deps.ownNodeId,
-				readers: this.deps.readers,
-				getRemoteFrame: this.deps.getRemoteFrame
-			});
+			decoded = await resolveFrame(frameHandle, { getRemoteFrame: this.deps.getRemoteFrame });
 		} catch (err) {
 			this.deps.logger.debug("event media: resolveFrame threw", {
 				tags: { deviceId },
@@ -4379,8 +5121,6 @@ var EmbeddingDispatcher = class {
 	encoder;
 	eventBus;
 	logger;
-	ownNodeId;
-	readers;
 	getRemoteFrame;
 	lastEmbedTime = /* @__PURE__ */ new Map();
 	pendingCrops = /* @__PURE__ */ new Map();
@@ -4393,8 +5133,6 @@ var EmbeddingDispatcher = class {
 		this.encoder = deps.encoder;
 		this.eventBus = deps.eventBus;
 		this.logger = deps.logger;
-		this.ownNodeId = deps.ownNodeId;
-		this.readers = deps.readers;
 		this.getRemoteFrame = deps.getRemoteFrame;
 	}
 	async start() {
@@ -4446,11 +5184,7 @@ var EmbeddingDispatcher = class {
 		}
 		let decoded;
 		try {
-			decoded = await resolveFrame(handle, {
-				ownNodeId: this.ownNodeId,
-				readers: this.readers,
-				getRemoteFrame: this.getRemoteFrame
-			});
+			decoded = await resolveFrame(handle, { getRemoteFrame: this.getRemoteFrame });
 		} catch (err) {
 			this.logger.debug("skip: resolveFrame threw", {
 				tags: { deviceId: Number(deviceId) },
@@ -4697,6 +5431,17 @@ var RESOLUTION_MS = {
 * latest state is never lost.
 */
 var SLICE_WRITE_INTERVAL_MS$1 = 1e3;
+/**
+* Cadence of the synthetic occupancy baseline. When a camera is detached (no
+* inference frames) but has persisted parked objects, the history ring would
+* otherwise stay empty and the chart would read "No occupancy history yet". A
+* device WITH parked entries gets one hydrated sample per this interval — a
+* flat baseline of the parked count — so the graph shows the parking lot's
+* standing occupancy instead of a gap. No sample is emitted for a device
+* without entries, and a real `recordFrame` in the same window suppresses the
+* baseline (it already appended a richer sample).
+*/
+var BASELINE_SAMPLE_INTERVAL_MS = 6e4;
 var ZoneAnalyticsProvider = class {
 	ctx;
 	snapshots = /* @__PURE__ */ new Map();
@@ -4713,8 +5458,17 @@ var ZoneAnalyticsProvider = class {
 	/** Last logged frame-wide occupancy total per device — so the occupancy log
 	*  fires only when the count actually changes, not every inference frame. */
 	lastOccupancyTotal = /* @__PURE__ */ new Map();
+	/** Low-cadence baseline sampler — appends a hydrated occupancy sample for any
+	*  device with parked objects but no live frames. `null` when disabled. */
+	baselineTimer = null;
 	constructor(ctx) {
 		this.ctx = ctx;
+		if (ctx.listStationaryDeviceIds && ctx.listStationaryObjects) {
+			this.baselineTimer = setInterval(() => {
+				this.appendBaselineSamples();
+			}, BASELINE_SAMPLE_INTERVAL_MS);
+			this.baselineTimer.unref?.();
+		}
 		this.sliceThrottle = new SliceThrottler({
 			intervalMs: SLICE_WRITE_INTERVAL_MS$1,
 			equalsIgnoringTs: snapshotEqualsIgnoringTs,
@@ -4736,9 +5490,10 @@ var ZoneAnalyticsProvider = class {
 	/** Stop pending throttle timers — called from addon shutdown. */
 	destroy() {
 		this.sliceThrottle.destroy();
+		if (this.baselineTimer) clearInterval(this.baselineTimer);
 	}
 	async getCurrentSnapshot({ deviceId }) {
-		return this.snapshots.get(deviceId) ?? null;
+		return this.snapshots.get(deviceId) ?? await this.hydrateFromRegistry(deviceId);
 	}
 	async getZoneHistory(input) {
 		return this.bucketize(input.deviceId, input.from, input.to, input.resolution, (snap) => {
@@ -4791,6 +5546,65 @@ var ZoneAnalyticsProvider = class {
 		this.lastOccupancyTotal.delete(deviceId);
 		this.sliceThrottle.forgetDevice(deviceId);
 	}
+	/**
+	* Build an occupancy snapshot for a device purely from its parked-object
+	* registry (no live frame). Returns `null` when hydration is unavailable or
+	* the device has no parked objects — a device with neither frames nor entries
+	* legitimately reports `null`. The snapshot's `ts` is the most recent
+	* `lastConfirmedAt` across entries, falling back to the current tick.
+	*/
+	async hydrateFromRegistry(deviceId) {
+		const listStationary = this.ctx.listStationaryObjects;
+		if (!listStationary) return null;
+		const entries = listStationary(deviceId);
+		if (entries.length === 0) return null;
+		let zones = [];
+		try {
+			zones = await this.ctx.resolveZones?.(deviceId) ?? [];
+		} catch (err) {
+			this.ctx.logger.debug("zone-analytics hydrate zone resolve failed", {
+				tags: { deviceId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		}
+		const ts = mostRecentStationaryConfirmedAt(entries) || Date.now();
+		return buildStationarySnapshot({
+			deviceId,
+			entries,
+			zones,
+			timestamp: ts
+		});
+	}
+	/**
+	* Baseline sampler tick: for every device with parked objects, append a
+	* hydrated sample to the history ring at the CURRENT time — but only when a
+	* real frame hasn't already appended a sample within this interval (frames
+	* flowing = richer samples, no synthetic baseline needed).
+	*/
+	async appendBaselineSamples() {
+		const deviceIds = this.ctx.listStationaryDeviceIds?.() ?? [];
+		const now = Date.now();
+		for (const deviceId of deviceIds) {
+			const ring = this.history.get(deviceId);
+			if (now - (ring && ring.length > 0 ? ring[ring.length - 1].ts : 0) < BASELINE_SAMPLE_INTERVAL_MS) continue;
+			const entries = this.ctx.listStationaryObjects?.(deviceId) ?? [];
+			if (entries.length === 0) continue;
+			let zones = [];
+			try {
+				zones = await this.ctx.resolveZones?.(deviceId) ?? [];
+			} catch {}
+			const snapshot = buildStationarySnapshot({
+				deviceId,
+				entries,
+				zones,
+				timestamp: now
+			});
+			if (snapshot) {
+				this.appendHistory(deviceId, snapshot);
+				this.sliceThrottle.push(deviceId, snapshot);
+			}
+		}
+	}
 	appendHistory(deviceId, snapshot) {
 		const ring = this.history.get(deviceId) ?? [];
 		const cutoff = snapshot.ts - HISTORY_WINDOW_MS;
@@ -4877,9 +5691,43 @@ function computeSnapshot(input) {
 		unzoned: {
 			totalObjects: unzonedTotal,
 			byClass: unzonedByClass
-		}
+		},
+		...input.stationaryObjects !== void 0 && input.stationaryObjects.length > 0 ? { stationaryObjects: input.stationaryObjects } : {}
 	};
 }
+/** Most recent `lastConfirmedAt` across parked entries (0 when none). */
+function mostRecentStationaryConfirmedAt(entries) {
+	let max = 0;
+	for (const e of entries) if (e.lastConfirmedAt > max) max = e.lastConfirmedAt;
+	return max;
+}
+/**
+* Build an occupancy snapshot from parked-object registry entries alone —
+* used when no live inference frame is available (fresh respawn, camera
+* detached). Each entry is folded into the frame aggregate AND attributed to
+* the zones its normalised bbox centroid falls inside (via
+* {@link computeStationaryEntryZones}), so a zone drawn over a parked car
+* reports a count of 1. Returns `null` for an empty entry list. Reuses
+* {@link computeSnapshot} — the SAME aggregation the live frame path runs.
+*/
+function buildStationarySnapshot(input) {
+	if (input.entries.length === 0) return null;
+	const tracked = input.entries.map((e) => ({
+		trackId: `stationary:${e.id}`,
+		className: e.className,
+		zones: computeStationaryEntryZones(e, input.zones)
+	}));
+	const first = input.entries[0];
+	return computeSnapshot({
+		deviceId: input.deviceId,
+		timestamp: input.timestamp,
+		frameWidth: first.frameWidth,
+		frameHeight: first.frameHeight,
+		tracked,
+		zones: input.zones,
+		stationaryObjects: input.entries
+	});
+}
 //#endregion
 //#region src/pipeline-analytics/audio-metrics-provider.ts
 var AUDIO_METRICS_CAP_NAME = "audio-metrics";
@@ -5453,7 +6301,18 @@ var MediaSettingsSchema = object({
 	/** Cadence (ms) for the periodic per-track `snapshot` + rolling `lastFrame`.
 	*  A snapshot is captured for an active track only after this much wall-clock
 	*  has elapsed since its previous one. */
-	snapshotIntervalMs: number().int().min(500).max(6e4).default(5e3)
+	snapshotIntervalMs: number().int().min(500).max(6e4).default(5e3),
+	/** Movement gate for the periodic `snapshot`: once `snapshotIntervalMs` has
+	*  elapsed, a fresh snapshot is only captured when the track's centroid moved
+	*  at least this fraction of the frame DIAGONAL since the last captured
+	*  snapshot. Suppresses near-identical frames from a long-lived / stationary
+	*  track. 0 disables the gate (pure-time behaviour). Default 0.03 ≈ 3% of the
+	*  frame diagonal (~66px on 1080p). */
+	snapshotMovementThreshold: number().min(0).max(1).default(.03),
+	/** Loiterer fallback (ms): force a periodic `snapshot` for a stationary but
+	*  still-present track after this much wall-clock without one, so its
+	*  filmstrip is never empty. Effectively clamped to ≥ `snapshotIntervalMs`. */
+	snapshotMaxIdleMs: number().int().min(1e3).max(6e5).default(3e4)
 });
 var MEDIA_DEFAULTS = MediaSettingsSchema.parse({});
 /**
@@ -5468,7 +6327,148 @@ function resolveMediaSettings(raw) {
 	return {
 		cropPadding: pick("cropPadding"),
 		saveThumbnails: pick("saveThumbnails"),
-		snapshotIntervalMs: pick("snapshotIntervalMs")
+		snapshotIntervalMs: pick("snapshotIntervalMs"),
+		snapshotMovementThreshold: pick("snapshotMovementThreshold"),
+		snapshotMaxIdleMs: pick("snapshotMaxIdleMs")
+	};
+}
+function centroidOf(b) {
+	return {
+		x: b.x + b.w / 2,
+		y: b.y + b.h / 2
+	};
+}
+/** Centroid displacement between two boxes as a fraction of the frame diagonal.
+*  Returns 0 for a degenerate (≤0) frame diagonal so the caller can fall back
+*  to pure-time behaviour instead of dividing by zero. */
+function centroidMovedFraction(a, b, frameWidth, frameHeight) {
+	const diag = Math.hypot(frameWidth, frameHeight);
+	if (diag <= 0) return 0;
+	const ca = centroidOf(a);
+	const cb = centroidOf(b);
+	return Math.hypot(cb.x - ca.x, cb.y - ca.y) / diag;
+}
+/**
+* Decide whether the periodic `snapshot` should be captured for a track THIS
+* frame. Pure: no side effects. The caller keeps the `saveThumbnails` master
+* switch and advances `lastSnapshotAt`/`lastSnapshotBbox` only when a capture
+* actually lands — so a skipped (stationary) frame leaves the clock untouched,
+* which naturally lets `maxIdleMs` fire and re-evaluates movement every frame
+* until the object moves.
+*/
+function evaluatePeriodicSnapshot(input) {
+	const { lastSnapshotAt, lastSnapshotBbox, currentBbox, now, frameWidth, frameHeight, intervalMs, movementThreshold, maxIdleMs } = input;
+	if (lastSnapshotAt <= 0 || now - lastSnapshotAt < intervalMs) {
+		if (lastSnapshotAt > 0 && lastSnapshotBbox !== void 0 && now - lastSnapshotAt >= 1500) {
+			const fastMoved = centroidMovedFraction(lastSnapshotBbox, currentBbox, frameWidth, frameHeight);
+			if (fastMoved >= .08) return {
+				capture: true,
+				reason: "fast-mover",
+				movedFraction: fastMoved
+			};
+		}
+		return {
+			capture: false,
+			reason: "interval-not-elapsed",
+			movedFraction: 0
+		};
+	}
+	if (lastSnapshotBbox === void 0) return {
+		capture: true,
+		reason: "no-reference",
+		movedFraction: 0
+	};
+	const movedFraction = centroidMovedFraction(lastSnapshotBbox, currentBbox, frameWidth, frameHeight);
+	if (movedFraction >= movementThreshold) return {
+		capture: true,
+		reason: "moved",
+		movedFraction
+	};
+	const idleLimit = Math.max(maxIdleMs, intervalMs);
+	if (now - lastSnapshotAt >= idleLimit) return {
+		capture: true,
+		reason: "idle-forced",
+		movedFraction
+	};
+	return {
+		capture: false,
+		reason: "stationary-skip",
+		movedFraction
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/periodic-media-plan.ts
+/**
+* Decide the periodic media writes for one track on one frame. Pure: no side
+* effects. The caller advances its own `lastFrameAt` clock only when the
+* returned `rollingLastFrame` is true.
+*
+* INVARIANT: `appendSnapshot` and `rollingLastFrame` are never both true — the
+* rolling `lastFrame` is never the same frame as an appended `snapshot`, so it
+* can never duplicate one.
+*/
+function planPeriodicMedia(input) {
+	const appendSnapshot = input.dueSnapshot;
+	return {
+		appendSnapshot,
+		rollingLastFrame: input.saveThumbnails && input.now - input.lastFrameAt >= input.intervalMs && !appendSnapshot,
+		bestThumbnail: input.isNewBest
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/key-frame-capture.ts
+/**
+* Pure helpers for the per-track NATIVE-resolution `keyFrame` capture
+* (Design B — one native full-frame per track at its best-detection moment).
+*
+* ## Why this exists (the missing native keyFrame)
+*
+* `keyFrame` was historically captured ONLY inside the CLIP object-embedding
+* best path (`persistObjectEmbeddingBests`, gated by `isClipObjectEmbedding`).
+* Under the two-plane pipeline the root frame carries NO CLIP embedding (clip is
+* a per-track DETAIL served via `runDetailSubtree`, and is disabled cluster-
+* wide), so that gate was never satisfied and the native `keyFrame` was NEVER
+* produced — every stored frame stayed at the ≤640×360 detection resolution.
+*
+* The fix decouples the `keyFrame` from the clip path: it is captured on the
+* GENERAL best-frame signal (the same `bestThumbnail` decision that drives the
+* `thumbnail`), reusing the WORKING native crop path (`captureCrop` →
+* `pipelineRunner.getNativeCrop`, which cuts the ROI from the decode worker's
+* retained NATIVE surface and only falls back to the detection frame on a miss).
+* A full-frame ROI at {@link KEYFRAME_NATIVE_MAX_WIDTH} therefore yields a frame
+* LARGER than the detection raster (up to the cap), which is the whole point of
+* the `keyFrame` kind.
+*/
+/** Cap (px) on the width of the native KEY FRAME (full-frame native capture).
+*  Native resolution is the point, but a full 4K RGB surface over the transport
+*  per new-best is wasteful for a web detail view — 1920px keeps a sharp native
+*  frame while bounding the copy (a miss falls back to the detection-res frame,
+*  which is already ≤640px). */
+var KEYFRAME_NATIVE_MAX_WIDTH = 1920;
+/**
+* The tracks whose native `keyFrame` should be (re)captured THIS frame: exactly
+* the tracks that hit a new best-frame moment (`bestThumbnail`). `putReplacing`
+* downstream keeps one `keyFrame` per track (the current peak).
+*/
+function selectKeyFrameTrackIds(targets) {
+	return targets.filter((t) => t.bestThumbnail).map((t) => t.trackId);
+}
+/**
+* Build the `captureCrop` request for a track's native `keyFrame`: the FULL
+* frame (no padding) at the native width cap. The full-frame box is what makes
+* the capture route through the native surface at native resolution instead of
+* a tight ≤640 detection crop.
+*/
+function buildKeyFrameCaptureRequest(frameWidth, frameHeight) {
+	return {
+		bbox: {
+			x: 0,
+			y: 0,
+			w: frameWidth,
+			h: frameHeight
+		},
+		padding: 0,
+		maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
 	};
 }
 //#endregion
@@ -6805,6 +7805,17 @@ var DEFAULT_MIN_INTERVAL_MS = 1e3;
 /** Default fire cap for a `once` step when its announce omits `maxPerTrack`. */
 var DEFAULT_ONCE_MAX_PER_TRACK = 3;
 /**
+* Consecutive frame-plane misses ("frame + crop both missed") after which a step
+* is ABANDONED for the track. The decode worker serves native crops from a RAM
+* lease store with a ~500ms TTL, so a retry that arrives seconds later re-cuts
+* from an evicted handle and is a guaranteed miss forever. Retrying a
+* permanently-gone frame just burns cross-process RPC + CPU + log lines. Three
+* consecutive misses (each ≥ one tick apart) confidently means the frame is gone
+* for good, while still tolerating a single transient decode-worker hiccup /
+* respawn on a genuinely live track (the counter resets on any resolved result).
+*/
+var MAX_CONSECUTIVE_FRAME_MISSES = 3;
+/**
 * Pure per-(track, step) scheduling state machine for detail-subtree
 * dispatch. Given a camera's announced child steps (`DetailStepAnnounce[]`,
 * read off `PipelineInferenceResultPayload.detailSteps`), decides WHEN each
@@ -6825,7 +7836,9 @@ var DetailScheduler = class {
 				firedCount: 1,
 				lastFiredAt: nowMs,
 				sticky: false,
-				retryPending: false
+				retryPending: false,
+				consecutiveFrameMisses: 0,
+				abandoned: false
 			};
 			steps.set(stepAnnounce.stepId, state);
 			requests.push({
@@ -6858,7 +7871,7 @@ var DetailScheduler = class {
 	tick(nowMs) {
 		const requests = [];
 		for (const [trackId, steps] of this.tracks) for (const state of steps.values()) {
-			if (state.sticky) continue;
+			if (state.sticky || state.abandoned) continue;
 			if (state.retryPending) {
 				if (!this.intervalElapsed(state, nowMs)) continue;
 				if (!this.underMaxPerTrack(state)) {
@@ -6896,7 +7909,8 @@ var DetailScheduler = class {
 		if (!steps) return;
 		const state = steps.get(stepId);
 		if (!state) return;
-		if (state.sticky) return;
+		if (state.sticky || state.abandoned) return;
+		state.consecutiveFrameMisses = 0;
 		const { stickyOnConfidence } = state.announce.cadence;
 		if (confidence !== null && stickyOnConfidence !== void 0 && confidence >= stickyOnConfidence) {
 			state.sticky = true;
@@ -6911,11 +7925,37 @@ var DetailScheduler = class {
 			if (this.underMaxPerTrack(state)) state.retryPending = true;
 		}
 	}
+	/**
+	* A dispatched request could not resolve a frame AT ALL — the frame handle
+	* lease was evicted AND the crop fallback was unavailable (the "frame + crop
+	* both missed" outcome). This is fundamentally different from `onResult(null)`:
+	* there the frame plane WORKED and the model merely returned nothing (worth a
+	* retry on a fresh frame). A frame-plane miss re-cuts from the SAME evicted
+	* handle every time, so it can never recover from this request. It is
+	* retry-eligible only for a bounded number of CONSECUTIVE attempts; after
+	* {@link MAX_CONSECUTIVE_FRAME_MISSES} in a row the step is abandoned for the
+	* track — this is the give-up that breaks the permanent-retry loop. `_nowMs`
+	* is accepted for signature symmetry (backoff is anchored to `lastFiredAt`).
+	*/
+	onFrameMiss(trackId, stepId, _nowMs) {
+		const steps = this.tracks.get(trackId);
+		if (!steps) return;
+		const state = steps.get(stepId);
+		if (!state) return;
+		if (state.sticky || state.abandoned) return;
+		state.consecutiveFrameMisses += 1;
+		if (state.consecutiveFrameMisses >= MAX_CONSECUTIVE_FRAME_MISSES) {
+			state.abandoned = true;
+			state.retryPending = false;
+			return;
+		}
+		if (this.underMaxPerTrack(state)) state.retryPending = true;
+	}
 	onTrackEnded(trackId) {
 		this.tracks.delete(trackId);
 	}
 	canFire(state, nowMs) {
-		if (state.sticky) return false;
+		if (state.sticky || state.abandoned) return false;
 		if (!this.underMaxPerTrack(state)) return false;
 		return this.intervalElapsed(state, nowMs);
 	}
@@ -6938,7 +7978,7 @@ var DetailScheduler = class {
 //#region src/pipeline-analytics/detail-dispatcher.ts
 /**
 * Compose the `steps` list sent to `runDetailSubtree` for one request —
-* identity-aware for the face chain.
+* chain-aware for the multi-step detail subtrees.
 *
 * A `face-detection` request ALSO includes `'face-embedding'` (the full
 * detect→recognize chain) EXCEPT when it is a PERIODIC geometry refresh on a
@@ -6947,13 +7987,35 @@ var DetailScheduler = class {
 * that case runs the detector geometry ALONE. Every recognition-bearing reason
 * (new-track / improve / retry) keeps the embedding regardless of the label.
 *
-* Non-face steps are unchanged (`[req.stepId]`). Pairs with the pipeline's
-* strict-`steps` pruning (`pruneChildStepsToRequested`) — including
-* `'face-embedding'` here is what keeps the nested child in the executed chain.
+* A `plate-detection` request ALWAYS includes `'plate-ocr'` — symmetric to the
+* face chain. Without `'plate-ocr'` in the array the pipeline's strict-`steps`
+* pruning (`pruneChildStepsToRequested`) drops the OCR child, so a detected
+* plate never gets read and no plate text is ever produced. (The dispatcher
+* cannot import the pipeline catalog to derive the child chain — this hardcode
+* mirrors it; keep the two in sync when the catalog's plate subtree changes.)
+*
+* Other steps are unchanged (`[req.stepId]`). Pairs with the pipeline's
+* strict-`steps` pruning — naming the nested child here is what keeps it in the
+* executed chain.
 */
 function composeDetailSteps(req, hasTrackLabel) {
-	if (req.stepId !== "face-detection") return [req.stepId];
-	return req.reason === "periodic" && hasTrackLabel(req.trackId) ? ["face-detection"] : ["face-detection", "face-embedding"];
+	if (req.stepId === "face-detection") return req.reason === "periodic" && hasTrackLabel(req.trackId) ? ["face-detection"] : ["face-detection", "face-embedding"];
+	if (req.stepId === "plate-detection") return ["plate-detection", "plate-ocr"];
+	return [req.stepId];
+}
+/**
+* Does `steps` name a nested-enrichment chain (root detector + a child that
+* produces a `label`/`embedding`), i.e. more than the bare root step? Used to
+* surface a silent enrichment miss (BUG C): a plate detected but never read, a
+* face detected but never embedded — the root detail still routes so the miss
+* is otherwise invisible. `['plate-detection']` alone is NOT a chain.
+*/
+function isEnrichmentChain(steps) {
+	return steps.length > 1;
+}
+/** Does any returned detail carry the enrichment a chain request asked for? */
+function detailsCarryEnrichment(details) {
+	return details.some((d) => d.label !== void 0 || d.embedding !== void 0);
 }
 /** Throttle for the per-device "detail call failed" warn — one line / minute. */
 var FAIL_WARN_THROTTLE_MS = 6e4;
@@ -7030,7 +8092,8 @@ var TrackDetailDispatcher = class {
 				queue: [],
 				inFlight: 0,
 				timer: null,
-				lastFailWarnAt: 0
+				lastFailWarnAt: 0,
+				lastEnrichWarnAt: 0
 			};
 			this.devices.set(deviceId, dev);
 		}
@@ -7073,9 +8136,15 @@ var TrackDetailDispatcher = class {
 	}
 	async dispatch(deviceId, dev, req, frame) {
 		const details = await this.runOnce(deviceId, dev, req, frame);
+		if (details === null) {
+			dev.scheduler.onFrameMiss(req.trackId, req.stepId, Date.now());
+			return;
+		}
 		let topScore = null;
-		if (details !== null && details.length > 0) {
+		if (details.length > 0) {
 			topScore = details.reduce((max, d) => d.score > max ? d.score : max, Number.NEGATIVE_INFINITY);
+			const steps = composeDetailSteps(req, (id) => this.deps.hasTrackLabel?.(id) ?? false);
+			if (isEnrichmentChain(steps) && !detailsCarryEnrichment(details)) this.warnEnrichmentMissThrottled(deviceId, dev, req, steps);
 			try {
 				await this.deps.routeResults(deviceId, req.trackId, details, frame);
 			} catch (err) {
@@ -7157,6 +8226,20 @@ var TrackDetailDispatcher = class {
 			}
 		});
 	}
+	warnEnrichmentMissThrottled(deviceId, dev, req, steps) {
+		const now = Date.now();
+		if (now - dev.lastEnrichWarnAt < FAIL_WARN_THROTTLE_MS) return;
+		dev.lastEnrichWarnAt = now;
+		this.deps.logger.warn("detail chain ran but produced no enrichment (root detected, child yielded no label/embedding)", {
+			tags: { deviceId },
+			meta: {
+				trackId: req.trackId,
+				stepId: req.stepId,
+				reason: req.reason,
+				steps
+			}
+		});
+	}
 };
 //#endregion
 //#region src/pipeline-analytics/overlay-state.ts
@@ -7994,38 +9077,68 @@ var PlateRecognizer = class {
 			name
 		} : null;
 	}
-	/** Live label for a plate read: the recognized vehicle NAME when matched, else
-	*  the raw OCR text (today's behavior). Used by the ingest label path. */
+	/** Live label for a plate read: the recognized vehicle NAME when matched,
+	*  else the raw OCR text. Returns `null` for an implausible read (junk OCR
+	*  off a distant/oblique plate) — the caller must NOT stamp a label then. */
 	resolveLabel(text, score) {
+		if (!isPlausiblePlateRead(text, score)) return null;
 		return this.matchVehicle(text, score)?.name ?? text;
 	}
 	async processFrame(input) {
 		const minConfidence = input.minConfidence ?? 0;
 		const candidates = input.tracked.filter((t) => typeof t.plateText === "string" && t.plateText.length > 0 && typeof t.plateScore === "number" && t.plateScore >= minConfidence && t.plateBbox !== void 0);
 		if (candidates.length === 0) return;
-		for (const c of candidates) {
-			const held = this.bestPlate.get(c.trackId);
-			if (held !== void 0 && c.plateScore <= held.score) continue;
-			let crop;
-			if (input.frameHandle !== void 0) try {
-				crop = await this.deps.captureCrop(input.frameHandle, c.plateBbox, input.frameWidth, input.frameHeight, input.cropPadding) ?? void 0;
-			} catch (err) {
-				this.deps.logger.debug("PlateRecognizer crop capture failed", {
-					tags: { deviceId: input.deviceId },
-					meta: {
-						trackId: c.trackId,
-						error: String(err)
-					}
-				});
-			}
-			this.bestPlate.set(c.trackId, {
-				text: c.plateText,
-				score: c.plateScore,
-				bbox: c.plateBbox,
-				timestamp: input.timestamp,
-				...crop !== void 0 ? { crop } : {}
+		for (const c of candidates) await this.holdBest({
+			deviceId: input.deviceId,
+			trackId: c.trackId,
+			text: c.plateText,
+			score: c.plateScore,
+			bbox: c.plateBbox,
+			timestamp: input.timestamp,
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight,
+			cropPadding: input.cropPadding,
+			...input.frameHandle !== void 0 ? { frameHandle: input.frameHandle } : {}
+		});
+	}
+	/**
+	* Detail-plane entry point (two-plane design): plate-ocr runs on demand per
+	* track via `pipelineRunner.runDetailSubtree`, NOT per frame, so the OCR read
+	* never lands on the per-frame `tracked[]` that {@link processFrame} scans.
+	* The dispatcher's result router calls this with each plate detail so the
+	* gallery still collects the best read + tight crop (persisted on
+	* {@link onTrackEnd}). Without it the plate label rides the event but the
+	* gallery stays empty (0 plateCrop) — the observed live gap.
+	*/
+	async observePlateRead(input) {
+		if (!isPlausiblePlateRead(input.text, input.score)) return;
+		if (input.score < (input.minConfidence ?? 0)) return;
+		await this.holdBest(input);
+	}
+	/** Hold the highest-scoring plate read per track, capturing a tight crop the
+	*  first time a new best is seen (shared by the per-frame + detail-plane paths). */
+	async holdBest(input) {
+		const held = this.bestPlate.get(input.trackId);
+		if (held !== void 0 && input.score <= held.score) return;
+		let crop;
+		if (input.frameHandle !== void 0) try {
+			crop = await this.deps.captureCrop(input.frameHandle, input.bbox, input.frameWidth, input.frameHeight, input.cropPadding) ?? void 0;
+		} catch (err) {
+			this.deps.logger.debug("PlateRecognizer crop capture failed", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					trackId: input.trackId,
+					error: String(err)
+				}
 			});
 		}
+		this.bestPlate.set(input.trackId, {
+			text: input.text,
+			score: input.score,
+			bbox: input.bbox,
+			timestamp: input.timestamp,
+			...crop !== void 0 ? { crop } : {}
+		});
 	}
 	/** Persist the held best plate for a finished track as one PlateStore row
 	*  (crop → MediaStore under ownerKind 'plate'), then drop in-memory state. */
@@ -8361,6 +9474,40 @@ function classifyAudioFrame(top, cfg) {
 //#endregion
 //#region src/pipeline-analytics/event-media-handler.ts
 var CACHE_CONTROL = "public, max-age=31536000, immutable";
+/** Default / clamp bounds for the `thumb` variant edge (px). Mirrors
+*  `shared/frame/square-thumb.ts`; kept here so query parsing stays pure. */
+var THUMB_DEFAULT_SIZE = 160;
+var THUMB_MIN_SIZE$1 = 64;
+var THUMB_MAX_SIZE$1 = 320;
+/**
+* Parse the `?kind=…` query into a preferred stored media kind. Returns null
+* when unset. The value is a free-form kind token (e.g. `crop`); the resolver
+* validates it against the known kinds.
+*/
+function parseEventMediaKind(query) {
+	const kind = new URLSearchParams(query).get("kind");
+	return kind !== null && kind.length > 0 ? kind : null;
+}
+/**
+* Parse the `?variant=…` query into an {@link EventMediaVariant}. Returns null
+* when no small-square rendering was requested (the caller then serves the
+* stored blob). Accepts `variant=thumb` or `square=1`; the edge comes from
+* `size` / `w` / `h` (clamped to [64, 320], default 160).
+*/
+function parseEventMediaVariant(query) {
+	const params = new URLSearchParams(query);
+	if (!(params.get("variant") === "thumb" || params.get("square") === "1")) return null;
+	const sizeRaw = params.get("size") ?? params.get("w") ?? params.get("h");
+	let size = THUMB_DEFAULT_SIZE;
+	if (sizeRaw !== null) {
+		const n = Number.parseInt(sizeRaw, 10);
+		if (Number.isFinite(n)) size = Math.max(THUMB_MIN_SIZE$1, Math.min(THUMB_MAX_SIZE$1, n));
+	}
+	return {
+		kind: "thumb",
+		size
+	};
+}
 /**
 * Create a data-plane handler that serves event thumbnails as JPEG images.
 *
@@ -8374,14 +9521,20 @@ function createEventMediaHandler(deps) {
 			res.writeHead(405, { allow: "GET, HEAD" }).end();
 			return;
 		}
-		const eventId = ((req.url ?? "/").split("?")[0] ?? "/").replace(/^\/+/, "");
+		const url = req.url ?? "/";
+		const qIdx = url.indexOf("?");
+		const rawPath = qIdx === -1 ? url : url.slice(0, qIdx);
+		const query = qIdx === -1 ? "" : url.slice(qIdx + 1);
+		const eventId = rawPath.replace(/^\/+/, "");
 		if (!eventId || eventId.includes("/")) {
 			res.writeHead(404).end();
 			return;
 		}
+		const variant = parseEventMediaVariant(query);
+		const preferKind = parseEventMediaKind(query);
 		let media = null;
 		try {
-			media = await deps.getMedia(eventId);
+			media = await deps.getMedia(eventId, variant ?? void 0, preferKind ?? void 0);
 		} catch {
 			const body = "Internal server error";
 			res.writeHead(500, {
@@ -8414,6 +9567,27 @@ function createEventMediaHandler(deps) {
 		else res.end(Buffer.from(media.bytes));
 	};
 }
+/** JPEG quality for the small square thumbnail (visibly fine at ≤192px, tiny). */
+var THUMB_QUALITY = 70;
+/**
+* Produce a SMALL SQUARE JPEG from an already-encoded image (typically the
+* stored 640×360 `crop`). Center-crop cover to a square then downscale to
+* `size`×`size` at JPEG q70 — the reel/list surfaces want a compact square tile
+* showing the object, not the full 16:9 crop. Output is a fraction of the source
+* (~3–8 KB at 144–192 px vs ~65 KB for the crop), so a fleet-wide reel renders
+* from tiny HTTP-cached tiles instead of full base64 payloads.
+*
+* `fit: 'cover'` + `position: 'centre'` scales the shorter side to `size` and
+* crops the overflow symmetrically — the center square of a square-safe crop
+* fully contains the detector bbox, so the object stays framed.
+*/
+async function makeSquareThumb(bytes, size) {
+	const edge = Math.max(64, Math.min(320, Math.round(size)));
+	return sharp(Buffer.from(bytes)).resize(edge, edge, {
+		fit: "cover",
+		position: "centre"
+	}).jpeg({ quality: THUMB_QUALITY }).toBuffer();
+}
 //#endregion
 //#region src/pipeline-analytics/index.ts
 /**
@@ -8436,18 +9610,17 @@ var DETAIL_FALLBACK_CROP_PADDING = .15;
 *  before re-reading. */
 var CLIP_MODEL_ID_CACHE_TTL_MS = 6e4;
 var SETTINGS_CACHE_TTL_MS = 5e3;
+/** Reconcile cadence for the per-device `zones` / `zoneRules` slice handles.
+*  The `device.state-changed` push doesn't reliably reach a forked child, so
+*  each cached proxy re-pulls both slices on this timer (see ensureProxy) —
+*  a zone drawn in the editor shows up in per-zone stats within one tick. */
+var ZONE_SLICE_RECONCILE_MS = 3e4;
 /** §5 best-frame: a track's `thumbnail` is overwritten only when the current
 *  detection confidence beats the held best by at least this margin (hysteresis
 *  so jitter around a plateau doesn't churn the write). */
 var BEST_FRAME_HYSTERESIS = .05;
 /** §5 best-frame: at most one best-thumbnail capture per this interval per track. */
 var BEST_FRAME_MIN_GAP_MS = 2e3;
-/** Design B: cap (px) on the width of the native KEY FRAME (full-frame native
-*  capture). Native resolution is the point, but a full 4K RGB surface over the
-*  transport per new-best is wasteful for a web detail view — 1920px keeps a
-*  sharp native frame while bounding the copy (a miss falls back to the
-*  detection-res frame, which is already ≤640px). */
-var KEYFRAME_NATIVE_MAX_WIDTH = 1920;
 /** getKeyEvents: max completed tracks pulled from a window before importance
 *  ranking. Ordering is by importance (not firstSeen) and legacy rows score on
 *  read, so we over-fetch candidates and trim to `limit` after sorting. */
@@ -8470,6 +9643,34 @@ var OVERLAY_SYNTHESIS_WARN_THROTTLE_MS = 6e4;
 var AUDIO_EVENT_HEARTBEAT_MS = 5e3;
 var MOTION_EVENT_HEARTBEAT_MS = 5e3;
 /**
+* Stored media kinds that carry NO drawn bounding box, in fallback preference
+* order. The reel forces `?kind=crop`; when a track has no crop the endpoint may
+* degrade only to one of these CLEAN frames — never `fullFrameBoxed` /
+* `thumbnail` / `lastFrame` / `firstFrame` / `snapshot` (all server-boxed).
+*/
+var CLEAN_MEDIA_KINDS = [
+	"crop",
+	"fullFrame",
+	"keyFrame"
+];
+/**
+* Pick a CLEAN (never boxed) media file for a crop-forced request: the exact
+* `preferKind` if it is itself clean and present, else the first available
+* {@link CLEAN_MEDIA_KINDS} frame. Returns undefined when only boxed / no media
+* exists (caller 404s → the viewer shows an icon).
+*/
+function pickCleanMedia(files, preferKind) {
+	const isClean = (k) => CLEAN_MEDIA_KINDS.includes(k);
+	if (isClean(preferKind)) {
+		const exact = files.find((f) => f.kind === preferKind);
+		if (exact) return exact;
+	}
+	for (const kind of CLEAN_MEDIA_KINDS) {
+		const found = files.find((f) => f.kind === kind);
+		if (found) return found;
+	}
+}
+/**
 * Decode a base64 little-endian float32 vector (the `DetailResult.embedding`
 * wire encoding produced by `runDetailSubtree`) back into a plain number[].
 */
@@ -8520,6 +9721,10 @@ function stripGlobalOnlyFields(sections) {
 var PipelineAnalyticsAddon = class extends BaseAddon {
 	processors = /* @__PURE__ */ new Map();
 	trackStore = null;
+	/** Parked-object registry: promotes a track that stopped moving into a
+	*  lightweight entry, suppresses its detections from re-spawning tracks, and
+	*  wakes it when the object departs. Null until onInitialize. */
+	stationaryRegistry = null;
 	mediaStore = null;
 	eventStore = null;
 	identityStore = null;
@@ -8545,9 +9750,6 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	*  detection-pipeline DECODED frame — the ONLY image source (never the
 	*  snapshot cap). Null when shm frame access is unavailable. */
 	eventMediaDispatcher = null;
-	/** Shared shm-ring reader cache for resolving `frameHandle`s to pixels.
-	*  Owned here so segments stay open across frames; closed once on shutdown. */
-	frameReaders = null;
 	/** Object/face embedding dispatcher — migrated from the retired
 	*  enrichment-engine addon. Runs ONLY on the post-processing node; on each
 	*  detection it resolves the frame, crops the ROI, and calls the
@@ -8584,6 +9786,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	*  dataPlane facility in the current environment). */
 	eventMediaBaseUrl = null;
 	lastActiveTrackIds = /* @__PURE__ */ new Map();
+	lastFrameDimsByDevice = /* @__PURE__ */ new Map();
 	lastAudioInsertByDevice = /* @__PURE__ */ new Map();
 	lastMotionInsertByDevice = /* @__PURE__ */ new Map();
 	levelStateByDevice = /* @__PURE__ */ new Map();
@@ -8615,10 +9818,15 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	*  cross-restart "best" gate stays in `ObjectEmbeddingStore.upsertIfBetter`. */
 	objectEmbeddingBestSelector = new TrackBestSelector();
 	/** Design B: the track's shared native key-frame media key, captured at the
-	*  best-detection moment (object-embedding best path). Read by the face path
-	*  at track end so a face row links to the SAME single key frame. Cleared on
-	*  track end. */
+	*  best-detection moment (general best-frame path). Read by the face / plate /
+	*  object-embedding rows so they LINK the SAME single native key frame.
+	*  Cleared on track end. */
 	keyFrameKeyByTrackId = /* @__PURE__ */ new Map();
+	/** Wall-clock of each track's last ACTUALLY-written rolling `lastFrame`. The
+	*  rolling `lastFrame` runs on its OWN pure-time cadence and only on frames
+	*  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();
 	/** 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
@@ -8669,6 +9877,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		await PlateStore.declare(api.settingsStore);
 		await VehicleStore.declare(api.settingsStore);
 		await ObjectEmbeddingStore.declare(api.settingsStore);
+		await StationaryObjectRegistry.declare(api.settingsStore);
 		const logger = this.ctx.logger;
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
@@ -8682,6 +9891,30 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			store: api.settingsStore,
 			logger: logger.child("TrackStore")
 		});
+		this.stationaryRegistry = new StationaryObjectRegistry({
+			store: api.settingsStore,
+			logger: logger.child("StationaryRegistry"),
+			onChange: ({ phase, entry, timestamp }) => {
+				this.ctx.eventBus.emit({
+					id: `pa-stationary-${entry.id}-${phase}`,
+					timestamp: new Date(timestamp),
+					source: {
+						type: "addon",
+						id: "pipeline-analytics",
+						addonId: "pipeline-analytics"
+					},
+					category: EventCategory.PipelineAnalyticsStationaryChanged,
+					data: {
+						deviceId: entry.deviceId,
+						entryId: entry.id,
+						className: entry.className,
+						phase,
+						timestamp
+					}
+				});
+			}
+		});
+		await this.stationaryRegistry.load();
 		this.mediaStore = new MediaStore({
 			storage,
 			store: api.settingsStore,
@@ -8718,33 +9951,33 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				designatedNode: designated
 			} });
 		}
-		this.frameReaders = new FrameRingReaderCache(logger.child("shm-readers"));
-		const decoderApi = api.decoder;
+		const pipelineRunnerApi = api.pipelineRunner;
 		const getRemoteFrame = async (handle) => {
-			if (!decoderApi?.getFrame) return null;
-			const remote = await decoderApi.getFrame.query({
+			if (!pipelineRunnerApi?.getNativeCrop) return null;
+			const full = await pipelineRunnerApi.getNativeCrop.query({
 				handle,
-				nodeId: handle.nodeId
-			});
-			if (!remote) return null;
+				bbox: {
+					x: 0,
+					y: 0,
+					w: 1,
+					h: 1
+				},
+				maxWidth: handle.width
+			}, nodePin(handle.nodeId));
+			if (!full || full.width <= 0 || full.height <= 0) return null;
 			return {
-				data: Buffer.from(remote.data),
-				width: remote.width,
-				height: remote.height,
-				format: remote.format,
-				timestamp: remote.timestamp
+				data: Buffer.from(full.bytes),
+				width: full.width,
+				height: full.height,
+				format: "rgb",
+				timestamp: 0
 			};
 		};
 		this.eventMediaDispatcher = new EventMediaDispatcher({
-			ownNodeId,
-			readers: this.frameReaders,
 			getRemoteFrame,
 			mediaStore: this.mediaStore,
 			logger: logger.child("EventMediaDispatcher")
 		});
-		const ownNodeIdForFaces = ownNodeId;
-		const frameReadersForFaces = this.frameReaders;
-		const pipelineRunnerApi = api.pipelineRunner;
 		const cropMetricLogger = logger.child("NativeCrop");
 		let nativeHits = 0;
 		let nativeFallbacks = 0;
@@ -8776,11 +10009,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				return null;
 			}
 		};
-		const resolveFrameShared = createSharedFrameResolver((frameHandle) => resolveFrame(frameHandle, {
-			ownNodeId: ownNodeIdForFaces,
-			readers: frameReadersForFaces,
-			getRemoteFrame
-		}));
+		const resolveFrameShared = createSharedFrameResolver((frameHandle) => resolveFrame(frameHandle, { getRemoteFrame }));
 		const captureCrop = async (frameHandle, bbox, frameWidth, frameHeight, padding, maxWidth) => {
 			const paddedNorm = padBbox({
 				x: bbox.x / frameWidth,
@@ -8860,7 +10089,10 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		});
 		this.zoneAnalytics = new ZoneAnalyticsProvider({
 			logger: logger.child("ZoneAnalytics"),
-			fetchDevice: (deviceId) => this.ctx.fetchDevice(deviceId)
+			fetchDevice: (deviceId) => this.ctx.fetchDevice(deviceId),
+			listStationaryObjects: (deviceId) => this.stationaryRegistry?.listViews(deviceId) ?? [],
+			listStationaryDeviceIds: () => this.stationaryRegistry?.deviceIds() ?? [],
+			resolveZones: (deviceId) => this.resolveDeviceZones(deviceId)
 		});
 		this.audioMetrics = new AudioMetricsProvider({
 			logger: logger.child("AudioMetrics"),
@@ -8876,9 +10108,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			}
 		});
 		try {
-			const handler = createEventMediaHandler({ getMedia: async (id) => {
+			const handler = createEventMediaHandler({ getMedia: async (id, variant, preferKind) => {
 				try {
-					return await this.readMediaByEventOrKey(id);
+					return await this.readMediaByEventOrKey(id, variant, preferKind);
 				} catch (err) {
 					this.ctx.logger.warn("readEventThumbnail failed", { meta: {
 						eventId: id,
@@ -8936,8 +10168,6 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					encoder: encoderClient,
 					eventBus: this.ctx.eventBus,
 					logger: logger.child("EmbeddingDispatcher"),
-					ownNodeId,
-					readers: frameReadersForFaces,
 					getRemoteFrame
 				});
 				await this.embeddingDispatcher.start();
@@ -8948,6 +10178,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			this.bindingCache?.onBindingsChanged(data);
 			if (data.capName === "pipeline-analytics" && data.reason === "wrapper-deactivated") {
 				this.trackStore?.clearDevice(data.deviceId);
+				this.stationaryRegistry?.forgetDevice(data.deviceId);
 				this.overlayState.clearDevice(data.deviceId);
 				this.overlaySynthesisWarnAt.delete(data.deviceId);
 				this.forgetDeviceProcessors(data.deviceId);
@@ -8962,6 +10193,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.unsubDeviceUnreg = this.ctx.eventBus.subscribe({ category: EventCategory.DeviceUnregistered }, (ev) => {
 			const { deviceId } = ev.data;
 			this.trackStore?.clearDevice(deviceId);
+			this.stationaryRegistry?.forgetDevice(deviceId);
 			this.overlayState.clearDevice(deviceId);
 			this.overlaySynthesisWarnAt.delete(deviceId);
 			this.forgetDeviceProcessors(deviceId);
@@ -8982,6 +10214,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.retentionSweepTimer = setInterval(() => {
 			this.sweepRetention();
 			this.runTrackRetentionSweep();
+			this.stationaryRegistry?.sweep(Date.now());
 		}, RETENTION_SWEEP_INTERVAL_MS);
 		this.ctx.logger.info("pipeline-analytics subscribers installed");
 		const widgetsProvider = { listWidgets: async () => [
@@ -9302,8 +10535,10 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.overlaySynthesisWarnAt.clear();
 		this.processors.clear();
 		this.lastActiveTrackIds.clear();
+		this.lastFrameDimsByDevice.clear();
 		this.dropoutSkipsByKey.clear();
 		this.bestFrameTracker.clear();
+		this.lastFrameAtByTrack.clear();
 		this.trackLifecycleUpdateMem.clear();
 		this.objectEmbeddingBestSelector.clear();
 		this.levelStateByDevice.clear();
@@ -9314,13 +10549,12 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		this.faceGlobalEnabledCache = null;
 		this.mediaCacheByDevice.clear();
 		this.trackStore?.clearAll();
+		this.stationaryRegistry = null;
 		this.bindingCache?.clearAll();
 		await this.eventMediaDataPlane?.dispose();
 		this.eventMediaDataPlane = null;
 		this.eventMediaBaseUrl = null;
 		this.eventMediaDispatcher = null;
-		this.frameReaders?.close();
-		this.frameReaders = null;
 	}
 	async handleInferenceResult(data) {
 		if (this.shuttingDown) return;
@@ -9368,22 +10602,41 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			timestamp: frame.timestamp,
 			frame
 		});
+		if (source === "pipeline") this.stationaryRegistry?.noteFrame(deviceId, result.timestamp);
+		if (this.stationaryRegistry && (result.stationaryConfirmed.length > 0 || result.stationaryWoken.length > 0)) this.stationaryRegistry.applyFrameOutcome({
+			deviceId,
+			confirmed: result.stationaryConfirmed,
+			wokenEntryIds: result.stationaryWoken,
+			timestamp: result.timestamp
+		});
+		const stationaryViews = this.stationaryRegistry?.listViews(deviceId) ?? [];
+		const stationaryAsTracked = stationaryViews.map((v) => ({
+			trackId: `stationary:${v.id}`,
+			className: v.className,
+			zones: computeStationaryEntryZones(v, liveZones)
+		}));
 		this.zoneAnalytics?.recordFrame({
 			deviceId,
 			timestamp: result.timestamp,
 			frameWidth: result.frameWidth,
 			frameHeight: result.frameHeight,
-			tracked: result.tracked,
-			zones: liveZones
+			tracked: stationaryAsTracked.length > 0 ? [...result.tracked, ...stationaryAsTracked] : result.tracked,
+			zones: liveZones,
+			...stationaryViews.length > 0 ? { stationaryObjects: stationaryViews } : {}
+		});
+		if (result.frameWidth > 0 && result.frameHeight > 0) this.lastFrameDimsByDevice.set(deviceId, {
+			w: result.frameWidth,
+			h: result.frameHeight
 		});
 		const currentTrackIds = /* @__PURE__ */ new Set();
+		const positionsCountById = /* @__PURE__ */ new Map();
 		for (const t of result.tracked) {
 			currentTrackIds.add(t.trackId);
 			const center = {
 				x: t.bbox.x + t.bbox.w / 2,
 				y: t.bbox.y + t.bbox.h / 2
 			};
-			this.trackStore.upsert({
+			const upserted = this.trackStore.upsert({
 				trackId: t.trackId,
 				deviceId,
 				className: t.className,
@@ -9398,6 +10651,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				zones: t.zones,
 				state: t.state
 			});
+			positionsCountById.set(t.trackId, upserted.positions.length);
 		}
 		const log = this.ctx.logger.withTags({ deviceId });
 		const prevIds = this.lastActiveTrackIds.get(key) ?? /* @__PURE__ */ new Set();
@@ -9406,6 +10660,18 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		for (const id of currentTrackIds) if (!prevIds.has(id)) {
 			const t = result.tracked.find((x) => x.trackId === id);
 			if (t) {
+				if (classifyTrackAppearance({
+					inPrevActive: false,
+					positionsCount: positionsCountById.get(id) ?? 1
+				}) === "resurrection") {
+					log.info("track resumed", { meta: {
+						trackId: id,
+						className: t.className,
+						source,
+						resurrected: true
+					} });
+					continue;
+				}
 				newTrackCount += 1;
 				log.info("track started", { meta: {
 					trackId: id,
@@ -9419,7 +10685,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						bbox: { ...t.bbox },
 						...t.label ? { label: t.label } : {}
 					});
-					this.trackStore.seedSnapshotClock(id, result.timestamp);
+					this.trackStore.seedSnapshotClock(id, result.timestamp, t.bbox);
 				}
 				this.ctx.eventBus.emit({
 					id: `pa-${randomUUID()}`,
@@ -9465,6 +10731,34 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			} });
 		}
 		this.lastActiveTrackIds.set(key, currentTrackIds);
+		if (source === "pipeline" && this.stationaryRegistry) {
+			const dims = this.lastFrameDimsByDevice.get(deviceId);
+			if (dims && dims.w > 0 && dims.h > 0) {
+				const refDiag = Math.hypot(dims.w, dims.h);
+				for (const t of result.tracked) {
+					const active = this.trackStore.peekActive(t.trackId);
+					if (!active) continue;
+					const { promote } = evaluateStationaryPromotion({
+						positions: active.positions,
+						referenceDiagonalPx: refDiag,
+						now: result.timestamp,
+						config: DEFAULT_PROMOTION_CONFIG
+					});
+					if (!promote) continue;
+					this.promoteToStationary({
+						deviceId,
+						key,
+						processor,
+						track: t,
+						firstSeen: active.firstSeen,
+						label: active.label,
+						frameWidth: result.frameWidth,
+						frameHeight: result.frameHeight,
+						timestamp: result.timestamp
+					});
+				}
+			}
+		}
 		if (this.detailDispatcher && detailSteps && detailSteps.length > 0) {
 			const dispatcher = this.detailDispatcher;
 			const steps = detailSteps;
@@ -9533,7 +10827,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			let plateCrops = 0;
 			for (const crops of childCropsByEvent.values()) for (const c of crops) if (c.kind === "faceCrop") faceCrops += 1;
 			else plateCrops += 1;
-			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings);
+			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings, result.frameWidth, result.frameHeight);
+			const keyFrameTrackIds = selectKeyFrameTrackIds(snapshotTargets);
+			if (keyFrameTrackIds.length > 0) this.persistKeyFrames(deviceId, result.timestamp, keyFrameTrackIds, frameHandle, result.frameWidth, result.frameHeight);
 			if (eventTargets.length > 0 || firstFrameTargets.length > 0 || snapshotTargets.length > 0) {
 				const captureCounts = {
 					events: eventTargets.length,
@@ -9748,14 +11044,36 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			if (isFaceDetail && d.embedding !== void 0) await this.routeFaceDetail(deviceId, trackId, d, frame);
 			else if (d.embedding !== void 0) await this.routeClipDetail(deviceId, trackId, d, frame.timestamp);
 			else if (d.label !== void 0 && d.label.length > 0) {
-				if (d.className === "plate" && d.bbox !== void 0) this.overlayState.notePlateDetail(deviceId, trackId, {
-					x: d.bbox.x,
-					y: d.bbox.y,
-					w: d.bbox.w,
-					h: d.bbox.h
-				}, d.score, d.label, frame.timestamp);
-				const label = d.className === "plate" ? this.plateRecognizer?.resolveLabel(d.label, d.score) ?? d.label : d.label;
-				await this.applyTrackEnrichmentLabel(deviceId, trackId, label);
+				if (d.className === "plate" && d.bbox !== void 0) {
+					this.overlayState.notePlateDetail(deviceId, trackId, {
+						x: d.bbox.x,
+						y: d.bbox.y,
+						w: d.bbox.w,
+						h: d.bbox.h
+					}, d.score, d.label, frame.timestamp);
+					if (this.plateRecognizer) {
+						const mediaSettings = await this.resolveDeviceMediaSettings(deviceId);
+						await this.plateRecognizer.observePlateRead({
+							deviceId,
+							trackId,
+							text: d.label,
+							score: d.score,
+							bbox: {
+								x: d.bbox.x,
+								y: d.bbox.y,
+								w: d.bbox.w,
+								h: d.bbox.h
+							},
+							timestamp: frame.timestamp,
+							frameWidth: frame.frameWidth,
+							frameHeight: frame.frameHeight,
+							cropPadding: mediaSettings.cropPadding,
+							...frame.frameHandle !== void 0 ? { frameHandle: frame.frameHandle } : {}
+						});
+					}
+				}
+				const label = d.className === "plate" ? this.plateRecognizer?.resolveLabel(d.label, d.score) ?? null : d.label;
+				if (label !== null && label !== void 0) await this.applyTrackEnrichmentLabel(deviceId, trackId, label);
 			}
 		} catch (err) {
 			this.ctx.logger.warn("detail result route failed", {
@@ -9902,55 +11220,26 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		await Promise.all(bests.map(async (t) => {
 			if (!isClipObjectEmbedding(t)) return;
 			let mediaKey;
-			let keyFrameMediaKey;
-			if (frameHandle !== void 0 && this.captureCrop && this.mediaStore) {
-				try {
-					const crop = await this.captureCrop(frameHandle, t.bbox, frameWidth, frameHeight, cropPadding);
-					if (crop) mediaKey = await this.mediaStore.putReplacing({
-						deviceId,
-						ownerKind: "track",
-						ownerId: t.trackId,
-						kind: "crop",
-						timestamp,
-						data: crop
-					});
-				} catch (err) {
-					this.ctx.logger.debug("object-embedding crop capture failed", {
-						tags: { deviceId },
-						meta: {
-							trackId: t.trackId,
-							error: errMsg(err)
-						}
-					});
-				}
-				try {
-					const keyFrame = await this.captureCrop(frameHandle, {
-						x: 0,
-						y: 0,
-						w: frameWidth,
-						h: frameHeight
-					}, frameWidth, frameHeight, 0, KEYFRAME_NATIVE_MAX_WIDTH);
-					if (keyFrame) {
-						keyFrameMediaKey = await this.mediaStore.putReplacing({
-							deviceId,
-							ownerKind: "track",
-							ownerId: t.trackId,
-							kind: "keyFrame",
-							timestamp,
-							data: keyFrame
-						});
-						this.keyFrameKeyByTrackId.set(t.trackId, keyFrameMediaKey);
+			if (frameHandle !== void 0 && this.captureCrop && this.mediaStore) try {
+				const crop = await this.captureCrop(frameHandle, t.bbox, frameWidth, frameHeight, cropPadding);
+				if (crop) mediaKey = await this.mediaStore.putReplacing({
+					deviceId,
+					ownerKind: "track",
+					ownerId: t.trackId,
+					kind: "crop",
+					timestamp,
+					data: crop
+				});
+			} catch (err) {
+				this.ctx.logger.debug("object-embedding crop capture failed", {
+					tags: { deviceId },
+					meta: {
+						trackId: t.trackId,
+						error: errMsg(err)
 					}
-				} catch (err) {
-					this.ctx.logger.debug("key-frame capture failed", {
-						tags: { deviceId },
-						meta: {
-							trackId: t.trackId,
-							error: errMsg(err)
-						}
-					});
-				}
+				});
 			}
+			const keyFrameMediaKey = this.keyFrameKeyByTrackId.get(t.trackId);
 			await store.upsertIfBetter({
 				trackId: t.trackId,
 				deviceId,
@@ -9964,6 +11253,48 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			});
 		}));
 	}
+	/**
+	* Capture ONE native-resolution KEY FRAME per given track at this best-
+	* detection frame and store it (`putReplacing` → one keyFrame per track).
+	*
+	* The full frame is cropped NATIVE-FIRST via `captureCrop`: the request is the
+	* FULL frame (no padding) at `KEYFRAME_NATIVE_MAX_WIDTH`, which routes through
+	* `pipelineRunner.getNativeCrop` (the decode worker's retained native surface)
+	* and only falls back to the ≤640 detection frame when the native lease is
+	* gone. The stored key is recorded in `keyFrameKeyByTrackId` so the face /
+	* plate / object-embedding rows LINK the SAME native key frame (Design B).
+	* Issued in the live-frame window so the native lease is still held. Best-
+	* effort (D8) — a per-track failure is logged and never thrown.
+	*/
+	async persistKeyFrames(deviceId, timestamp, trackIds, frameHandle, frameWidth, frameHeight) {
+		const capture = this.captureCrop;
+		const mediaStore = this.mediaStore;
+		if (!capture || !mediaStore) return;
+		const req = buildKeyFrameCaptureRequest(frameWidth, frameHeight);
+		await Promise.all(trackIds.map(async (trackId) => {
+			try {
+				const keyFrame = await capture(frameHandle, req.bbox, frameWidth, frameHeight, req.padding, req.maxWidth);
+				if (!keyFrame) return;
+				const key = await mediaStore.putReplacing({
+					deviceId,
+					ownerKind: "track",
+					ownerId: trackId,
+					kind: "keyFrame",
+					timestamp,
+					data: keyFrame
+				});
+				this.keyFrameKeyByTrackId.set(trackId, key);
+			} catch (err) {
+				this.ctx.logger.debug("key-frame capture failed", {
+					tags: { deviceId },
+					meta: {
+						trackId,
+						error: errMsg(err)
+					}
+				});
+			}
+		}));
+	}
 	/** Emit a `PipelineAnalyticsTrackLifecycle` event (start / update / end). */
 	emitTrackLifecycle(payload, timestamp) {
 		this.ctx.eventBus.emit({
@@ -10013,27 +11344,48 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			...track?.zonesVisited !== void 0 ? { zonesVisited: track.zonesVisited } : {},
 			...track?.totalDistance !== void 0 ? { totalDistance: track.totalDistance } : {},
 			...track?.positions !== void 0 ? { positionsCount: track.positions.length } : {},
+			...track?.audioLabels !== void 0 ? { audioLabels: track.audioLabels } : {},
 			...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {},
 			...t.embeddingModelId !== void 0 ? { embeddingModelId: t.embeddingModelId } : {}
 		});
 		this.emitTrackLifecycle(payload, timestamp);
 	}
-	buildSnapshotTargets(deviceId, tracked, timestamp, media) {
+	buildSnapshotTargets(deviceId, tracked, timestamp, media, frameWidth, frameHeight) {
 		const targets = [];
 		for (const t of tracked) {
 			const lastSnap = this.trackStore.lastSnapshotAt(t.trackId);
-			const dueSnapshot = media.saveThumbnails && lastSnap > 0 && timestamp - lastSnap >= media.snapshotIntervalMs;
+			const dueSnapshot = media.saveThumbnails && evaluatePeriodicSnapshot({
+				lastSnapshotAt: lastSnap,
+				lastSnapshotBbox: this.trackStore.lastSnapshotBbox(t.trackId),
+				currentBbox: t.bbox,
+				now: timestamp,
+				frameWidth,
+				frameHeight,
+				intervalMs: media.snapshotIntervalMs,
+				movementThreshold: media.snapshotMovementThreshold,
+				maxIdleMs: media.snapshotMaxIdleMs
+			}).capture;
 			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp);
 			this.maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest);
-			if (!dueSnapshot && !isNewBest) continue;
+			const plan = planPeriodicMedia({
+				saveThumbnails: media.saveThumbnails,
+				dueSnapshot,
+				isNewBest,
+				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;
 			targets.push({
 				trackId: t.trackId,
 				timestamp,
 				bbox: { ...t.bbox },
 				...t.label ? { label: t.label } : {},
-				appendSnapshot: dueSnapshot,
-				rollingLastFrame: dueSnapshot,
-				bestThumbnail: isNewBest
+				appendSnapshot: plan.appendSnapshot,
+				rollingLastFrame: plan.rollingLastFrame,
+				bestThumbnail: plan.bestThumbnail
 			});
 		}
 		return targets;
@@ -10089,6 +11441,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				atMs: timestamp
 			});
 			await this.eventStore.insertAudio(ev);
+			this.trackStore?.addAudioLabelEpisode(deviceId, route.className, topClassification.score, timestamp);
 			this.ctx.eventBus.emit({
 				id: `pa-${ev.id}`,
 				timestamp: new Date(ev.timestamp),
@@ -10306,6 +11659,11 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					const peak = await this.eventStore?.peakForTrack(t.trackId);
 					if (peak) {
 						endBestEventId = peak.bestEventId;
+						const dims = this.lastFrameDimsByDevice.get(t.deviceId);
+						const staticMetrics = dims ? computeStaticTrackMetrics(t.positions.map((p) => ({
+							x: p.x,
+							y: p.y
+						})), Math.hypot(dims.w, dims.h)) : void 0;
 						const { importance, reason } = computeImportance({
 							peakConfidence: trackerPeak?.confidence ?? peak.peakConfidence,
 							className: t.className,
@@ -10313,7 +11671,11 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 							peakBboxAreaFrac: peak.peakBboxAreaFrac,
 							totalDistance: t.totalDistance,
 							zonesVisited: t.zonesVisited,
-							...t.label !== void 0 ? { label: t.label } : {}
+							...t.label !== void 0 ? { label: t.label } : {},
+							...staticMetrics ? {
+								netDisplacementFrac: staticMetrics.netDisplacementFrac,
+								pathSpanFrac: staticMetrics.pathSpanFrac
+							} : {}
 						});
 						endImportance = importance;
 						endImportanceReason = reason;
@@ -10328,6 +11690,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				}
 				this.bestFrameTracker.delete(t.trackId);
 				this.objectEmbeddingBestSelector.delete(t.trackId);
+				this.lastFrameAtByTrack.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) {
@@ -10372,6 +11735,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					positionsCount: t.positions.length,
 					...endImportance !== void 0 ? { importance: endImportance } : {},
 					...endImportanceReason !== void 0 ? { importanceReason: endImportanceReason } : {},
+					...t.audioLabels !== void 0 ? { audioLabels: t.audioLabels } : {},
 					...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {},
 					...endBestEventId !== void 0 ? { bestEventId: endBestEventId } : {}
 				});
@@ -10534,6 +11898,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		for (const k of this.processors.keys()) if (k.startsWith(prefix)) this.processors.delete(k);
 		for (const k of this.lastActiveTrackIds.keys()) if (k.startsWith(prefix)) this.lastActiveTrackIds.delete(k);
 		for (const k of this.dropoutSkipsByKey.keys()) if (k.startsWith(prefix)) this.dropoutSkipsByKey.delete(k);
+		this.lastFrameDimsByDevice.delete(deviceId);
 	}
 	/** Apply a mutation to every live source-processor of a device (zones/rules
 	*  are device-level and must reach all sources). */
@@ -10541,6 +11906,57 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		const prefix = `${deviceId}:`;
 		for (const [k, p] of this.processors) if (k.startsWith(prefix)) fn(p);
 	}
+	/**
+	* Turn a parked track into a stationary-registry entry and tear the track
+	* down WITHOUT firing an 'end' key-event / importance scoring / media flush
+	* (a parked object is not a highlight; the durable record is the entry). The
+	* tracker + store forget the track so its detections stop re-spawning tracks,
+	* and the registry suppresses them from the next frame on.
+	*/
+	promoteToStationary(input) {
+		const { deviceId, key, processor, track, firstSeen, label, frameWidth, frameHeight, timestamp } = input;
+		const keyFrameMediaKey = this.keyFrameKeyByTrackId.get(track.trackId);
+		const entry = {
+			id: randomUUID(),
+			deviceId,
+			className: track.className,
+			bbox: { ...track.bbox },
+			frameWidth,
+			frameHeight,
+			firstSeenAt: firstSeen,
+			becameStationaryAt: timestamp,
+			lastConfirmedAt: timestamp,
+			sourceTrackId: track.trackId,
+			...label !== void 0 ? { label } : {},
+			...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {}
+		};
+		this.stationaryRegistry?.promote(entry);
+		processor.dropTrack(track.trackId);
+		this.trackStore?.dropActive(track.trackId);
+		const faceEnd = this.faceRecognizer?.onTrackEnd(deviceId, track.trackId);
+		const dropKeyFrame = () => {
+			this.keyFrameKeyByTrackId.delete(track.trackId);
+		};
+		if (faceEnd) faceEnd.finally(dropKeyFrame);
+		else dropKeyFrame();
+		this.plateRecognizer?.onTrackEnd(deviceId, track.trackId);
+		this.bestFrameTracker.delete(track.trackId);
+		this.objectEmbeddingBestSelector.delete(track.trackId);
+		this.lastFrameAtByTrack.delete(track.trackId);
+		this.trackLifecycleUpdateMem.delete(track.trackId);
+		this.detailDispatcher?.onTrackEnded(deviceId, track.trackId);
+		this.overlayState.onTrackEnded(deviceId, track.trackId);
+		this.lastActiveTrackIds.get(key)?.delete(track.trackId);
+		this.ctx.logger.info("track promoted to stationary", {
+			tags: { deviceId },
+			meta: {
+				trackId: track.trackId,
+				className: track.className,
+				entryId: entry.id,
+				...label ? { label } : {}
+			}
+		});
+	}
 	async getOrCreateProcessor(deviceId, source) {
 		const key = this.procKey(deviceId, source);
 		let p = this.processors.get(key);
@@ -10566,6 +11982,18 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				cooldownSec,
 				minTrackAgeMs: trk.minTrackAgeMs
 			}, 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
+				}) });
+			}
 			this.processors.set(key, p);
 		}
 		return p;
@@ -10577,6 +12005,16 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	* forward updates to the per-device FrameProcessor so a rule change
 	* applies to the very next frame even when frames stop briefly
 	* (e.g. during binding flips).
+	*
+	* RECONCILE: the push channel behind `subscribe` (`device.state-changed`
+	* via `live.onEvent`) does not reliably reach a forked addon child — a
+	* zone created AFTER the proxy's cold read stayed invisible until the
+	* addon respawned (live-diagnosed on device 617, 2026-07-16: zone slice
+	* populated hub-side, `zones: []` in every snapshot). Events are lossy
+	* telemetry (D8); the durable channel is RPC + reconcile — so each
+	* proxy also refreshes its two slices on a slow timer. `refresh()`
+	* round-trips `deviceState.getCapSlice` and fans out through the SAME
+	* subscribe callbacks above, so a zone edit lands within one interval.
 	*/
 	async ensureProxy(deviceId) {
 		const cached = this.proxies.get(deviceId);
@@ -10585,13 +12023,22 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			const proxy = await this.ctx.api.deviceManager ? await this.ctx.fetchDevice(deviceId) : null;
 			if (!proxy) return null;
 			this.proxies.set(deviceId, proxy);
-			const unsubs = [proxy.state.zones.subscribe((slice) => {
-				const zones = slice?.zones ?? [];
-				this.forEachDeviceProcessor(deviceId, (p) => p.setZones(zones));
-			}), proxy.state.zoneRules.subscribe((slice) => {
-				const rules = slice?.detection ?? [];
-				this.forEachDeviceProcessor(deviceId, (p) => p.setDetectionRules(rules));
-			})];
+			const reconcile = setInterval(() => {
+				proxy.state.zones.refresh().catch(() => void 0);
+				proxy.state.zoneRules.refresh().catch(() => void 0);
+			}, ZONE_SLICE_RECONCILE_MS);
+			reconcile.unref?.();
+			const unsubs = [
+				proxy.state.zones.subscribe((slice) => {
+					const zones = slice?.zones ?? [];
+					this.forEachDeviceProcessor(deviceId, (p) => p.setZones(zones));
+				}),
+				proxy.state.zoneRules.subscribe((slice) => {
+					const rules = slice?.detection ?? [];
+					this.forEachDeviceProcessor(deviceId, (p) => p.setDetectionRules(rules));
+				}),
+				() => clearInterval(reconcile)
+			];
 			this.proxyUnsubs.set(deviceId, unsubs);
 			return proxy;
 		} catch (err) {
@@ -10602,6 +12049,21 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			return null;
 		}
 	}
+	/**
+	* Resolve a device's current 0–1 zone catalogue independent of the live
+	* frame path — used by zone-analytics snapshot hydration + the occupancy
+	* baseline sampler when the camera is detached (no frames). Warms the proxy
+	* (cold read via `fetchDevice`) and, when the cached slice is empty, forces
+	* one `refresh()` round-trip so a just-created proxy returns real zones.
+	*/
+	async resolveDeviceZones(deviceId) {
+		const proxy = await this.ensureProxy(deviceId);
+		if (!proxy) return [];
+		const cached = proxy.state.zones.value?.zones;
+		if (cached && cached.length > 0) return cached;
+		await proxy.state.zones.refresh().catch(() => void 0);
+		return proxy.state.zones.value?.zones ?? [];
+	}
 	releaseProxy(deviceId) {
 		const unsubs = this.proxyUnsubs.get(deviceId);
 		if (unsubs) for (const u of unsubs) try {
@@ -10623,6 +12085,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	}
 	async clearTracks(input) {
 		this.trackStore?.clearDevice(input.deviceId);
+		this.stationaryRegistry?.clearDevice(input.deviceId);
 		this.overlayState.clearDevice(input.deviceId);
 		this.overlaySynthesisWarnAt.delete(input.deviceId);
 		const prefix = `${input.deviceId}:`;
@@ -10924,6 +12387,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	* Enrolled gallery + identity media are exempt.
 	*/
 	async wipeAllAnalytics(input) {
+		await this.stationaryRegistry?.clearDevice(input.deviceId);
 		return this.pruneTracksBefore({
 			deviceId: input.deviceId,
 			cutoffMs: Date.now()
@@ -10975,24 +12439,62 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	* points its thumbnail at the embedding row's crop key (a `track:…:crop:…`
 	* key), so this resolves that crop; event ids stay on the event-crop path.
 	*/
-	async readMediaByEventOrKey(id) {
-		if (id.includes(":")) {
-			const file = await (this.mediaStore?.getByKey(id) ?? Promise.resolve(null));
-			if (!file) return null;
+	async readMediaByEventOrKey(id, variant, preferKind) {
+		const base = id.includes(":") ? await this.readMediaByKey(id) : await this.readEventThumbnail(id, preferKind);
+		if (base === null || variant === void 0) return base;
+		return this.applyThumbVariant(base, variant);
+	}
+	async readMediaByKey(id) {
+		const file = await (this.mediaStore?.getByKey(id) ?? Promise.resolve(null));
+		if (!file) return null;
+		return {
+			bytes: Buffer.from(file.base64, "base64"),
+			key: file.key
+		};
+	}
+	/**
+	* Render a small center-cropped square from a resolved event media blob for
+	* the reel / list surfaces. The returned `key` is variant-distinct so the
+	* data-plane ETag never collides with the full-size blob's. On any encode
+	* failure the full blob is served (a thumb must never 500 / blank a tile).
+	*/
+	async applyThumbVariant(media, variant) {
+		try {
 			return {
-				bytes: Buffer.from(file.base64, "base64"),
-				key: file.key
+				bytes: await makeSquareThumb(media.bytes, variant.size),
+				key: `${media.key}|t${variant.size}`
 			};
+		} catch (err) {
+			this.ctx.logger.debug("event media: thumb variant failed — serving full", { meta: {
+				key: media.key,
+				size: variant.size,
+				error: errMsg(err)
+			} });
+			return media;
 		}
-		return this.readEventThumbnail(id);
 	}
-	async readEventThumbnail(eventId) {
-		const files = await (this.mediaStore?.listByOwner("event", eventId) ?? Promise.resolve([]));
-		const chosen = files.find((f) => f.kind === "crop") ?? files.find((f) => f.kind === "fullFrameBoxed") ?? files[0];
-		if (!chosen) return null;
+	async readEventThumbnail(id, preferKind) {
+		const eventFiles = await (this.mediaStore?.listByOwner("event", id) ?? Promise.resolve([]));
+		if (preferKind !== void 0 && preferKind.length > 0) {
+			const trackFiles = await (this.mediaStore?.listByOwner("track", id) ?? Promise.resolve([]));
+			const clean = pickCleanMedia([...eventFiles, ...trackFiles], preferKind);
+			if (!clean) return null;
+			return {
+				bytes: Buffer.from(clean.base64, "base64"),
+				key: clean.key
+			};
+		}
+		const chosenEvent = eventFiles.find((f) => f.kind === "crop") ?? eventFiles.find((f) => f.kind === "fullFrameBoxed") ?? eventFiles[0];
+		if (chosenEvent) return {
+			bytes: Buffer.from(chosenEvent.base64, "base64"),
+			key: chosenEvent.key
+		};
+		const trackFiles = await (this.mediaStore?.listByOwner("track", id) ?? Promise.resolve([]));
+		const chosenTrack = trackFiles.find((f) => f.kind === "thumbnail") ?? trackFiles.find((f) => f.kind === "lastFrame") ?? trackFiles.find((f) => f.kind === "firstFrame") ?? [...trackFiles].reverse().find((f) => f.kind === "snapshot") ?? trackFiles[trackFiles.length - 1];
+		if (!chosenTrack) return null;
 		return {
-			bytes: Buffer.from(chosen.base64, "base64"),
-			key: chosen.key
+			bytes: Buffer.from(chosenTrack.base64, "base64"),
+			key: chosenTrack.key
 		};
 	}
 	/**
@@ -11085,6 +12587,32 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						unit: "s",
 						displayScale: 1e3
 					},
+					{
+						type: "slider",
+						key: "snapshotMovementThreshold",
+						label: "Snapshot movement gate",
+						description: "After the interval elapses, only capture a snapshot if the object moved this fraction of the frame since the last one. Higher = fewer near-identical frames. 0 disables the gate.",
+						min: 0,
+						max: .15,
+						step: .005,
+						default: .03,
+						showValue: true,
+						unit: "%",
+						displayScale: .01
+					},
+					{
+						type: "slider",
+						key: "snapshotMaxIdleMs",
+						label: "Snapshot max idle",
+						description: "Force a snapshot for a stationary but still-present track after this long without one, so its filmstrip is never empty.",
+						min: 5e3,
+						max: 12e4,
+						step: 5e3,
+						default: 3e4,
+						showValue: true,
+						unit: "s",
+						displayScale: 1e3
+					},
 					{
 						type: "select",
 						key: "mediaAttachPolicy",
@@ -11540,4 +13068,4 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { PipelineAnalyticsAddon as default, stripGlobalOnlyFields, toAnalyticsDeviceSections };
+export { PipelineAnalyticsAddon as default, pickCleanMedia, stripGlobalOnlyFields, toAnalyticsDeviceSections };