@camstack/addon-post-analysis 1.2.235 → 1.2.237

package/dist/pipeline-analytics/index.js

@@ -31853,7 +31853,8 @@ function analyseDebugTrack(inventory) {
 		}
 	}
 	if (closed && facts.bestEventId === void 0) out.push(finding("NO_BEST_EVENT", "info", "No representative event was chosen for this track."));
-	if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
+	if (facts.labelStepId === "detector:raw-class") out.push(finding("UNSCORED_LABEL", "info", `The label is the detector's raw class (${facts.label ?? facts.className}) — no scored classifier answered for this track.`));
+	else if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
 	if (thumbnailProvenance === "standin") out.push(finding("BEST_SHOT_STANDIN", "warn", "Best shot is a stand-in: a face/plate detail crop copied in because no frame of the subject was captured."));
 	if (thumbnailProvenance === "raster") out.push(finding("BEST_SHOT_RASTER", "info", "Best shot is a sub-native raster crop of the subject, not a native capture."));
 	return out;
@@ -31911,6 +31912,7 @@ function toFacts(track) {
 		className: track.className,
 		...track.label === void 0 ? {} : { label: track.label },
 		...track.labelScore === void 0 ? {} : { labelScore: track.labelScore },
+		...track.labelMeta?.stepId === void 0 ? {} : { labelStepId: track.labelMeta.stepId },
 		firstSeen: track.firstSeen,
 		lastSeen: track.lastSeen,
 		active: track.active,
@@ -47581,31 +47583,54 @@ var EventMediaService = class {
 //#endregion
 //#region src/shared/frame/crop-extractor.ts
 /**
-* Extracts a JPEG-encoded crop from a raw frame buffer using a normalized bounding box.
-* Coordinates are clamped to frame bounds to avoid out-of-range errors.
+* The ONE reading of a normalized box against a frame: round, then clamp so
+* the rectangle is inside the frame and never empty. Both extractors below
+* share it, so the JPEG half and the raw half can never disagree about WHICH
+* pixels the crop is — only about how they are encoded.
+*/
+function clampNormalizedBox(frameWidth, frameHeight, bbox) {
+	const left = Math.max(0, Math.min(Math.round(bbox.x * frameWidth), frameWidth - 1));
+	const top = Math.max(0, Math.min(Math.round(bbox.y * frameHeight), frameHeight - 1));
+	return {
+		left,
+		top,
+		width: Math.max(1, Math.min(Math.round(bbox.w * frameWidth), frameWidth - left)),
+		height: Math.max(1, Math.min(Math.round(bbox.h * frameHeight), frameHeight - top))
+	};
+}
+/**
+* Extracts a **JPEG-encoded** crop from a raw frame buffer using a normalized
+* bounding box. The name does not say JPEG; the return type is what you must
+* read. A caller whose surrounding frame is raw wants {@link extractCropRaw} —
+* handing this output on as raw pixels is what produced 717 `VipsImage: memory
+* area too small` failures and cost the fleet a day of group shots.
 */
 async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
-	const rawLeft = Math.round(bbox.x * frameWidth);
-	const rawTop = Math.round(bbox.y * frameHeight);
-	const rawWidth = Math.round(bbox.w * frameWidth);
-	const rawHeight = Math.round(bbox.h * frameHeight);
-	const left = Math.max(0, Math.min(rawLeft, frameWidth - 1));
-	const top = Math.max(0, Math.min(rawTop, frameHeight - 1));
-	const width = Math.max(1, Math.min(rawWidth, frameWidth - left));
-	const height = Math.max(1, Math.min(rawHeight, frameHeight - top));
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
 	return {
 		crop: await (0, sharp.default)(frameData, { raw: {
 			width: frameWidth,
 			height: frameHeight,
 			channels: 3
-		} }).extract({
-			left,
-			top,
-			width,
-			height
-		}).jpeg({ quality: 90 }).toBuffer(),
-		width,
-		height
+		} }).extract(rect).jpeg({ quality: 90 }).toBuffer(),
+		width: rect.width,
+		height: rect.height
+	};
+}
+/**
+* The same cut, raw in and **raw RGB out** — for a caller that carries a
+* `DecodedFrame` and must keep `format: 'rgb'` true of the bytes it holds.
+*/
+async function extractCropRaw(frameData, frameWidth, frameHeight, bbox) {
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
+	return {
+		data: await (0, sharp.default)(frameData, { raw: {
+			width: frameWidth,
+			height: frameHeight,
+			channels: 3
+		} }).extract(rect).raw().toBuffer(),
+		width: rect.width,
+		height: rect.height
 	};
 }
 //#endregion
