@camstack/addon-post-analysis 1.2.5 → 1.2.6

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { C as hydrateSchema, D as object, E as number, O as string, S as createEvent, T as boolean, _ as videoclipsCapability, a as OpsLogEntrySchema, b as BaseAddon, c as buildEventKindDescriptor, d as faceGalleryCapability, g as subKindsOf, h as plateGalleryCapability, i as MACRO_LABELS, k as EventCategory, l as cosineSimilarity, m as pipelineAnalyticsCapability, n as EVENT_KIND_BY_CAP, o as addonWidgetsSourceCapability, p as nodePin, r as EVENT_PAD_MS, s as audioMetricsCapability, t as DEFAULT_EVENT_COLOR, v as zoneAnalyticsCapability, w as array, x as DeviceType, y as errMsg } from "../dist-Db0CsDGK.mjs";
+import { C as hydrateSchema, D as object, E as number, O as string, S as createEvent, T as boolean, _ as videoclipsCapability, a as OpsLogEntrySchema, b as BaseAddon, c as buildEventKindDescriptor, d as faceGalleryCapability, g as subKindsOf, h as plateGalleryCapability, i as MACRO_LABELS, k as EventCategory, l as cosineSimilarity, m as pipelineAnalyticsCapability, n as EVENT_KIND_BY_CAP, o as addonWidgetsSourceCapability, p as nodePin, r as EVENT_PAD_MS, s as audioMetricsCapability, t as DEFAULT_EVENT_COLOR, v as zoneAnalyticsCapability, w as array, x as DeviceType, y as errMsg } from "../dist-DGkWhfba.mjs";
 import { randomUUID } from "node:crypto";
 import sharp from "sharp";
 //#region src/pipeline-analytics/videoclips-provider.ts
@@ -2086,6 +2086,7 @@ var FrameProcessor = class {
 		const firstLevelBboxById = /* @__PURE__ */ new Map();
 		const sourceIdByBbox = /* @__PURE__ */ new Map();
 		const faceBboxByBbox = /* @__PURE__ */ new Map();
+		const nativeFaceSizeByBbox = /* @__PURE__ */ new Map();
 		const faceAlignedCropByBbox = /* @__PURE__ */ new Map();
 		const plateByBbox = /* @__PURE__ */ new Map();
 		const maskByBbox = /* @__PURE__ */ new Map();
@@ -2131,6 +2132,7 @@ var FrameProcessor = class {
 				h: det.bbox.height
 			});
 			if (det.faceAlignedCrop !== void 0) faceAlignedCropByBbox.set(parentBbox, det.faceAlignedCrop);
+			if (det.nativeFaceShortSidePx !== void 0) nativeFaceSizeByBbox.set(parentBbox, det.nativeFaceShortSidePx);
 			if (det.embedding !== void 0 && !embeddingByBbox.has(parentBbox)) embeddingByBbox.set(parentBbox, {
 				embedding: det.embedding,
 				...det.embeddingModelId !== void 0 ? { embeddingModelId: det.embeddingModelId } : {}
@@ -2186,6 +2188,7 @@ var FrameProcessor = class {
 			});
 			const emb = embeddingByBbox.get(td.bbox);
 			const faceBbox = faceBboxByBbox.get(td.bbox);
+			const nativeFaceShortSidePx = nativeFaceSizeByBbox.get(td.bbox);
 			const faceAlignedCrop = faceAlignedCropByBbox.get(td.bbox);
 			const plate = plateByBbox.get(td.bbox);
 			const sourceDetectionId = sourceIdByBbox.get(td.bbox);
@@ -2204,6 +2207,7 @@ var FrameProcessor = class {
 					...emb.embeddingModelId !== void 0 ? { embeddingModelId: emb.embeddingModelId } : {}
 				} : {},
 				...faceBbox !== void 0 ? { faceBbox } : {},
+				...nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx } : {},
 				...faceAlignedCrop !== void 0 ? { faceAlignedCrop } : {},
 				...plate !== void 0 ? {
 					plateText: plate.text,
@@ -2340,6 +2344,10 @@ function buildTrackLifecyclePayload(input) {
 		...hasMedia ? { media } : {}
 	};
 }
