@camstack/addon-post-analysis 1.1.29 → 1.1.30

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-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-CFjLqX2m.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";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -2496,6 +2496,14 @@ var StationaryObjectRegistry = class {
 	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) {
@@ -2715,6 +2723,26 @@ function rowToEntry(id, data) {
 	};
 }
 //#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;
@@ -5403,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();
@@ -5419,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,
@@ -5442,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) => {
@@ -5497,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;
@@ -5587,6 +5695,39 @@ function computeSnapshot(input) {
 		...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";
@@ -7664,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
@@ -7684,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({
@@ -7717,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)) {
@@ -7755,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;
@@ -7770,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);
 	}
@@ -7955,8 +8136,12 @@ 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);
@@ -9289,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.
 *
@@ -9302,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, {
@@ -9342,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
 /**
@@ -9397,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[].
 */
@@ -9815,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"),
@@ -9831,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,
@@ -10336,7 +10613,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		const stationaryAsTracked = stationaryViews.map((v) => ({
 			trackId: `stationary:${v.id}`,
 			className: v.className,
-			zones: []
+			zones: computeStationaryEntryZones(v, liveZones)
 		}));
 		this.zoneAnalytics?.recordFrame({
 			deviceId,
@@ -11772,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 {
@@ -12147,19 +12439,51 @@ 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(id) {
+	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"),
@@ -12744,4 +13068,4 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { PipelineAnalyticsAddon as default, stripGlobalOnlyFields, toAnalyticsDeviceSections };
+export { PipelineAnalyticsAddon as default, pickCleanMedia, stripGlobalOnlyFields, toAnalyticsDeviceSections };

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-D0V4LPAq.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-DeoVBjEB.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.1.29",
+  "version": "1.1.30",
   "description": "CamStack Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",