@@ -72430,6 +72455,92 @@ var RawGlobalStoreMirror = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/summary/group-crop.ts
+/** Padding around the union, as a fraction of its own size. */
+var GROUP_CROP_PADDING = .12;
+/**
+* Smallest crop, per axis, as a fraction of the frame.
+*
+* A quarter. Below that a thumbnail stops being legible at the sizes the
+* gallery draws it, and the extra context costs nothing — the subjects stay the
+* dominant thing in the picture at this size.
+*/
+var MIN_CROP_FRACTION = .25;
+/**
+* The crop, or `null` when there is nothing to cut to — no visible member, or
+* a frame with no dimensions. `null` means the caller keeps the full frame,
+* which is the only honest answer when nobody could say where the group was.
+*/
+function groupCropRect(input) {
+	const { frameWidth: fw, frameHeight: fh } = input;
+	if (fw <= 0 || fh <= 0) return null;
+	const boxes = input.boxes.filter((b) => b.width > 0 && b.height > 0);
+	if (boxes.length === 0) return null;
+	let left = Number.POSITIVE_INFINITY;
+	let top = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	let bottom = Number.NEGATIVE_INFINITY;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.width);
+		bottom = Math.max(bottom, b.y + b.height);
+	}
+	const padX = (right - left) * GROUP_CROP_PADDING;
+	const padY = (bottom - top) * GROUP_CROP_PADDING;
+	let x0 = left - padX;
+	let y0 = top - padY;
+	let x1 = right + padX;
+	let y1 = bottom + padY;
+	const minW = fw * MIN_CROP_FRACTION;
+	const minH = fh * MIN_CROP_FRACTION;
+	if (x1 - x0 < minW) {
+		const cx = (x0 + x1) / 2;
+		x0 = cx - minW / 2;
+		x1 = cx + minW / 2;
+	}
+	if (y1 - y0 < minH) {
+		const cy = (y0 + y1) / 2;
+		y0 = cy - minH / 2;
+		y1 = cy + minH / 2;
+	}
+	const width = Math.min(x1 - x0, fw);
+	const height = Math.min(y1 - y0, fh);
+	const x = Math.max(0, Math.min(x0, fw - width));
+	const y = Math.max(0, Math.min(y0, fh - height));
+	return {
+		x: Math.round(x),
+		y: Math.round(y),
+		width: Math.round(width),
+		height: Math.round(height)
+	};
+}
+/**
+* Carry a crop computed on the DETECTION frame onto the NATIVE surface.
+*
+* The two are different sizes by construction: detection runs on a downscaled
+* frame and the group shot is fetched at up to 4096 px. Applying the rectangle
+* raw would cut a corner of the picture and call it the group — the failure
+* mode is silent and looks like a framing bug.
+*
+* Scaled per axis rather than by one factor, because the two surfaces are not
+* guaranteed to share an aspect, and clamped to the native frame so rounding
+* can never ask for a pixel that is not there.
+*/
+function scaleCropToFrame(crop, from, to) {
+	if (from.width <= 0 || from.height <= 0 || to.width <= 0 || to.height <= 0) return null;
+	const sx = to.width / from.width;
+	const sy = to.height / from.height;
+	const x = Math.max(0, Math.min(Math.round(crop.x * sx), to.width - 1));
+	const y = Math.max(0, Math.min(Math.round(crop.y * sy), to.height - 1));
+	return {
+		x,
+		y,
+		width: Math.max(1, Math.min(Math.round(crop.width * sx), to.width - x)),
+		height: Math.max(1, Math.min(Math.round(crop.height * sy), to.height - y))
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/summary/summary-score.ts
 /** A member whose own box is covered this much by others is hidden. */
 var OCCLUDED_COVER_FRACTION = .5;
@@ -72478,12 +72589,24 @@ function scoreSummaryFrame(input) {
 	const visible = present.filter((d) => coveredFraction(d.bbox, present.filter((o) => o !== d).map((o) => o.bbox)) < OCCLUDED_COVER_FRACTION);
 	if (visible.length === 0) return {
 		visible: 0,
-		quality: 0
+		quality: 0,
+		crop: null
 	};
 	const quality = visible.reduce((sum, d) => sum + memberQuality(d, input.frameWidth, input.frameHeight), 0) / visible.length;
+	const crop = groupCropRect({
+		boxes: visible.map((d) => ({
+			x: d.bbox.x,
+			y: d.bbox.y,
+			width: d.bbox.width,
+			height: d.bbox.height
+		})),
+		frameWidth: input.frameWidth,
+		frameHeight: input.frameHeight
+	});
 	return {
 		visible: visible.length,
-		quality
+		quality,
+		crop
 	};
 }
 /**
@@ -72603,6 +72726,54 @@ var GroupShotTracker = class {
 };
 //#endregion
 //#region src/pipeline-analytics/summary/group-shot-materialiser.ts
+/**
+* Apply the group crop to the native surface, or hand it back untouched.
+*
+* Every reason to skip is a reason NOT to guess: no rectangle, no detection
+* geometry to scale from, or a cropper this deployment does not have. The full
+* frame is worse than a crop and far better than a wrong crop.
+*/
+async function cropNative(native, input, deps) {
+	const crop = input.crop;
+	if (!crop || !deps.cropFrame) return native;
+	const fw = input.cropFrameWidth;
+	const fh = input.cropFrameHeight;
+	if (fw === void 0 || fh === void 0) return native;
+	const scaled = scaleCropToFrame(crop, {
+		width: fw,
+		height: fh
+	}, native);
+	if (scaled === null) return native;
+	if (scaled.width >= native.width && scaled.height >= native.height) return native;
+	try {
+		const cut = await deps.cropFrame(native, scaled);
+		if (cut === null) return native;
+		const expected = cut.width * cut.height * 3;
+		if (cut.format === "rgb" && cut.data.length !== expected) {
+			deps.logger.warn("group shot crop returned a surface that is not its geometry", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					summaryId: input.summaryId,
+					width: cut.width,
+					height: cut.height,
+					expectedBytes: expected,
+					gotBytes: cut.data.length
+				}
+			});
+			return native;
+		}
+		return cut;
+	} catch (err) {
+		deps.logger.warn("group shot crop failed — storing the full frame", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				summaryId: input.summaryId,
+				error: require_dist.errMsg(err)
+			}
+		});
+		return native;
+	}
+}
 async function persistSummaryGroupShot(deps, input) {
 	const { deviceId, summaryId, frameHandle } = input;
 	const drop = {
@@ -72636,7 +72807,8 @@ async function persistSummaryGroupShot(deps, input) {
 			});
 			return { kind: "ram-tier" };
 		}