+//#endregion
+//#region src/pipeline-analytics/pipeline/edge-clear.ts
+/** Default border tolerance — 1% of each dimension. */
+var DEFAULT_EDGE_TOLERANCE = .01;
 /**
 * True when `bbox` sits fully inside the frame — no side within the tolerance
 * band of any border. Degenerate/unknown frame dims (≤ 0) return true so the
@@ -2385,6 +2393,104 @@ function bboxCenterScore(bbox, frameWidth, frameHeight) {
 	const dist = Math.hypot(dx, dy) / Math.SQRT2;
 	return Math.max(0, Math.min(1, 1 - dist));
 }
+/** Maximum fraction of a candidate's score a SINGLE fully-spanning clipped side
+*  can subtract (the edge-containment penalty). A clipped side that spans the
+*  whole of its border removes up to this much; a side that only grazes the
+*  border (small perpendicular span) removes proportionally less. 0.5 = a
+*  subject flush against — and filling — one border loses half its effective
+*  score, so a fully-contained near-equal detection outranks it, while a
+*  DECISIVELY higher-confidence clipped detection still wins. */
+var CONTAINMENT_MAX_SIDE_PENALTY = .5;
+/** Floor on the containment factor — a subject clipped on several borders never
+*  drops to zero (which would annihilate its score and could leave a track with
+*  NO best frame at all). */
+var CONTAINMENT_MIN = .1;
+/**
+* Edge-CONTAINMENT factor for a (clamped) bbox: an estimate in
+* `[CONTAINMENT_MIN, 1]` of the fraction of the subject that is actually in
+* frame. 1 = fully contained (no border clipping); lower = the subject is
+* flush against one or more borders and is probably truncated (half of a person
+* walking out of view).
+*
+* Because detection bboxes are already CLAMPED to the frame, the true off-screen
+* extent is unknown, so this is a purely-geometric proxy: for each border the
+* bbox touches (within the {@link DEFAULT_EDGE_TOLERANCE} band), the penalty is
+* scaled by how much of that border the bbox spans on the perpendicular axis —
+* i.e. the subject's aspect against that edge. A wide bbox flush to the
+* top/bottom (a wide subject cut off top/bottom) or a tall bbox flush to the
+* left/right (a tall subject cut off at the side) is heavily penalised, whereas
+* a narrow subject whose feet merely graze the bottom border keeps most of its
+* score. Degenerate/unknown dims (≤ 0) return 1 (neutral — matches
+* {@link isEdgeClear}).
+*/
+function bboxContainment(bbox, frameWidth, frameHeight, tolerance = DEFAULT_EDGE_TOLERANCE) {
+	if (frameWidth <= 0 || frameHeight <= 0) return 1;
+	const tolX = tolerance * frameWidth;
+	const tolY = tolerance * frameHeight;
+	const left = bbox.x;
+	const top = bbox.y;
+	const right = bbox.x + bbox.w;
+	const bottom = bbox.y + bbox.h;
+	const spanX = Math.max(0, Math.min(1, bbox.w / frameWidth));
+	const spanY = Math.max(0, Math.min(1, bbox.h / frameHeight));
+	let containment = 1;
+	const penalize = (span) => {
+		containment *= 1 - CONTAINMENT_MAX_SIDE_PENALTY * span;
+	};
+	if (left <= tolX) penalize(spanY);
+	if (right >= frameWidth - tolX) penalize(spanY);
+	if (top <= tolY) penalize(spanX);
+	if (bottom >= frameHeight - tolY) penalize(spanX);
+	return Math.max(CONTAINMENT_MIN, Math.min(1, containment));
+}
+/** Fraction of the frame area at which a subject's size score saturates to 1.
+*  10% of the frame is already a large, close subject; anything bigger gains
+*  no further preference (and the plausibility gate rejects exploded boxes). */
+var SIZE_SCORE_SATURATION_AREA_FRAC = .1;
+/** A candidate whose effective score beats the held peak by at least this
+*  RATIO is a DECISIVE improvement: it bypasses the capture rate limit
+*  (`minGapMs`) the way a tier upgrade does. Drive-through subjects hit their
+*  best framing 1–3s after birth — exactly inside the rate-limit window — and
+*  the "better shot" otherwise never gets captured (2026-07-22 audit:
+*  BEST_SHOT_STALE on 9/63 tracks with 1.5–3.8× larger in-frame views). */
+var DECISIVE_IMPROVEMENT_RATIO = 1.25;
+/**
+* Subject-size score for the best-frame ranking: sqrt of the bbox's frame-area
+* fraction, saturating at {@link SIZE_SCORE_SATURATION_AREA_FRAC}. A bigger,
+* closer subject is a better SHOT even at equal detector confidence — raw
+* confidence does not correlate with human-perceived crop quality (a distant
+* 20px person can out-score a full-frame close-up). sqrt softens the term so
+* confidence still matters between similar sizes. Degenerate dims → 1
+* (neutral), matching {@link isEdgeClear}.
+*/
+function bboxSizeScore(bbox, frameWidth, frameHeight) {
+	if (frameWidth <= 0 || frameHeight <= 0) return 1;
+	const areaFrac = bbox.w * bbox.h / (frameWidth * frameHeight);
+	return Math.sqrt(Math.max(0, Math.min(1, areaFrac / SIZE_SCORE_SATURATION_AREA_FRAC)));
+}
+/** Floor of the size factor's influence: the raw sizeScore (0..1) is mapped to
+*  `[SIZE_FACTOR_FLOOR, 1]` before scaling the confidence, so a tiny subject
+*  halves its effective score at most. Keeps the effective scale comparable to
+*  raw confidence — the ABSOLUTE hysteresis margin stays meaningful — while a
+*  bigger view still earns up to a 2× relative preference. */
+var SIZE_FACTOR_FLOOR = .5;
+/** The effective within-tier score: detector confidence scaled by the
+*  edge-containment and (floored) subject-size factors — each neutral at 1
+*  when absent. */
+function effectiveScore(c) {
+	const sizeFactor = c.sizeScore === void 0 ? 1 : SIZE_FACTOR_FLOOR + (1 - SIZE_FACTOR_FLOOR) * c.sizeScore;
+	return c.confidence * (c.containment ?? 1) * sizeFactor;
+}
+/**
+* True when `candidate` beats `current` DECISIVELY — same-or-better edge tier
+* AND an effective score at least {@link DECISIVE_IMPROVEMENT_RATIO}× the held
+* peak's. Used by `BestDetectionTracker` to bypass the capture rate limit
+* (`minGapMs`) for genuinely better framings that land inside the rate window.
+*/
+function isDecisiveImprovement(current, candidate) {
+	if (!candidate.edgeClear && current.edgeClear) return false;
+	return effectiveScore(candidate) >= effectiveScore(current) * DECISIVE_IMPROVEMENT_RATIO;
+}
 /**
 * Edge-aware "is `candidate` a new best over `current`?" comparator.
 *
@@ -2393,8 +2499,18 @@ function bboxCenterScore(bbox, frameWidth, frameHeight) {
 * confidence past the `hysteresis` margin wins. The tier upgrade
 * (touching → clear) bypasses hysteresis — the first clear frame is always taken.
 *
+* EDGE-CONTAINMENT (#edge-clip): within the same tier the comparison is on the
+* EFFECTIVE score `confidence × containment` (see {@link bboxContainment}), not
+* raw confidence — so a fully-contained detection outranks a larger/higher-
+* confidence but border-CLIPPED one unless the confidence margin is decisive.
+* The binary edge-clear tier still gates first (a whole subject beats a clipped
+* one regardless), and within the CLEAR tier both frames have containment 1, so
+* this is a no-op there; it discriminates WITHIN the touching tier (feet merely
+* grazing the bottom vs half the body out the side). `containment` defaults to
+* 1 when omitted (legacy face / object-embedding callers) → identical behaviour.
+*
 * CENTERING TIE-BREAK (#27-D): within the same tier, when neither frame clearly
-* wins on confidence (the two are within the `hysteresis` band) but the
+* wins on the effective score (the two are within the `hysteresis` band) but the
 * candidate is meaningfully better CENTRED ({@link CENTER_TIE_BREAK_MARGIN}), the
 * candidate wins. This only engages when both sides carry a `centerScore` (the
 * best-frame path), so low-importance short tracks stop keeping an edge-of-frame
@@ -2407,9 +2523,11 @@ function bboxCenterScore(bbox, frameWidth, frameHeight) {
 function isEdgeAwareNewBest(current, candidate, hysteresis) {
 	if (candidate.edgeClear && !current.edgeClear) return true;
 	if (!candidate.edgeClear && current.edgeClear) return false;
-	if (candidate.confidence > current.confidence + hysteresis) return true;
+	const curEffective = effectiveScore(current);
+	const candEffective = effectiveScore(candidate);
+	if (candEffective > curEffective + hysteresis) return true;
 	if (candidate.centerScore !== void 0 && current.centerScore !== void 0) {
-		if (Math.abs(candidate.confidence - current.confidence) <= hysteresis && candidate.centerScore > current.centerScore + .1) return true;
+		if (Math.abs(candEffective - curEffective) <= hysteresis && candidate.centerScore > current.centerScore + .1) return true;
 	}
 	return false;
 }
@@ -2451,6 +2569,14 @@ var BestDetectionTracker = class {
 	*  does not supply centering (face / object-embedding paths) → the centering
 	*  tie-break is disabled and the legacy confidence policy applies. */
 	centerScore = /* @__PURE__ */ new Map();
+	/** Held peak's edge-containment factor (0..1), PARALLEL to `best`. Absent =
+	*  the caller does not supply containment (face / object-embedding paths) →
+	*  the within-tier comparison stays on raw confidence (containment treated as
+	*  1). */
+	containment = /* @__PURE__ */ new Map();
+	/** Held peak's subject-size score (0..1), PARALLEL to `best`. Absent = the
+	*  caller does not supply size (face / object-embedding paths) → neutral. */
+	sizeScore = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.hysteresis = options.hysteresis ?? 0;
 		this.minGapMs = options.minGapMs ?? 0;