-		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(native);
+		const surface = await cropNative(native, input, deps);
+		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(surface);
 		const keyFrameMediaId = await deps.media.putReplacing({
 			deviceId,
 			ownerKind: "summary",
@@ -79856,13 +80028,30 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				fetchNativeFullFrame: getNative,
 				encodeVariants: encodeKeyFrameVariants,
 				media: mediaStore,
-				logger: this.ctx.logger
+				logger: this.ctx.logger,
+				cropFrame: async (frame, rect) => {
+					const out = await extractCropRaw(frame.data, frame.width, frame.height, {
+						x: rect.x / frame.width,
+						y: rect.y / frame.height,
+						w: rect.width / frame.width,
+						h: rect.height / frame.height
+					});
+					return {
+						...frame,
+						data: out.data,
+						width: out.width,
+						height: out.height
+					};
+				}
 			}, {
 				deviceId,
 				summaryId,
 				timestamp: result.timestamp,
 				frameHandle,
-				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
+				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH,
+				crop: score.crop,
+				cropFrameWidth: result.frameWidth,
+				cropFrameHeight: result.frameHeight
 			})
 		}).then((outcome) => {
 			if (outcome?.kind === "landed") {

package/dist/pipeline-analytics/index.mjs

@@ -31830,7 +31830,8 @@ function analyseDebugTrack(inventory) {
 		}
 	}
 	if (closed && facts.bestEventId === void 0) out.push(finding("NO_BEST_EVENT", "info", "No representative event was chosen for this track."));
-	if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
+	if (facts.labelStepId === "detector:raw-class") out.push(finding("UNSCORED_LABEL", "info", `The label is the detector's raw class (${facts.label ?? facts.className}) — no scored classifier answered for this track.`));
+	else if (facts.labelScore !== void 0 && facts.labelScore < .5) out.push(finding("LOW_BEST_SCORE", "info", `Best label score ${facts.labelScore.toFixed(2)} is under ${String(LOW_BEST_SCORE)}.`));
 	if (thumbnailProvenance === "standin") out.push(finding("BEST_SHOT_STANDIN", "warn", "Best shot is a stand-in: a face/plate detail crop copied in because no frame of the subject was captured."));
 	if (thumbnailProvenance === "raster") out.push(finding("BEST_SHOT_RASTER", "info", "Best shot is a sub-native raster crop of the subject, not a native capture."));
 	return out;
@@ -31888,6 +31889,7 @@ function toFacts(track) {
 		className: track.className,
 		...track.label === void 0 ? {} : { label: track.label },
 		...track.labelScore === void 0 ? {} : { labelScore: track.labelScore },
+		...track.labelMeta?.stepId === void 0 ? {} : { labelStepId: track.labelMeta.stepId },
 		firstSeen: track.firstSeen,
 		lastSeen: track.lastSeen,
 		active: track.active,
@@ -47507,31 +47509,54 @@ var EventMediaService = class {
 //#endregion
 //#region src/shared/frame/crop-extractor.ts
 /**
-* Extracts a JPEG-encoded crop from a raw frame buffer using a normalized bounding box.
-* Coordinates are clamped to frame bounds to avoid out-of-range errors.
+* The ONE reading of a normalized box against a frame: round, then clamp so
+* the rectangle is inside the frame and never empty. Both extractors below
+* share it, so the JPEG half and the raw half can never disagree about WHICH
+* pixels the crop is — only about how they are encoded.
+*/
+function clampNormalizedBox(frameWidth, frameHeight, bbox) {
+	const left = Math.max(0, Math.min(Math.round(bbox.x * frameWidth), frameWidth - 1));
+	const top = Math.max(0, Math.min(Math.round(bbox.y * frameHeight), frameHeight - 1));
+	return {
+		left,
+		top,
+		width: Math.max(1, Math.min(Math.round(bbox.w * frameWidth), frameWidth - left)),
+		height: Math.max(1, Math.min(Math.round(bbox.h * frameHeight), frameHeight - top))
+	};
+}
+/**
+* Extracts a **JPEG-encoded** crop from a raw frame buffer using a normalized
+* bounding box. The name does not say JPEG; the return type is what you must
+* read. A caller whose surrounding frame is raw wants {@link extractCropRaw} —
+* handing this output on as raw pixels is what produced 717 `VipsImage: memory
+* area too small` failures and cost the fleet a day of group shots.
 */
 async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
-	const rawLeft = Math.round(bbox.x * frameWidth);
-	const rawTop = Math.round(bbox.y * frameHeight);
-	const rawWidth = Math.round(bbox.w * frameWidth);
-	const rawHeight = Math.round(bbox.h * frameHeight);
-	const left = Math.max(0, Math.min(rawLeft, frameWidth - 1));
-	const top = Math.max(0, Math.min(rawTop, frameHeight - 1));
-	const width = Math.max(1, Math.min(rawWidth, frameWidth - left));
-	const height = Math.max(1, Math.min(rawHeight, frameHeight - top));
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
 	return {
 		crop: await sharp(frameData, { raw: {
 			width: frameWidth,
 			height: frameHeight,
 			channels: 3
-		} }).extract({
-			left,
-			top,
-			width,
-			height
-		}).jpeg({ quality: 90 }).toBuffer(),
-		width,
-		height
+		} }).extract(rect).jpeg({ quality: 90 }).toBuffer(),
+		width: rect.width,
+		height: rect.height
+	};
+}
+/**
+* The same cut, raw in and **raw RGB out** — for a caller that carries a
+* `DecodedFrame` and must keep `format: 'rgb'` true of the bytes it holds.
+*/
+async function extractCropRaw(frameData, frameWidth, frameHeight, bbox) {
+	const rect = clampNormalizedBox(frameWidth, frameHeight, bbox);
+	return {
+		data: await sharp(frameData, { raw: {
+			width: frameWidth,
+			height: frameHeight,
+			channels: 3
+		} }).extract(rect).raw().toBuffer(),
+		width: rect.width,
+		height: rect.height
 	};
 }
 //#endregion
@@ -72356,6 +72381,92 @@ var RawGlobalStoreMirror = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/summary/group-crop.ts
+/** Padding around the union, as a fraction of its own size. */
+var GROUP_CROP_PADDING = .12;
+/**
+* Smallest crop, per axis, as a fraction of the frame.
+*
+* A quarter. Below that a thumbnail stops being legible at the sizes the
+* gallery draws it, and the extra context costs nothing — the subjects stay the
+* dominant thing in the picture at this size.
+*/
+var MIN_CROP_FRACTION = .25;
+/**
+* The crop, or `null` when there is nothing to cut to — no visible member, or
+* a frame with no dimensions. `null` means the caller keeps the full frame,
+* which is the only honest answer when nobody could say where the group was.
+*/
+function groupCropRect(input) {
+	const { frameWidth: fw, frameHeight: fh } = input;
+	if (fw <= 0 || fh <= 0) return null;
+	const boxes = input.boxes.filter((b) => b.width > 0 && b.height > 0);
+	if (boxes.length === 0) return null;
+	let left = Number.POSITIVE_INFINITY;
+	let top = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	let bottom = Number.NEGATIVE_INFINITY;
+	for (const b of boxes) {
+		left = Math.min(left, b.x);
+		top = Math.min(top, b.y);
+		right = Math.max(right, b.x + b.width);
+		bottom = Math.max(bottom, b.y + b.height);
+	}
+	const padX = (right - left) * GROUP_CROP_PADDING;
+	const padY = (bottom - top) * GROUP_CROP_PADDING;
+	let x0 = left - padX;
+	let y0 = top - padY;
+	let x1 = right + padX;
+	let y1 = bottom + padY;
+	const minW = fw * MIN_CROP_FRACTION;
+	const minH = fh * MIN_CROP_FRACTION;
+	if (x1 - x0 < minW) {
+		const cx = (x0 + x1) / 2;
+		x0 = cx - minW / 2;
+		x1 = cx + minW / 2;
+	}
+	if (y1 - y0 < minH) {
+		const cy = (y0 + y1) / 2;
+		y0 = cy - minH / 2;
+		y1 = cy + minH / 2;
+	}
+	const width = Math.min(x1 - x0, fw);
+	const height = Math.min(y1 - y0, fh);
+	const x = Math.max(0, Math.min(x0, fw - width));
+	const y = Math.max(0, Math.min(y0, fh - height));
+	return {
+		x: Math.round(x),
+		y: Math.round(y),
+		width: Math.round(width),
+		height: Math.round(height)
+	};
+}
+/**
+* Carry a crop computed on the DETECTION frame onto the NATIVE surface.
+*
+* The two are different sizes by construction: detection runs on a downscaled
+* frame and the group shot is fetched at up to 4096 px. Applying the rectangle
+* raw would cut a corner of the picture and call it the group — the failure
+* mode is silent and looks like a framing bug.
+*
+* Scaled per axis rather than by one factor, because the two surfaces are not
+* guaranteed to share an aspect, and clamped to the native frame so rounding
+* can never ask for a pixel that is not there.
+*/
+function scaleCropToFrame(crop, from, to) {
+	if (from.width <= 0 || from.height <= 0 || to.width <= 0 || to.height <= 0) return null;
+	const sx = to.width / from.width;
+	const sy = to.height / from.height;
+	const x = Math.max(0, Math.min(Math.round(crop.x * sx), to.width - 1));
+	const y = Math.max(0, Math.min(Math.round(crop.y * sy), to.height - 1));
+	return {
+		x,
+		y,
+		width: Math.max(1, Math.min(Math.round(crop.width * sx), to.width - x)),
+		height: Math.max(1, Math.min(Math.round(crop.height * sy), to.height - y))
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/summary/summary-score.ts
 /** A member whose own box is covered this much by others is hidden. */
 var OCCLUDED_COVER_FRACTION = .5;
@@ -72404,12 +72515,24 @@ function scoreSummaryFrame(input) {
 	const visible = present.filter((d) => coveredFraction(d.bbox, present.filter((o) => o !== d).map((o) => o.bbox)) < OCCLUDED_COVER_FRACTION);
 	if (visible.length === 0) return {
 		visible: 0,
-		quality: 0
+		quality: 0,
+		crop: null
 	};
 	const quality = visible.reduce((sum, d) => sum + memberQuality(d, input.frameWidth, input.frameHeight), 0) / visible.length;
+	const crop = groupCropRect({
+		boxes: visible.map((d) => ({
+			x: d.bbox.x,
+			y: d.bbox.y,
+			width: d.bbox.width,
+			height: d.bbox.height
+		})),
+		frameWidth: input.frameWidth,
+		frameHeight: input.frameHeight
+	});
 	return {
 		visible: visible.length,
-		quality
+		quality,
+		crop
 	};
 }
 /**
@@ -72529,6 +72652,54 @@ var GroupShotTracker = class {
 };
 //#endregion
 //#region src/pipeline-analytics/summary/group-shot-materialiser.ts
+/**
+* Apply the group crop to the native surface, or hand it back untouched.
+*
+* Every reason to skip is a reason NOT to guess: no rectangle, no detection
+* geometry to scale from, or a cropper this deployment does not have. The full
+* frame is worse than a crop and far better than a wrong crop.
+*/
+async function cropNative(native, input, deps) {
+	const crop = input.crop;
+	if (!crop || !deps.cropFrame) return native;
+	const fw = input.cropFrameWidth;
+	const fh = input.cropFrameHeight;
+	if (fw === void 0 || fh === void 0) return native;
+	const scaled = scaleCropToFrame(crop, {
+		width: fw,
+		height: fh
+	}, native);
+	if (scaled === null) return native;
+	if (scaled.width >= native.width && scaled.height >= native.height) return native;
+	try {
+		const cut = await deps.cropFrame(native, scaled);
+		if (cut === null) return native;
+		const expected = cut.width * cut.height * 3;
+		if (cut.format === "rgb" && cut.data.length !== expected) {
+			deps.logger.warn("group shot crop returned a surface that is not its geometry", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					summaryId: input.summaryId,
+					width: cut.width,
+					height: cut.height,
+					expectedBytes: expected,
+					gotBytes: cut.data.length
+				}
+			});
+			return native;
+		}
+		return cut;
+	} catch (err) {
+		deps.logger.warn("group shot crop failed — storing the full frame", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				summaryId: input.summaryId,
+				error: errMsg$1(err)
+			}
+		});
+		return native;
+	}
+}
 async function persistSummaryGroupShot(deps, input) {
 	const { deviceId, summaryId, frameHandle } = input;
 	const drop = {
@@ -72562,7 +72733,8 @@ async function persistSummaryGroupShot(deps, input) {
 			});
 			return { kind: "ram-tier" };
 		}