@@ -2467,7 +2593,7 @@ var BestDetectionTracker = class {
 	* the classic policy holds: a confidence past the `hysteresis` margin that also
 	* respects `minGapMs` wins. On acceptance the held peak advances.
 	*/
-	observe(trackId, confidence, timestamp, edgeClear, centerScore) {
+	observe(trackId, confidence, timestamp, edgeClear, centerScore, containment, sizeScore) {
 		const cur = this.best.get(trackId);
 		if (cur === void 0) {
 			this.best.set(trackId, {
@@ -2476,20 +2602,32 @@ var BestDetectionTracker = class {
 			});
 			if (edgeClear !== void 0) this.edgeClear.set(trackId, edgeClear);
 			if (centerScore !== void 0) this.centerScore.set(trackId, centerScore);
+			if (containment !== void 0) this.containment.set(trackId, containment);
+			if (sizeScore !== void 0) this.sizeScore.set(trackId, sizeScore);
 			return true;
 		}
 		const curClear = this.edgeClear.get(trackId) ?? true;
 		const candClear = edgeClear ?? true;
 		const curCenter = this.centerScore.get(trackId);
-		const isNewBest = candClear && !curClear ? true : isEdgeAwareNewBest({
+		const curContainment = this.containment.get(trackId);
+		const curSize = this.sizeScore.get(trackId);
+		const held = {
 			confidence: cur.confidence,
 			edgeClear: curClear,
-			...curCenter !== void 0 ? { centerScore: curCenter } : {}
-		}, {
+			...curCenter !== void 0 ? { centerScore: curCenter } : {},
+			...curContainment !== void 0 ? { containment: curContainment } : {},
+			...curSize !== void 0 ? { sizeScore: curSize } : {}
+		};
+		const cand = {
 			confidence,
 			edgeClear: candClear,
-			...centerScore !== void 0 ? { centerScore } : {}
-		}, this.hysteresis) && timestamp - cur.atMs >= this.minGapMs;
+			...centerScore !== void 0 ? { centerScore } : {},
+			...containment !== void 0 ? { containment } : {},
+			...sizeScore !== void 0 ? { sizeScore } : {}
+		};
+		const tierUpgrade = candClear && !curClear;
+		const gapOk = timestamp - cur.atMs >= this.minGapMs || sizeScore !== void 0 && isDecisiveImprovement(held, cand);
+		const isNewBest = tierUpgrade ? true : isEdgeAwareNewBest(held, cand, this.hysteresis) && gapOk;
 		if (isNewBest) {
 			this.best.set(trackId, {
 				confidence,
@@ -2497,6 +2635,8 @@ var BestDetectionTracker = class {
 			});
 			if (edgeClear !== void 0) this.edgeClear.set(trackId, edgeClear);
 			if (centerScore !== void 0) this.centerScore.set(trackId, centerScore);
+			if (containment !== void 0) this.containment.set(trackId, containment);
+			if (sizeScore !== void 0) this.sizeScore.set(trackId, sizeScore);
 		}
 		return isNewBest;
 	}
@@ -2509,14 +2649,44 @@ var BestDetectionTracker = class {
 		this.best.delete(trackId);
 		this.edgeClear.delete(trackId);
 		this.centerScore.delete(trackId);
+		this.containment.delete(trackId);
+		this.sizeScore.delete(trackId);
 	}
 	clear() {
 		this.best.clear();
 		this.edgeClear.clear();
 		this.centerScore.clear();
+		this.containment.clear();
+		this.sizeScore.clear();
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/pipeline/last-frame-promotion.ts
+/**
+* Decide whether a closing track's newest `snapshot` should be promoted to be
+* its `lastFrame`. Pure — see the module header for the contract.
+*
+* Promote when there is at least one `snapshot` AND either there is no
+* `lastFrame` yet, or the newest snapshot is strictly newer than the held
+* `lastFrame`. Otherwise keep the current behaviour (no promotion).
+*/
+function decideLastFramePromotion(media) {
+	let newestSnapshot;
+	let lastFrame;
+	for (const m of media) if (m.kind === "snapshot") {
+		if (newestSnapshot === void 0 || m.timestamp > newestSnapshot.timestamp) newestSnapshot = m;
+	} else if (m.kind === "lastFrame") {
+		if (lastFrame === void 0 || m.timestamp > lastFrame.timestamp) lastFrame = m;
+	}
+	if (newestSnapshot === void 0) return { promote: false };
+	if (lastFrame !== void 0 && newestSnapshot.timestamp <= lastFrame.timestamp) return { promote: false };
+	return {
+		promote: true,
+		snapshotKey: newestSnapshot.key,
+		snapshotTimestamp: newestSnapshot.timestamp
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/track-best-detection.ts
 /**
 * `TrackBestSelector` — the ONE unified "best detection per track" primitive.
@@ -4681,6 +4851,31 @@ var MediaStore = class {
 		return newKey;
 	}
 	/**
+	* Promote an existing `snapshot` blob to be the track's single `lastFrame`
+	* (operator "genuinely-last view" policy, see `last-frame-promotion.ts`).
+	*
+	* Both kinds share the SAME 960-boxed rendering, so promotion re-writes the
+	* snapshot's bytes into the single-instance `lastFrame` slot (`putReplacing`,
+	* which overwrites any held `lastFrame` blob + row) and then removes the
+	* promoted `snapshot` row + blob — so there is exactly ONE genuinely-last view
+	* and no duplicate snapshot/lastFrame pair. The `lastFrame` write lands BEFORE
+	* the snapshot delete, so the view is never momentarily absent. Returns the new
+	* `lastFrame` key.
+	*/
+	async promoteToLastFrame(input) {
+		const data = Buffer.from(input.snapshot.base64, "base64");
+		const newKey = await this.putReplacing({
+			deviceId: input.deviceId,
+			ownerKind: "track",
+			ownerId: input.trackId,
+			kind: "lastFrame",
+			timestamp: input.snapshot.timestamp,
+			data
+		});
+		await this.deleteByKey(input.snapshot.key);
+		return newKey;
+	}
+	/**
 	* Fetch one media entry by its key (id). Returns null if the key is not
 	* found in the index or if the blob is missing from storage.
 	*/
@@ -6558,37 +6753,121 @@ function squareSubjectCropRegion(bbox, frame) {
 	};
 }
 /**
-* The same SQUARE region as {@link squareSubjectCropRegion}, expressed in
-* NORMALIZED [0,1]×[0,1] coordinates. A normalized box maps DIRECTLY onto a
-* native-resolution surface of the SAME aspect ratio, so the region computed
-* from the detection-frame dimensions addresses the exact same ROI on the
-* runner's retained native frame. Reuses the pixel geometry verbatim (single
-* source of truth) and divides by the frame dimensions.
+* Compute the 16:9 central-square window layout for a subject bbox.
+*
+* Algorithm:
+*   1. central square `C = squareSubjectCropRegion(bbox, frame)` — the
+*      subject-containing, frame-clamped square of side `c` (its contract also
+*      handles the "subject bigger than the short edge / scale the window up"
+*      cases). `C` becomes the middle square of the output.
+*   2. canvas: `canvasW = round(c × 16/9)`, `canvasH = c`.
+*   3. anchor: place the canvas so `C` is its horizontal middle →
+*      `frameOriginX = C.x − (canvasW − c)/2` (frame-x mapping to canvas-x 0).
+*   4. in-frame slab: intersect `[frameOriginX, frameOriginX + canvasW]` with
+*      `[0, W]`; the slab is that intersection at full height `c` (C ⊆ frame ⇒
+*      the vertical extent is always in-frame). Its canvas offset is
+*      `slabOffsetX = fxa − frameOriginX ≥ 0`; anything outside is padding.
 */
-function squareSubjectCropRegionNormalized(bbox, frame) {
-	const region = squareSubjectCropRegion(bbox, frame);
+function wideCentralSquareLayout(bbox, frame) {
+	const central = squareSubjectCropRegion(bbox, frame);
+	const c = central.w;
+	const canvasW = Math.round(c * 16 / 9);
+	const centralX0 = Math.round((canvasW - c) / 2);
+	let frameOriginX = central.x - (canvasW - c) / 2;
+	if (canvasW <= frame.W) {
+		const slideRightMax = Math.max(0, bbox.x - central.x);
+		const slideLeftMax = Math.max(0, central.x + c - (bbox.x + bbox.w));
+		if (frameOriginX < 0) frameOriginX += Math.min(-frameOriginX, slideRightMax);
+		const overRight = frameOriginX + canvasW - frame.W;
+		if (overRight > 0) frameOriginX -= Math.min(overRight, slideLeftMax);
+	} else frameOriginX = (frame.W - canvasW) / 2;
+	const fxa = Math.max(0, frameOriginX);
+	const slabW = Math.min(frame.W, frameOriginX + canvasW) - fxa;
+	const slabOffsetX = fxa - frameOriginX;
 	return {
-		x: region.x / frame.W,
-		y: region.y / frame.H,
-		w: region.w / frame.W,
-		h: region.h / frame.H
+		fetch: {
+			x: fxa / frame.W,
+			y: central.y / frame.H,
+			w: slabW / frame.W,
+			h: c / frame.H
+		},
+		canvasW,
+		canvasH: c,
+		slabOffsetX,
+		slabW,
+		slabH: c,
+		centralX0,
+		centralSide: c,
+		frameOriginX
 	};
 }
+//#endregion
+//#region src/shared/frame/subject-crop-variants.ts
 /**
-* Derive the `thumbnailSmall` JPEG from an already-encoded native subject-crop
-* JPEG. Downscales to at most {@link THUMBNAIL_SMALL_MAX_WIDTH} on the long side
-* (aspect preserved). If the native crop's long side is already ≤ the cap, the
-* ORIGINAL buffer is returned unchanged (store as-is, never upscale, no wasted
-* re-encode).
+* Best-shot subject-crop variants (best-crop fast-load, 2026-07-21; 16:9
+* central-square reframe, 2026-07-22).
+*
+* ONE native fetch (the 16:9 central-square WINDOW — see
+* {@link wide-central-square-crop}) backs both persisted variants:
+*  - `thumbnail`      — the native uncapped 16:9 window JPEG (subject in the
+*                       central square, lateral scene context, never upscaled).
+*  - `thumbnailSmall` — the SAME window downscaled to {@link WIDE_THUMBNAIL_SMALL_MAX_WIDTH}
+*                       long side (854×480), the reel / lists / grid fast-load
+*                       representative.
+*
+* The small variant is DERIVED from the already-composed native window — never a
+* second native round-trip and NEVER upscaled: if the window is already ≤ 854 on
+* its long side it is stored AS-IS (byte-identical). The window is composed from
+* the in-frame slab plus lateral letterbox padding for the (rare) part of the
+* 16:9 window that falls outside the frame at a horizontal edge.
 */
-async function deriveThumbnailSmall(nativeJpeg) {
-	const meta = await sharp(nativeJpeg).metadata();
+/** Gaussian sigma for the blurred-scene letterbox fill. */
+var LETTERBOX_BLUR_SIGMA = 25;
+/** Brightness factor for the blurred fill — dimmed so the real slab reads as
+*  the subject surface and the fill as ambience, never as sharp scene. */
+var LETTERBOX_BLUR_BRIGHTNESS = .55;
+/**
+* Compose the native-resolution 16:9 central-square WINDOW (`thumbnail`) from the
+* in-frame slab fetched for `layout`. The slab is placed at its computed offset
+* on a 16:9 canvas; any lateral part of the window outside the frame (a subject
+* flush against a frame edge — the geometry already slides the window in-frame
+* wherever the subject has slack) is filled with a BLURRED, dimmed stretch of
+* the slab itself instead of dead black bars (operator triage 2026-07-22).
+* When the whole window is in-frame (`slab` already spans the full canvas) the
+* slab is returned VERBATIM (no re-encode). NEVER upscales the real image —
+* the canvas is at the slab's native scale; only the out-of-frame ambience fill
+* is synthesized.
+*
+* `slab` must be the JPEG of `layout.fetch`; its native pixel dimensions set the
+* canvas scale (native px per source px = `slabNativeHeight / layout.slabH`).
+*/
+async function composeWideCentralSquareThumbnail(slab, layout) {
+	const meta = await sharp(slab).metadata();
+	const nativeW = meta.width ?? 0;
+	const nativeH = meta.height ?? 0;
+	if (nativeW <= 0 || nativeH <= 0 || layout.slabH <= 0) return slab;
+	const scale = nativeH / layout.slabH;
+	const canvasNativeW = Math.max(Math.round(layout.canvasW * scale), nativeW);
+	const leftPad = Math.max(0, Math.round(layout.slabOffsetX * scale));
+	const rightPad = Math.max(0, canvasNativeW - nativeW - leftPad);
+	if (leftPad === 0 && rightPad === 0) return slab;
+	return sharp(await sharp(slab).resize(canvasNativeW, nativeH, { fit: "fill" }).blur(LETTERBOX_BLUR_SIGMA).modulate({ brightness: LETTERBOX_BLUR_BRIGHTNESS }).toBuffer()).composite([{
+		input: slab,
+		left: leftPad,
+		top: 0
+	}]).jpeg({ quality: 88 }).toBuffer();
+}
+/**
+* Derive the `thumbnailSmall` JPEG from the composed native 16:9 window.
+* Downscales to at most {@link WIDE_THUMBNAIL_SMALL_MAX_WIDTH} (854) on the long
+* side (aspect preserved → ~854×480). If the window's long side is already ≤ the
+* cap, the ORIGINAL buffer is returned unchanged (store as-is, never upscale).
+*/
+async function deriveThumbnailSmall(nativeWideJpeg) {
+	const meta = await sharp(nativeWideJpeg).metadata();
 	const longSide = Math.max(meta.width ?? 0, meta.height ?? 0);
-	if (longSide > 0 && longSide <= 480) return nativeJpeg;
-	return sharp(nativeJpeg).resize(480, 480, {
-		fit: "inside",
-		withoutEnlargement: true
-	}).jpeg({ quality: 88 }).toBuffer();
+	if (longSide > 0 && longSide <= 854) return nativeWideJpeg;
+	return sharp(nativeWideJpeg).resize(854, null, { withoutEnlargement: true }).jpeg({ quality: 88 }).toBuffer();
 }
 //#endregion
 //#region src/shared/frame/box-drawer.ts
@@ -6671,6 +6950,9 @@ async function drawBoxedFrame(frameData, frameWidth, frameHeight, boxes, opts =
 * upscale).
 */
 var SNAPSHOT_MAX_WIDTH = 960;
+/** Bound the once-per-owner display-fallback memo so a long-lived process never
+*  leaks it. */
+var MAX_LOGGED_DISPLAY_FALLBACKS = 5e3;
 /**
 * Map a detection-frame pixel box (`fromW`×`fromH`, the ≤640 raster the tracker
 * ran on) onto the native full frame (`toW`×`toH`, the 960-downscaled native
@@ -6750,6 +7032,9 @@ var EventMediaDispatcher = class {
 	* {@link SNAPSHOT_MAX_WIDTH} here (the only dispatcher use of the fetch).
 	*/
 	sharedNativeFullFrame;
+	/** Once-per-owner (`${eventId}:${kind}`) memo for the DISPLAY-crop fallback
+	*  info log — see {@link logDisplayFallbackOnce}. */
+	loggedDisplayFallbacks = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.deps = deps;
 		this.sharedNativeFullFrame = createSharedFrameResolver((handle) => this.deps.getNativeFullFrameRgb(handle, SNAPSHOT_MAX_WIDTH));
@@ -6816,7 +7101,7 @@ var EventMediaDispatcher = class {
 			return empty;
 		}
 		const rasterFallbacks = await this.collectRasterFallbacks(frameData, fw, fh, trackFrames, snapshots, input.cropPadding, input.rasterFallbackWantedTrackIds, input.rasterFallbackCandidates);
-		for (const ev of events) await this.writeEventMedia(deviceId, frameHandle, fw, fh, ev, input.cropPadding);
+		for (const ev of events) await this.writeEventMedia(deviceId, frameHandle, frameData, fw, fh, ev, input.cropPadding);
 		const firstFrameTrackIds = [];
 		for (const tf of trackFrames) if (await this.writeTrackFrame(deviceId, frameHandle, frameData, fw, fh, tf)) firstFrameTrackIds.push(tf.trackId);
 		const storedSnapshots = [];
@@ -6947,56 +7232,89 @@ var EventMediaDispatcher = class {
 		};
 	}
 	/**
-	* Clean subject-centered crop of `bbox` — the shared output contract of the
-	* object-event `crop` kind, the child `faceCrop`/`plateCrop`, and the track
-	* `thumbnail`: the square-safe 16:9 region around the bbox with NO box drawn.
+	* Clean subject-centered crop of `bbox` for the DISPLAY child media
+	* (`faceCrop`/`plateCrop`): the square-safe 16:9 region around the bbox with NO
+	* box drawn.
 	*
-	* NATIVE-OR-NOTHING: the region is requested from the runner's retained native
-	* surface (normalized [0,1] coords map directly onto it) with NO `maxWidth` —
-	* the crop at TRUE native resolution (decision #3). On any miss/error (or a
-	* runner without the method) it returns `null` after a loud `logger.warn`; the
-	* caller SKIPS the write and the per-frame retry lands a real native crop
-	* later. It is NEVER upscaled — an upscaled ≤640 tile is a blurred lie
-	* (case-study lapVar 5–7), so no local resize fallback exists. Runs inside the
+	* These are operator gallery images, NOT model inputs (the spec's native-source
+	* hard rule governs model inputs, which stay native-strict). So a native-ROI
+	* miss degrades gracefully — always honest, NEVER upscaled:
+	*   1. native ROI crop (the runner's retained native surface) — best quality;
+	*   2. the retained full frame (keyframe-native or the runner's ≤640 RAM tier)
+	*      cropped to the SAME region;
+	*   3. the already-resolved ≤640 detection raster (`frameData`, in hand) cropped
+	*      to the region — the last-resort honest sub-native preview.
+	* Only a total miss (all three unavailable) returns `null`. A fallback is
+	* logged ONCE per owner (`${eventId}:${kind}`) at info level. Runs inside the
 	* live-handle window opened by `captureForFrame`.
 	*/
-	async cropSubjectRegion(frameHandle, fw, fh, bbox, cropPadding) {
-		if (!this.deps.getNativeCropJpeg) {
-			this.deps.logger.warn("native subject crop miss — will retry, no upscale", { meta: {
+	async cropSubjectRegion(frameHandle, frameData, fw, fh, bbox, cropPadding, ownerId) {
+		const norm = squareSafeCropRegionNormalized(bbox, {
+			W: fw,
+			H: fh
+		}, cropPadding);
+		if (this.deps.getNativeCropJpeg) try {
+			const native = await this.deps.getNativeCropJpeg(frameHandle, norm);
+			if (native) return native;
+		} catch (err) {
+			this.deps.logger.debug("display child crop: native ROI fetch threw", { meta: {
 				shmId: frameHandle.shmId,
-				reason: "no-native-cap"
+				error: err instanceof Error ? err.message : String(err)
 			} });
-			return null;
 		}
 		try {
-			const norm = squareSafeCropRegionNormalized(bbox, {
-				W: fw,
-				H: fh
-			}, cropPadding);
-			const native = await this.deps.getNativeCropJpeg(frameHandle, norm);
-			if (native) return native;
-			this.deps.logger.warn("native subject crop miss — will retry, no upscale", { meta: {
+			const full = await this.sharedNativeFullFrame(frameHandle);
+			if (full && full.format === "rgb" && full.width > 0 && full.height > 0) {
+				const { crop } = await extractCrop(full.data, full.width, full.height, norm);
+				this.logDisplayFallbackOnce(ownerId, "native-full-frame");
+				return crop;
+			}
+		} catch (err) {
+			this.deps.logger.debug("display child crop: full-frame fallback threw", { meta: {
 				shmId: frameHandle.shmId,
-				reason: "native-miss"
+				error: err instanceof Error ? err.message : String(err)
 			} });
-			return null;
+		}
+		try {
+			const { crop } = await extractCrop(frameData, fw, fh, norm);
+			this.logDisplayFallbackOnce(ownerId, "detection-raster");
+			return crop;
 		} catch (err) {
-			this.deps.logger.warn("native subject crop miss — will retry, no upscale", { meta: {
+			this.deps.logger.warn("display child crop: all sources missed", { meta: {
 				shmId: frameHandle.shmId,
 				error: err instanceof Error ? err.message : String(err)
 			} });
 			return null;
 		}
 	}
+	/** Info-log a DISPLAY-crop fallback ONCE per owner (`${eventId}:${kind}`) so a
+	*  short native window is visible without flooding the log every frame. */
+	logDisplayFallbackOnce(ownerId, reason) {
+		if (this.loggedDisplayFallbacks.has(ownerId)) return;
+		if (this.loggedDisplayFallbacks.size >= MAX_LOGGED_DISPLAY_FALLBACKS) this.loggedDisplayFallbacks.clear();
+		this.loggedDisplayFallbacks.add(ownerId);
+		this.deps.logger.info("display child crop fallback used (honest sub-native, not upscaled)", { meta: {
+			ownerId,
+			reason
+		} });
+	}
 	/**
 	* The best-shot subject crop as its TWO persisted variants (best-crop
-	* fast-load, 2026-07-21). ONE native fetch: the SQUARE-framed subject ROI
-	* (side = max(w,h)×1.2, clamped to the frame — {@link squareSubjectCropRegionNormalized})
-	* is requested from the runner's retained native surface with NO `maxWidth`
-	* (uncapped TRUE native, decision #3) → the `thumbnail`. The `thumbnailSmall`
-	* is DERIVED by downscaling that SAME JPEG to the 480 long-side cap — never a
-	* second `getNativeCropJpeg`, never upscaled ({@link deriveThumbnailSmall}
-	* returns the native buffer as-is when it is already ≤ 480).
+	* fast-load, 2026-07-21; 16:9 central-square reframe, 2026-07-22). ONE native
+	* fetch: the in-frame slab of the 16:9 central-square WINDOW
+	* ({@link wideCentralSquareLayout} — a `side × 16/9` window whose middle square
+	* of side `max(w,h)×1.2` fully contains the subject, clamped/anchored so the
+	* subject stays in that central square at every frame edge) is requested from
+	* the runner's retained native surface with NO `maxWidth` (uncapped TRUE
+	* native). It is composed into the full 16:9 window (lateral letterbox only for
+	* the part outside the frame) → the `thumbnail`. The `thumbnailSmall` is
+	* DERIVED by downscaling that SAME window to the 854 long-side cap (854×480) —
+	* never a second `getNativeCropJpeg`, never upscaled ({@link deriveThumbnailSmall}
+	* returns the window as-is when it is already ≤ 854).
+	*
+	* Both variants share the SAME framing + central-square containment guarantee:
+	* wide consumers use the 16:9 image as-is (subject centered, no cut); square
+	* consumers center-crop the middle square (subject always inside it).
 	*
 	* NATIVE-OR-NOTHING: any miss/error (or a runner without the method) returns
 	* `null` after a loud `logger.warn`; the caller SKIPS the write and the
@@ -7012,21 +7330,22 @@ var EventMediaDispatcher = class {
 			return null;
 		}
 		try {
-			const norm = squareSubjectCropRegionNormalized(bbox, {
+			const layout = wideCentralSquareLayout(bbox, {
 				W: fw,
 				H: fh
 			});
-			const native = await this.deps.getNativeCropJpeg(frameHandle, norm);
-			if (!native) {
+			const slab = await this.deps.getNativeCropJpeg(frameHandle, layout.fetch);
+			if (!slab) {
 				this.deps.logger.warn("native subject crop miss — will retry, no upscale", { meta: {
 					shmId: frameHandle.shmId,
 					reason: "native-miss"
 				} });
 				return null;
 			}
+			const thumbnail = await composeWideCentralSquareThumbnail(slab, layout);
 			return {
-				thumbnail: native,
-				thumbnailSmall: await deriveThumbnailSmall(native)
+				thumbnail,
+				thumbnailSmall: await deriveThumbnailSmall(thumbnail)
 			};
 		} catch (err) {
 			this.deps.logger.warn("native subject crop miss — will retry, no upscale", { meta: {
@@ -7115,9 +7434,9 @@ var EventMediaDispatcher = class {
 			return false;
 		}
 	}
-	async writeEventMedia(deviceId, frameHandle, fw, fh, ev, cropPadding) {
+	async writeEventMedia(deviceId, frameHandle, frameData, fw, fh, ev, cropPadding) {
 		if (ev.childCrops) for (const child of ev.childCrops) try {
-			const childCropData = await this.cropSubjectRegion(frameHandle, fw, fh, child.bbox, cropPadding);
+			const childCropData = await this.cropSubjectRegion(frameHandle, frameData, fw, fh, child.bbox, cropPadding, `${ev.eventId}:${child.kind}`);
 			if (!childCropData) continue;
 			await this.deps.mediaStore.put({
 				deviceId,
@@ -8945,7 +9264,8 @@ function evaluatePeriodicSnapshot(input) {
 */
 function planPeriodicMedia(input) {
 	const appendSnapshot = input.dueSnapshot;
-	const rollingLastFrame = input.saveThumbnails && input.now - input.lastFrameAt >= input.intervalMs && !appendSnapshot;
+	const lastFrameInterval = input.lastFrameIntervalMs ?? input.intervalMs;
+	const rollingLastFrame = input.saveThumbnails && input.now - input.lastFrameAt >= lastFrameInterval && !appendSnapshot;
 	const thumbnailLanded = input.thumbnailLanded ?? true;
 	return {
 		appendSnapshot,
@@ -8953,7 +9273,10 @@ function planPeriodicMedia(input) {
 		bestThumbnail: input.isNewBest || !thumbnailLanded
 	};
 }
-var DEFAULT_ZERO_MEDIA_POLICY_CONFIG = { suppressMaxDurationMs: 1e3 };
+var DEFAULT_ZERO_MEDIA_POLICY_CONFIG = {
+	suppressMaxDurationMs: 1e3,
+	nothingToShowMaxDurationMs: 1500
+};
 /**
 * Classify a closing track's persistence outcome. Pure — see the module header
 * for the full contract.
@@ -8961,6 +9284,7 @@ var DEFAULT_ZERO_MEDIA_POLICY_CONFIG = { suppressMaxDurationMs: 1e3 };
 function decideZeroMediaPolicy(input, config = DEFAULT_ZERO_MEDIA_POLICY_CONFIG) {
 	if (input.hasMedia) return "persist";
 	if (input.durationMs < config.suppressMaxDurationMs && !input.confirmed) return "suppress";
+	if (!input.hasRasterFallback && input.durationMs < config.nothingToShowMaxDurationMs) return "suppress";
 	return input.hasRasterFallback ? "raster-fallback" : "persist";
 }
 //#endregion
@@ -10136,6 +10460,7 @@ var FaceRecognizer = class {
 			embedding: input.embedding,
 			embeddingModelId: modelId,
 			...input.faceBbox !== void 0 ? { faceBbox: input.faceBbox } : {},
+			...input.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: input.nativeFaceShortSidePx } : {},
 			...input.alignedCropJpeg !== void 0 ? { faceAlignedCrop: input.alignedCropJpeg } : {}
 		};
 		await this.processFrame({
@@ -10151,7 +10476,7 @@ var FaceRecognizer = class {
 	}
 	async processFrame(input) {
 		const { settings } = input;
-		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence && (t.faceBbox === void 0 || Math.min(t.faceBbox.w, t.faceBbox.h) >= settings.minFacePx));
+		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence && (t.nativeFaceShortSidePx ?? (t.faceBbox ? Math.min(t.faceBbox.w, t.faceBbox.h) : void 0) ?? Number.POSITIVE_INFINITY) >= settings.minFacePx);
 		if (candidates.length === 0) return;
 		this.deps.logger.debug("face: frame candidates", {
 			tags: { deviceId: input.deviceId },
@@ -10189,7 +10514,7 @@ var FaceRecognizer = class {
 				let crop;
 				if (c.faceAlignedCrop !== void 0) crop = Buffer.from(c.faceAlignedCrop, "base64");
 				else if (c.faceBbox !== void 0 && input.frameHandle !== void 0) try {
-					crop = await this.deps.captureCrop(input.frameHandle, c.faceBbox, input.frameWidth, input.frameHeight, input.cropPadding) ?? void 0;
+					crop = await this.deps.captureCrop(input.frameHandle, c.faceBbox, input.frameWidth, input.frameHeight, input.cropPadding, c.trackId) ?? void 0;
 				} catch (err) {
 					this.deps.logger.debug("FaceRecognizer crop capture failed", {
 						tags: { deviceId: input.deviceId },
@@ -11720,7 +12045,7 @@ var PlateRecognizer = class {
 		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;
+			crop = await this.deps.captureCrop(input.frameHandle, input.bbox, input.frameWidth, input.frameHeight, input.cropPadding, input.trackId) ?? void 0;
 		} catch (err) {
 			this.deps.logger.debug("PlateRecognizer crop capture failed", {
 				tags: { deviceId: input.deviceId },
@@ -11735,6 +12060,9 @@ var PlateRecognizer = class {
 			score: input.score,
 			bbox: input.bbox,
 			timestamp: input.timestamp,
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight,
+			cropPadding: input.cropPadding,
 			...crop !== void 0 ? { crop } : {}
 		});
 	}
@@ -11745,15 +12073,48 @@ var PlateRecognizer = class {
 		this.bestPlate.delete(trackId);
 		if (held === void 0) return;
 		const plateId = `plate-${trackId}`;
+		const keyFrameMediaKey = this.deps.getKeyFrameMediaKey?.(trackId);
+		let cropData = held.crop;
+		if (cropData === void 0 && keyFrameMediaKey !== void 0 && this.deps.deriveCropFromKeyFrame) try {
+			const derived = await this.deps.deriveCropFromKeyFrame({
+				mediaKey: keyFrameMediaKey,
+				bbox: held.bbox,
+				frameWidth: held.frameWidth,
+				frameHeight: held.frameHeight,
+				padding: held.cropPadding,
+				timestamp: held.timestamp
+			});
+			if (derived) {
+				cropData = derived.jpeg;
+				this.deps.logger.info("plate crop recovered from keyFrame (live capture missed)", {
+					tags: {
+						deviceId,
+						trackId
+					},
+					meta: {
+						plateId,
+						skewMs: derived.skewMs
+					}
+				});
+			}
+		} catch (err) {
+			this.deps.logger.debug("PlateRecognizer keyFrame crop derive failed", {
+				tags: { deviceId },
+				meta: {
+					plateId,
+					error: String(err)
+				}
+			});
+		}
 		let mediaKey;
-		if (held.crop !== void 0) try {
+		if (cropData !== void 0) try {
 			mediaKey = await this.deps.mediaStore.put({
 				deviceId,
 				ownerKind: "plate",
 				ownerId: plateId,
 				kind: "crop",
 				timestamp: held.timestamp,
-				data: held.crop
+				data: cropData
 			});
 		} catch (err) {
 			this.deps.logger.warn("PlateRecognizer plate crop put failed", {
@@ -11765,7 +12126,6 @@ var PlateRecognizer = class {
 			});
 		}
 		const match = this.matchVehicle(held.text, held.score);
-		const keyFrameMediaKey = this.deps.getKeyFrameMediaKey?.(trackId);
 		try {
 			await this.deps.plateStore.insert({
 				id: plateId,
@@ -12021,6 +12381,86 @@ function createCaptureCrop(deps) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/display-crop.ts
+/** Bound the once-per-owner memo so a long-lived process never leaks it. */
+var MAX_LOGGED_OWNERS = 5e3;
+function createDisplayCrop(deps) {
+	const loggedOwners = /* @__PURE__ */ new Set();
+	const logFallbackOnce = (ownerId, reason) => {
+		if (loggedOwners.has(ownerId)) return;
+		if (loggedOwners.size >= MAX_LOGGED_OWNERS) loggedOwners.clear();
+		loggedOwners.add(ownerId);
+		deps.logger.info("display crop fallback used (honest sub-native, not upscaled)", { meta: {
+			ownerId,
+			reason
+		} });
+	};
+	return async (frameHandle, bbox, frameWidth, frameHeight, padding, ownerId, maxWidth) => {
+		const norm = padBbox({
+			x: bbox.x / frameWidth,
+			y: bbox.y / frameHeight,
+			w: bbox.w / frameWidth,
+			h: bbox.h / frameHeight
+		}, padding);
+		const native = await deps.fetchNativeRoiRgb(frameHandle, norm, maxWidth);
+		if (native) {
+			const jpeg = await deps.encodeRgb(native.bytes, native.width, native.height);
+			if (jpeg) return jpeg;
+		}
+		const fb = await deps.fetchFallbackFrame(frameHandle);
+		if (fb) try {
+			const jpeg = await deps.cropRegionToJpeg(fb.frame.bytes, fb.frame.width, fb.frame.height, norm);
+			logFallbackOnce(ownerId, fb.reason);
+			return jpeg;
+		} catch (err) {
+			deps.logger.debug("display crop fallback crop failed", { meta: {
+				ownerId,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+		logFallbackOnce(ownerId, "unavailable");
+		return null;
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/pipeline/keyframe-crop.ts
+function createKeyFrameCrop(deps) {
+	return async (input) => {
+		if (input.frameWidth <= 0 || input.frameHeight <= 0) return null;
+		const media = await deps.getMedia(input.mediaKey);
+		if (!media) return null;
+		const skewMs = Math.abs(media.timestamp - input.timestamp);
+		if (skewMs > deps.maxSkewMs) {
+			deps.logger.debug("keyframe crop rejected — temporal skew too large", { meta: {
+				mediaKey: input.mediaKey,
+				skewMs,
+				maxSkewMs: deps.maxSkewMs
+			} });
+			return null;
+		}
+		try {
+			const rgb = await deps.decodeJpegToRgb(media.base64);
+			if (rgb.width <= 0 || rgb.height <= 0) return null;
+			const norm = padBbox({
+				x: input.bbox.x / input.frameWidth,
+				y: input.bbox.y / input.frameHeight,
+				w: input.bbox.w / input.frameWidth,
+				h: input.bbox.h / input.frameHeight
+			}, input.padding);
+			return {
+				jpeg: await deps.cropRegionToJpeg(Buffer.from(rgb.bytes), rgb.width, rgb.height, norm),
+				skewMs
+			};
+		} catch (err) {
+			deps.logger.debug("keyframe crop derive failed", { meta: {
+				mediaKey: input.mediaKey,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return null;
+		}
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/dropout-skip.ts
 function shouldSkipDropoutFrame(activeTrackCount, detectionCount, consecutiveSkips, cfg) {
 	if (!cfg.enabled) return false;
@@ -12267,6 +12707,16 @@ var TTL_SWEEP_INTERVAL_MS = 5e3;
 /** Padding applied to the parent bbox for the `cropJpeg` retry fallback when a
 *  scheduled detail call's frameHandle lease is already gone. */
 var DETAIL_FALLBACK_CROP_PADDING = .15;
+/** Long-side cap for the DISPLAY-crop full-frame fallback (plate/face gallery
+*  tiles) when the native ROI missed. A generous native cap so a keyframe-native
+*  tier still yields a legible plate/face crop; the runner's ≤640 RAM tier is
+*  returned as-is (honest sub-native). Never triggers an upscale. */
+var DISPLAY_FALLBACK_MAX_WIDTH = 1920;
+/** Max |keyFrame − plate-read| skew (ms) accepted for the DURABLE keyFrame-
+*  derived plate-crop last resort. A readable plate implies a slow/stopping
+*  vehicle, so within this window the subject barely moves off its bbox;
+*  beyond it the crop would show empty scene, so it is rejected (no image). */
+var KEYFRAME_CROP_MAX_SKEW_MS = 1500;
 /** How long the active CLIP model id (from the embedding-encoder) is cached
 *  before re-reading. */
 var CLIP_MODEL_ID_CACHE_TTL_MS = 6e4;
@@ -12288,6 +12738,13 @@ 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). */
+/** Rolling `lastFrame` cadence — deliberately DENSER than the 5s snapshot
+*  interval: most real tracks live 3–9s, so on the snapshot cadence they
+*  closed with NO `lastFrame` at all (29/68 in the 2026-07-22 4h audit) and
+*  the close-time promotion had nothing to absorb. 1.5s bounds the "Ultimo"
+*  tile's staleness at ~1.5s + the coast window, at one 960-boxed re-encode
+*  per 1.5s per active track (putReplacing keeps a single row). */
+var LAST_FRAME_INTERVAL_MS = 1500;
 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;
@@ -12542,6 +12999,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	packageDropDetector = null;
 	/** Consecutive detector-dropout frames skipped per (deviceId, source) key. */
 	dropoutSkipsByKey = /* @__PURE__ */ new Map();
+	/** Reentrancy latch for `sweepExpiredTracks` — one sweep at a time (a stalled
+	*  sweep + queued interval ticks used to process the same close ~20×). */
+	sweepInFlight = false;
 	/** Best (highest-confidence) frame per track — drives the single overwrite
 	*  `thumbnail` (§5 best-frame). Shares the ONE best-detection policy with the
 	*  face path (`face-recognizer.ts`); rate-limited here since each best-frame
@@ -12964,13 +13424,31 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			logger: logger.child("CaptureCrop")
 		});
 		this.captureCrop = captureCrop;
+		const captureDisplayCrop = createDisplayCrop({
+			fetchNativeRoiRgb: (handle, norm, maxWidth) => fetchNativeCropRgb(handle, norm, maxWidth),
+			fetchFallbackFrame: async (handle) => {
+				const tiered = await fetchNativeFullFrameTiered(handle, DISPLAY_FALLBACK_MAX_WIDTH);
+				if (!tiered || tiered.frame.format !== "rgb") return null;
+				return {
+					frame: {
+						bytes: Buffer.from(tiered.frame.data),
+						width: tiered.frame.width,
+						height: tiered.frame.height
+					},
+					reason: tiered.tier === "ram-fullframe" ? "detection-raster" : "keyframe-native"
+				};
+			},
+			encodeRgb: (bytes, w, h) => encodeRgbCropToJpeg(bytes, w, h),
+			cropRegionToJpeg: async (bytes, w, h, norm) => (await extractCrop(bytes, w, h, norm)).crop,
+			logger: logger.child("DisplayCrop")
+		});
 		this.faceRecognizer = new FaceRecognizer({
 			identityStore: this.identityStore,
 			faceStore: this.faceStore,
 			mediaStore: this.mediaStore,
 			trackStore: this.trackStore,
 			eventStore: this.eventStore,
-			captureCrop,
+			captureCrop: captureDisplayCrop,
 			recomputeImportance: (trackId) => {
 				const trackStore = this.trackStore;
 				const eventStore = this.eventStore;
@@ -12985,11 +13463,26 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			logger: logger.child("FaceRecognizer")
 		});
 		this.faceRecognizer.refreshGallery();
+		const plateMediaStore = this.mediaStore;
+		const deriveCropFromKeyFrame = createKeyFrameCrop({
+			getMedia: async (mediaKey) => {
+				const m = await plateMediaStore.getByKey(mediaKey);
+				return m ? {
+					base64: m.base64,
+					timestamp: m.timestamp
+				} : null;
+			},
+			decodeJpegToRgb: (base64) => decodeJpegToRgb(base64),
+			cropRegionToJpeg: async (bytes, w, h, norm) => (await extractCrop(bytes, w, h, norm)).crop,
+			maxSkewMs: KEYFRAME_CROP_MAX_SKEW_MS,
+			logger: logger.child("KeyFrameCrop")
+		});
 		this.plateRecognizer = new PlateRecognizer({
 			plateStore: this.plateStore,
 			vehicleStore: this.vehicleStore,
 			mediaStore: this.mediaStore,
-			captureCrop,
+			captureCrop: captureDisplayCrop,
+			deriveCropFromKeyFrame,
 			getKeyFrameMediaKey: (trackId) => this.keyFrameKeyByTrackId.get(trackId),
 			emitPlateGalleryChanged: (payload) => this.emitPlateGalleryChanged(payload),
 			logger: logger.child("PlateRecognizer")
@@ -13639,6 +14132,7 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 					source,
 					resurrected: true
 				} });
+				if (this.eventMediaDispatcher) this.lastFrameAtByTrack.set(id, result.timestamp);
 				continue;
 			}
 			bornCandidates.push({
@@ -13825,7 +14319,23 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 			for (const retry of this.collectFirstFrameRetries(result.tracked, result.timestamp, firstFrameTargets)) firstFrameTargets.push(retry);
 			const keyFrameTrackIds = selectKeyFrameTrackIds(snapshotTargets);
 			if (keyFrameTrackIds.length > 0) this.persistKeyFrames(deviceId, result.timestamp, keyFrameTrackIds, frameHandle);
-			if (eventTargets.length > 0 || firstFrameTargets.length > 0 || snapshotTargets.length > 0) {
+			const targetedThisFrame = new Set([...firstFrameTargets.map((t) => t.trackId), ...snapshotTargets.map((s) => s.trackId)]);
+			const rasterFallbackCandidates = [];
+			const widenedRasterWantedIds = /* @__PURE__ */ new Set();
+			for (const t of result.tracked) {
+				if (t.matchedThisFrame === false) continue;
+				const closure = this.trackClosureState.get(t.trackId);
+				if (!closure?.confirmed) continue;
+				if (closure.rasterFallback) continue;
+				if (targetedThisFrame.has(t.trackId)) continue;
+				widenedRasterWantedIds.add(t.trackId);
+				rasterFallbackCandidates.push({
+					trackId: t.trackId,
+					timestamp: result.timestamp,
+					bbox: { ...t.bbox }
+				});
+			}
+			if (eventTargets.length > 0 || firstFrameTargets.length > 0 || snapshotTargets.length > 0 || widenedRasterWantedIds.size > 0) {
 				const captureCounts = {
 					events: eventTargets.length,
 					trackFrames: firstFrameTargets.length,
@@ -13851,24 +14361,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				const lastFrameInFlightTrackIds = snapshotTargets.filter((t) => t.rollingLastFrame).map((t) => t.trackId);
 				for (const trackId of lastFrameInFlightTrackIds) this.lastFrameInFlight.add(trackId);
 				const dispatchTimestamp = result.timestamp;
-				const rasterFallbackWantedTrackIds = /* @__PURE__ */ new Set();
+				const rasterFallbackWantedTrackIds = new Set(widenedRasterWantedIds);
 				for (const t of firstFrameTargets) if (!this.trackClosureState.get(t.trackId)?.rasterFallback) rasterFallbackWantedTrackIds.add(t.trackId);
 				for (const s of snapshotTargets) if (!this.trackClosureState.get(s.trackId)?.rasterFallback) rasterFallbackWantedTrackIds.add(s.trackId);
-				const targetedThisFrame = new Set([...firstFrameTargets.map((t) => t.trackId), ...snapshotTargets.map((s) => s.trackId)]);
-				const rasterFallbackCandidates = [];
-				for (const t of result.tracked) {
-					if (t.matchedThisFrame === false) continue;
-					const closure = this.trackClosureState.get(t.trackId);
-					if (!closure?.confirmed) continue;
-					if (closure.rasterFallback) continue;
-					if (targetedThisFrame.has(t.trackId)) continue;
-					rasterFallbackWantedTrackIds.add(t.trackId);
-					rasterFallbackCandidates.push({
-						trackId: t.trackId,
-						timestamp: result.timestamp,
-						bbox: { ...t.bbox }
-					});
-				}
 				this.eventMediaDispatcher.captureForFrame({
 					deviceId,
 					frameHandle,
@@ -14310,7 +14805,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		if (!this.faceRecognizer || detail.embedding === void 0) return;
 		if (!await this.resolveGlobalFaceEnabled()) return;
 		const [settings, media] = await Promise.all([this.resolveDeviceFaceSettings(deviceId), this.resolveDeviceMediaSettings(deviceId)]);
-		if (detail.bbox !== void 0 && Math.min(detail.bbox.w, detail.bbox.h) < settings.minFacePx) return;
+		const faceShortSidePx = detail.nativeFaceShortSidePx ?? (detail.bbox !== void 0 ? Math.min(detail.bbox.w, detail.bbox.h) : void 0);
+		if (faceShortSidePx !== void 0 && faceShortSidePx < settings.minFacePx) return;
 		await this.faceRecognizer.ingestFaceDetail({
 			deviceId,
 			trackId,
@@ -14656,7 +15152,9 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				frameHeight
 			});
 			const centerScore = bboxCenterScore(t.bbox, frameWidth, frameHeight);
-			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp, edgeClear, centerScore);
+			const containment = bboxContainment(t.bbox, frameWidth, frameHeight);
+			const sizeScore = bboxSizeScore(t.bbox, frameWidth, frameHeight);
+			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp, edgeClear, centerScore, containment, sizeScore);
 			this.maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest);
 			const plan = planPeriodicMedia({
 				saveThumbnails: media.saveThumbnails,
@@ -14665,7 +15163,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 				thumbnailLanded: this.thumbnailLandedTracks.has(t.trackId),
 				lastFrameAt: this.lastFrameAtByTrack.get(t.trackId) ?? 0,
 				now: timestamp,
-				intervalMs: media.snapshotIntervalMs
+				intervalMs: media.snapshotIntervalMs,
+				lastFrameIntervalMs: Math.min(LAST_FRAME_INTERVAL_MS, media.snapshotIntervalMs)
 			});
 			const rollingLastFrame = plan.rollingLastFrame && !this.lastFrameInFlight.has(t.trackId);
 			if (plan.appendSnapshot) this.trackStore.markSnapshotPending(t.trackId, timestamp, t.bbox);
@@ -14926,14 +15425,17 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 	}
 	async sweepExpiredTracks() {
 		if (this.shuttingDown || !this.trackStore) return;
+		if (this.sweepInFlight) return;
+		this.sweepInFlight = true;
 		try {
 			const expired = await this.trackStore.expireStale(Date.now());
 			for (const t of expired) {
 				const duration = t.lastSeen - t.firstSeen;
 				const closure = this.trackClosureState.get(t.trackId);
+				const ownedMedia = await this.mediaStore?.listByOwner("track", t.trackId) ?? [];
 				const outcome = decideZeroMediaPolicy({
 					durationMs: duration,
-					hasMedia: (await this.mediaStore?.listByOwner("track", t.trackId) ?? []).length > 0,
+					hasMedia: ownedMedia.length > 0,
 					confirmed: closure?.confirmed ?? false,
 					hasRasterFallback: closure?.rasterFallback !== void 0
 				});
@@ -14968,6 +15470,25 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 						}
 					});
 				}
+				const promotion = decideLastFramePromotion(ownedMedia);
+				if (promotion.promote) {
+					const snapshot = ownedMedia.find((m) => m.key === promotion.snapshotKey);
+					if (snapshot) try {
+						await this.mediaStore?.promoteToLastFrame({
+							deviceId: t.deviceId,
+							trackId: t.trackId,
+							snapshot
+						});
+					} catch (err) {
+						this.ctx.logger.debug("lastFrame promotion failed", {
+							tags: { deviceId: t.deviceId },
+							meta: {
+								trackId: t.trackId,
+								error: String(err)
+							}
+						});
+					}
+				}
 				this.ctx.logger.info("track ended", {
 					tags: { deviceId: t.deviceId },
 					meta: {
@@ -15086,6 +15607,8 @@ var PipelineAnalyticsAddon = class extends BaseAddon {
 		} catch (err) {
 			if (this.shuttingDown) return;
 			this.ctx.logger.debug("sweepExpiredTracks failed", { meta: { error: String(err) } });
+		} finally {
+			this.sweepInFlight = false;
 		}
 	}
 	/**