-		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(native);
+		const surface = await cropNative(native, input, deps);
+		const { keyFrame, keyFrameSmall } = await deps.encodeVariants(surface);
 		const keyFrameMediaId = await deps.media.putReplacing({
 			deviceId,
 			ownerKind: "summary",
@@ -79782,13 +79954,30 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				fetchNativeFullFrame: getNative,
 				encodeVariants: encodeKeyFrameVariants,
 				media: mediaStore,
-				logger: this.ctx.logger
+				logger: this.ctx.logger,
+				cropFrame: async (frame, rect) => {
+					const out = await extractCropRaw(frame.data, frame.width, frame.height, {
+						x: rect.x / frame.width,
+						y: rect.y / frame.height,
+						w: rect.width / frame.width,
+						h: rect.height / frame.height
+					});
+					return {
+						...frame,
+						data: out.data,
+						width: out.width,
+						height: out.height
+					};
+				}
 			}, {
 				deviceId,
 				summaryId,
 				timestamp: result.timestamp,
 				frameHandle,
-				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
+				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH,
+				crop: score.crop,
+				cropFrameWidth: result.frameWidth,
+				cropFrameHeight: result.frameHeight
 			})
 		}).then((outcome) => {
 			if (outcome?.kind === "landed") {

package/package.json

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