@camstack/addon-pipeline 1.2.195 → 1.2.197

package/dist/pipeline-runner/index.js

@@ -2,12 +2,12 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-HG5geL9t.js");
-const require_node = require("../node--my8JTOW.js");
-const require_default_detection_model = require("../default-detection-model-CJdc8j83.js");
-const require_worker_protocol = require("../worker-protocol-DCsi4YS1.js");
+const require_dist = require("../dist-CBa1j3On.js");
+const require_node = require("../node-C-B8VuGi.js");
+const require_default_detection_model = require("../default-detection-model-CM-8U0Bb.js");
+const require_worker_protocol = require("../worker-protocol-CXsdriRX.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-DmAwZ0s9.js");
+const require_lazy_sharp = require("../lazy-sharp-CS5WE9mI.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
@@ -1977,6 +1977,169 @@ function buildBenchRunPipelineInput(req) {
 		...req.plane ? { plane: req.plane } : {}
 	};
 }
+/**
+* How long a box stays "seen".
+*
+* Sized on the gate's own clock, not on a guess: `maxDeferralMs` defaults to
+* 2 000 ms, so a birth's whole life as a candidate is 2 s. A window shorter
+* than that would re-cut the same subject inside one deferral; a much longer
+* one would stop a subject that genuinely left and returned from being cut
+* again. 3 000 ms is the deferral budget plus one 1 s margin.
+*/
+var BIRTH_EVIDENCE_NOVELTY_WINDOW_MS = 3e3;
+/**
+* Padding around the box, as a fraction of its size.
+*
+* 0.15 deliberately equals `CONFIRMATION_CROP_PADDING` in post-analysis: the
+* gate promotes a secondary subject by mapping a crop-space box back into the
+* frame through the rectangle the crop was cut from, and the two derivations
+* disagreeing is how a promoted box lands somewhere the pixels never were.
+*/
+var BIRTH_EVIDENCE_PADDING = .15;
+/**
+* Boxes remembered per camera. A frame with more subjects than this keeps the
+* most recent — the cap is about bounding a crowd, and a box that fell out is
+* merely eligible for a cut it will not get twice (the encode budget above is
+* the real spend). 64 is 16x the tile tier's per-frame subject cap.
+*/
+var REMEMBERED_BOXES_PER_DEVICE = 64;
+/**
+* Per-camera memory of the boxes recently on screen.
+*
+* Per CAMERA and never global: a box on 617 says nothing about 615, and a
+* shared structure would make one camera's traffic decide another's cuts —
+* which is the exact shape of the node-wide sharing this whole change moves
+* away from.
+*
+* Judged per CLASS. A dog at its owner's knee is 100% contained in the person's
+* box; a class-blind test would call it "already seen" and it would reach the
+* gate with no pixels — the failure D372, D377 and D378 each fought at a
+* different layer.
+*/
+var BirthNoveltyMemory = class {
+	byDevice = /* @__PURE__ */ new Map();
+	/**
+	* Is this box a subject the camera has not been showing?
+	*
+	* Pure: it does not record anything. The caller records the whole frame with
+	* {@link note}, once, so a box that lost the encode budget is still counted
+	* as seen — otherwise the cap turns into a permanent re-cut of the same
+	* subjects.
+	*/
+	isNovel(deviceId, box, macroClass, nowMs) {
+		const boxes = this.byDevice.get(deviceId);
+		if (!boxes) return true;
+		for (const remembered of boxes) {
+			if (nowMs - remembered.atMs > 3e3) continue;
+			if (remembered.macroClass !== macroClass) continue;
+			if (iou(remembered.rect, box) >= .3) return false;
+		}
+		return true;
+	}
+	/** Record a frame's detections and drop everything past the window / the cap. */
+	note(deviceId, detections, nowMs) {
+		const kept = (this.byDevice.get(deviceId) ?? []).filter((b) => nowMs - b.atMs <= BIRTH_EVIDENCE_NOVELTY_WINDOW_MS);
+		for (const d of detections) {
+			if (!isUsable$1(d.bbox)) continue;
+			kept.push({
+				rect: d.bbox,
+				macroClass: d.macroClass,
+				atMs: nowMs
+			});
+		}
+		this.byDevice.set(deviceId, kept.length > REMEMBERED_BOXES_PER_DEVICE ? kept.slice(kept.length - REMEMBERED_BOXES_PER_DEVICE) : kept);
+	}
+	/** How many boxes this camera currently remembers (tests / diagnostics). */
+	rememberedCount(deviceId) {
+		return this.byDevice.get(deviceId)?.length ?? 0;
+	}
+	/** Forget a camera wholesale (detach, pipeline reset). */
+	clearDevice(deviceId) {
+		this.byDevice.delete(deviceId);
+	}
+};
+/**
+* The cuts worth taking on this frame, highest confidence first, capped.
+*
+* Records EVERY usable detection in `memory` — including the ones the cap
+* refused — so the budget bounds the spend without turning into a leak.
+*/
+function planBirthEvidence(deviceId, detections, frame, memory, nowMs, maxPerFrame = 2) {
+	if (frame.width <= 0 || frame.height <= 0) return [];
+	const usable = detections.map((d, index) => ({
+		d,
+		index
+	})).filter(({ d }) => isUsable$1(d.bbox));
+	const novel = usable.filter(({ d }) => memory.isNovel(deviceId, d.bbox, d.macroClass, nowMs));
+	memory.note(deviceId, usable.map(({ d }) => ({
+		bbox: d.bbox,
+		macroClass: d.macroClass
+	})), nowMs);
+	const plan = [];
+	for (const { d, index } of [...novel].sort((a, b) => b.d.score - a.d.score)) {
+		if (plan.length >= maxPerFrame) break;
+		const rect = padAndClamp(d.bbox, frame);
+		if (rect === null) continue;
+		plan.push({
+			index,
+			rect,
+			target: targetFor(rect)
+		});
+	}
+	return plan.sort((a, b) => a.index - b.index);
+}
+/**
+* The padded, clamped source rectangle — or `null` for a box that is not worth
+* an encode. A degenerate box is DROPPED rather than clamped: a zero-area crop
+* serves nothing and a NaN one would poison the encoder's geometry.
+*/
+function padAndClamp(box, frame) {
+	if (Math.min(box.width, box.height) < 128) return null;
+	const padX = box.width * BIRTH_EVIDENCE_PADDING;
+	const padY = box.height * BIRTH_EVIDENCE_PADDING;
+	const left = Math.max(0, Math.floor(box.x - padX));
+	const top = Math.max(0, Math.floor(box.y - padY));
+	const right = Math.min(frame.width, Math.ceil(box.x + box.width + padX));
+	const bottom = Math.min(frame.height, Math.ceil(box.y + box.height + padY));
+	const width = right - left;
+	const height = bottom - top;
+	if (width <= 0 || height <= 0) return null;
+	return {
+		x: left,
+		y: top,
+		width,
+		height
+	};
+}
+/** Encoded size: capped, aspect-preserving, never upscaled. */
+function targetFor(rect) {
+	if (rect.width <= 320) return {
+		width: rect.width,
+		height: rect.height
+	};
+	const scale = 320 / rect.width;
+	return {
+		width: 320,
+		height: Math.max(1, Math.round(rect.height * scale))
+	};
+}
+/** A box with finite, positive extent. */
+function isUsable$1(box) {
+	return Number.isFinite(box.x) && Number.isFinite(box.y) && Number.isFinite(box.width) && Number.isFinite(box.height) && box.width > 0 && box.height > 0;
+}
+/** Intersection over union of two absolute-pixel rectangles. */
+function iou(a, b) {
+	const left = Math.max(a.x, b.x);
+	const top = Math.max(a.y, b.y);
+	const right = Math.min(a.x + a.width, b.x + b.width);
+	const bottom = Math.min(a.y + a.height, b.y + b.height);
+	const w = right - left;
+	const h = bottom - top;
+	if (w <= 0 || h <= 0) return 0;
+	const intersection = w * h;
+	const union = a.width * a.height + b.width * b.height - intersection;
+	return union <= 0 ? 0 : intersection / union;
+}
 //#endregion
 //#region src/pipeline-runner/capacity/capacity-runner.ts
 /**
@@ -5156,12 +5319,6 @@ var PipelineRunner = class {
 		return null;
 	}
 };
-/**
-* How much of a region must lie OUTSIDE every full-frame detection for the
-* pass to run on it. A person's own blob (dilated, with shadow) is covered
-* 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
-*/
-var RECOVERY_MIN_UNCOVERED_FRACTION = .35;
 function area(r) {
 	return Math.max(0, r.w) * Math.max(0, r.h);
 }
@@ -5209,25 +5366,53 @@ function cropsForRegion(region, native) {
 	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
 }
 /**
-* The crops the second pass runs on this frame — possibly none.
+* The ONE place the two region gates are decided. `planRecoveryCrops` filters
+* on it and {@link countRecoverySkips} counts it, so the report can never
+* describe a gate the planner does not actually apply.
+*/
+function classifyRegion(region, uncovered) {
+	if (area(region) > .25) return "too-large";
+	if (uncovered < .35) return "covered";
+	return "eligible";
+}
+/**
+* WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
 *
-* A region qualifies when it is small (`RECOVERY_MAX_REGION_FRAME_FRACTION`)
-* and mostly uncovered by the full-frame boxes
-* (`RECOVERY_MIN_UNCOVERED_FRACTION`). Qualifying regions are served largest
-* uncovered area first under `RECOVERY_MAX_CROPS_PER_FRAME`; a crop whose
-* centre already lies inside a planned crop is folded into it. A frame that
-* cannot hold the smallest crop yields nothing: it is already seen at scale.
+* The pass report counts the passes that RAN, so "the second pass stops running
+* when a person is beside the dog" — a plausible reading of
+* {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+* {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+* — could not be confirmed or killed from the logs at all. This classifies the
+* regions a frame offered, against the same predicate the planner filters on.
 */
+function countRecoverySkips(input) {
+	let tooLarge = 0;
+	let covered = 0;
+	let eligible = 0;
+	for (const region of input.regions) switch (classifyRegion(region, uncoveredFraction(region, input.detections))) {
+		case "too-large":
+			tooLarge += 1;
+			break;
+		case "covered":
+			covered += 1;
+			break;
+		case "eligible":
+			eligible += 1;
+			break;
+	}
+	return {
+		tooLarge,
+		covered,
+		eligible
+	};
+}
 function planRecoveryCrops(input) {
 	const { native } = input;
 	if (Math.min(native.width, native.height) < 640) return [];
 	const ranked = input.regions.map((region) => ({
 		region,
 		uncovered: uncoveredFraction(region, input.detections)
-	})).filter(({ region, uncovered }) => {
-		if (area(region) > .25) return false;
-		return uncovered >= RECOVERY_MIN_UNCOVERED_FRACTION;
-	}).toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
+	})).filter(({ region, uncovered }) => classifyRegion(region, uncovered) === "eligible").toSorted((a, b) => area(b.region) * b.uncovered - area(a.region) * a.uncovered);
 	const planned = [];
 	for (const { region } of ranked) for (const crop of cropsForRegion(region, native)) {
 		if (planned.length >= 2) return planned;
@@ -5258,6 +5443,11 @@ function remapCropDetections(detections, crop, view, result, native) {
 		if (x <= 2 || y <= 2 || x + width >= view.width - 2 || y + height >= view.height - 2) continue;
 		out.push({
 			...detection,
+			nativeRecovery: {
+				score: detection.score,
+				cropSidePx: crop.side,
+				viewPx: view.width
+			},
 			bbox: {
 				x: (crop.left + x * viewToNative) * nativeToResultX,
 				y: (crop.top + y * viewToNative) * nativeToResultY,
@@ -5512,6 +5702,15 @@ var PACKAGE_ZONE_UNION_TTL_MS = 6e4;
 var MAX_BOUND_FRAME_CUTTERS = 256;
 /** How often a camera reports its undispatched cuts. */
 var TILE_CUT_DROP_LOG_INTERVAL_MS = 6e4;
+/**
+* How often a camera reports what carrying its birth evidence COST (D379).
+*
+* The cost of this change is the one thing that must be measured rather than
+* estimated, so the report is per camera, states encodes / bytes / encode-ms
+* over the window, and drains its counters — a camera that cut nothing says
+* nothing until it does.
+*/
+var BIRTH_EVIDENCE_REPORT_INTERVAL_MS = 6e5;
 var DEFAULT_CONFIG = {
 	maxQueueDepth: 30,
 	maxConcurrentInferences: 16,
@@ -5873,6 +6072,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	tileCutDrops = /* @__PURE__ */ new Map();
 	tileCutDropLoggedAt = /* @__PURE__ */ new Map();
 	/**
+	* Per-camera memory of the boxes recently on screen — what decides whether a
+	* detection is worth cutting its own evidence for (D379). Per CAMERA, never
+	* global: one camera's traffic must never decide another's cuts.
+	*/
+	birthNovelty = new BirthNoveltyMemory();
+	/** Per-camera cost of the carried evidence, drained by its report line. */
+	birthEvidenceCost = /* @__PURE__ */ new Map();
+	birthEvidenceReportedAt = /* @__PURE__ */ new Map();
+	/**
 	* Node-level RAM store of retained rgb detection frames, keyed by the
 	* `FrameHandle` that rides the inference-result event (shm-ring removal
 	* 2026-07-16 — replaces the `csr.` shm retention ring). Backs the
@@ -5922,6 +6130,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	/** Per-camera counters since the last recovery report line. */
 	recoveryStats = /* @__PURE__ */ new Map();
 	/**
+	* Per-camera counters for the frames on which the pass did NOT run, since the
+	* last report line (D378). "The second pass stops running when a person is
+	* beside the dog" was a live hypothesis on camera 615 and the logs could not
+	* answer it: a report that counts only the passes that ran cannot say why the
+	* others did not. `rateLimited` is the cadence cap, `noMotion` an empty or
+	* stale motion mirror, and `tooLarge` / `covered` the two region gates.
+	*/
+	recoverySkips = /* @__PURE__ */ new Map();
+	/**
 	* Gates the root-plane `package-detection` step to motion-settle edges +
 	* a low-cadence safety poll instead of every frame (packages are
 	* stationary — per-frame parcel inference is wasted cost). Consulted in
@@ -6141,7 +6358,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.runner.onResult(async (deviceId, frame, result, _streamType, handle) => {
 			this.retention?.noteInferenceResult(deviceId, handle, result);
 			this.cutSubjectTiles(deviceId, result, handle);
-			this.emitInferenceResult(deviceId, frame, result, handle);
+			const carried = await this.attachBirthEvidence(deviceId, frame, result);
+			this.emitInferenceResult(deviceId, frame, carried, handle);
 			const detectionCount = result.detections?.length ?? 0;
 			this.runner?.noteDetectionResult(deviceId, detectionCount);
 			if (detectionCount > 0 && this.occupancyBurstInFlight.has(deviceId)) this.occupancyBurstFound.add(deviceId);
@@ -7129,6 +7347,178 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* stays at debug; a miss the caller is handed as `null` is lost work and is a
 	* warn, carrying the numbers that decide the fix.
 	*/
+	/**
+	* Cut each candidate birth's own pixels from the frame that produced it, and
+	* return a result carrying them (D379).
+	*
+	* Returns the SAME result object when there is nothing to cut, which is the
+	* overwhelming majority of frames: a subject already on screen is not a
+	* birth, so it costs a novelty lookup and no encode. A new result object is
+	* built when there is — never a mutation of the one the executor produced.
+	*
+	* Every drop is counted and reported per camera. A branch that silently
+	* dropped the evidence would be indistinguishable from a camera with no
+	* births at all, which is the shape of failure this whole change exists to
+	* remove.
+	*/
+	async attachBirthEvidence(deviceId, frame, result) {
+		const detections = result.detections;
+		if (detections.length === 0) return result;
+		const plan = planBirthEvidence(deviceId, detections.map((d) => ({
+			bbox: d.bbox,
+			score: d.score,
+			macroClass: d.macroClass
+		})), {
+			width: result.width,
+			height: result.height
+		}, this.birthNovelty, Date.now());
+		if (plan.length === 0) return result;
+		const cost = this.birthEvidenceCost.get(deviceId) ?? {
+			cut: 0,
+			failed: 0,
+			skippedNoPixels: 0,
+			bytes: 0,
+			encodeMs: 0
+		};
+		this.birthEvidenceCost.set(deviceId, cost);
+		const byIndex = /* @__PURE__ */ new Map();
+		if (!(frame.frameRef !== void 0 || frame.format === "rgb" && frame.data.byteLength >= result.width * result.height * 3)) {
+			cost.skippedNoPixels += plan.length;
+			this.reportBirthEvidenceCost(deviceId);
+			return result;
+		}
+		for (const entry of plan) {
+			const startedAt = Date.now();
+			const jpeg = await this.encodeEvidenceCrop(frame, result, entry);
+			if (jpeg === null) {
+				cost.failed += 1;
+				continue;
+			}
+			cost.cut += 1;
+			cost.bytes += jpeg.byteLength;
+			cost.encodeMs += Date.now() - startedAt;
+			byIndex.set(entry.index, {
+				jpegBase64: jpeg.toString("base64"),
+				rect: entry.rect,
+				tier: "analysis"
+			});
+		}
+		this.reportBirthEvidenceCost(deviceId);
+		if (byIndex.size === 0) return result;
+		return {
+			...result,
+			detections: detections.map((d, i) => {
+				const evidence = byIndex.get(i);
+				return evidence === void 0 ? d : {
+					...d,
+					birthEvidence: evidence
+				};
+			})
+		};
+	}
+	/**
+	* One evidence crop, or `null` when neither raster can serve it.
+	*
+	* The process-local frame LEASE is tried first. On the co-located path
+	* `DecodedFrame.data` is deliberately empty and the pixels live only behind
+	* `frameRef` — reading `data` there produced `skippedNoPixels` on roughly half
+	* the cluster's cameras in the first minutes after this shipped, which is
+	* exactly the silent gap this whole change exists to close. It is also the
+	* same lease the recovery pass resolves its views from, so it costs no new
+	* mechanism and no new copy of the frame.
+	*
+	* The raw buffer is the fallback for a frame delivered inline. `format` is
+	* checked rather than assumed: a planar frame read as RGB would produce a crop
+	* of noise that re-detects as nothing — a false SUPPRESSION, the one error
+	* this path must never make.
+	*/
+	async encodeEvidenceCrop(frame, result, entry) {
+		const fromLease = frame.frameRef ? await this.encodeEvidenceFromLease(frame.frameRef, entry) : null;
+		if (fromLease !== null) return fromLease;
+		const expectedBytes = result.width * result.height * 3;
+		if (frame.format !== "rgb" || frame.data.byteLength < expectedBytes) return null;
+		try {
+			let pipeline = (await require_lazy_sharp.getSharp())(frame.data, { raw: {
+				width: result.width,
+				height: result.height,
+				channels: 3
+			} }).extract({
+				left: entry.rect.x,
+				top: entry.rect.y,
+				width: entry.rect.width,
+				height: entry.rect.height
+			});
+			if (entry.target.width !== entry.rect.width) pipeline = pipeline.resize(entry.target.width, entry.target.height, { fit: "fill" });
+			return await pipeline.jpeg({ quality: 85 }).toBuffer();
+		} catch {
+			return null;
+		}
+	}
+	/** The evidence crop from the process-local lease, JPEG-encoded by the view. */
+	async encodeEvidenceFromLease(ref, entry) {
+		const lease = require_default_detection_model.localFrameRegistry.acquire(ref);
+		if (!lease) return null;
+		let reason = "error";
+		try {
+			const view = await lease.resolve({
+				crop: {
+					left: entry.rect.x,
+					top: entry.rect.y,
+					width: entry.rect.width,
+					height: entry.rect.height
+				},
+				content: {
+					width: entry.target.width,
+					height: entry.target.height
+				},
+				fit: "stretch",
+				format: "jpeg"
+			});
+			if (view.kind !== "view") {
+				reason = "drop";
+				return null;
+			}
+			reason = "success";
+			return Buffer.from(view.data);
+		} catch {
+			return null;
+		} finally {
+			lease.release(reason);
+		}
+	}
+	/**
+	* State, per camera, what carrying the evidence cost over the window — and
+	* drain it. The operator's acceptance condition for D379 is that the runner's
+	* memory and the frame path do not grow beyond a declared budget, and a
+	* budget nobody measures is an estimate.
+	*/
+	reportBirthEvidenceCost(deviceId) {
+		const cost = this.birthEvidenceCost.get(deviceId);
+		if (!cost) return;
+		const now = Date.now();
+		const lastAt = this.birthEvidenceReportedAt.get(deviceId) ?? 0;
+		if (lastAt !== 0 && now - lastAt < BIRTH_EVIDENCE_REPORT_INTERVAL_MS) return;
+		const windowMs = lastAt === 0 ? BIRTH_EVIDENCE_REPORT_INTERVAL_MS : now - lastAt;
+		this.birthEvidenceReportedAt.set(deviceId, now);
+		this.ctx.logger.info("birth evidence carried", {
+			tags: { deviceId },
+			meta: {
+				cut: cost.cut,
+				failed: cost.failed,
+				skippedNoPixels: cost.skippedNoPixels,
+				kb: Math.round(cost.bytes / 1024),
+				encodeMs: cost.encodeMs,
+				meanKb: cost.cut > 0 ? Math.round(cost.bytes / cost.cut / 1024) : 0,
+				meanEncodeMs: cost.cut > 0 ? Math.round(cost.encodeMs / cost.cut) : 0,
+				windowMs
+			}
+		});
+		cost.cut = 0;
+		cost.failed = 0;
+		cost.skippedNoPixels = 0;
+		cost.bytes = 0;
+		cost.encodeMs = 0;
+	}
 	async resolveNativeCropPixels(input) {
 		const b = input.bbox;
 		const isFullFrame = b.x <= .001 && b.y <= .001 && b.w >= .999 && b.h >= .999;
@@ -7645,12 +8035,16 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.motionRegions.forget(deviceId);
 		this.lastRecoveryAt.delete(deviceId);
 		this.recoveryStats.delete(deviceId);
+		this.recoverySkips.delete(deviceId);
 		const warnPrefix = `${deviceId}:`;
 		for (const key of this.warnedNoJumpDevice) if (key.startsWith(warnPrefix)) this.warnedNoJumpDevice.delete(key);
 		this.attached.delete(deviceId);
 		this.lastMotionAt.delete(deviceId);
 		this.lastEmittedCameraMetrics.delete(deviceId);
 		this.retention?.forgetDevice(deviceId);
+		this.birthNovelty.clearDevice(deviceId);
+		this.birthEvidenceCost.delete(deviceId);
+		this.birthEvidenceReportedAt.delete(deviceId);
 		this.runner?.unregisterCamera(deviceId);
 		this.ctx?.logger.info("detachCamera", {
 			tags: { deviceId },
@@ -8413,9 +8807,15 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const api = this.ctx?.api;
 		if (!api || !frame.frameRef) return result;
 		const now = Date.now();
-		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) return result;
+		if (now - (this.lastRecoveryAt.get(deviceId) ?? 0) < 500) {
+			this.addRecoverySkips(deviceId, { rateLimited: 1 });
+			return result;
+		}
 		const regions = this.motionRegions.fresh(deviceId, now);
-		if (regions.length === 0) return result;
+		if (regions.length === 0) {
+			this.addRecoverySkips(deviceId, { noMotion: 1 });
+			return result;
+		}
 		const step = selectRecoveryStep(steps);
 		if (step === null) return result;
 		if (result.width <= 0 || result.height <= 0) return result;
@@ -8423,7 +8823,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			width: frame.frameRef.width,
 			height: frame.frameRef.height
 		};
-		const crops = planRecoveryCrops({
+		const planInput = {
 			regions,
 			detections: result.detections.filter((d) => d.kind === "first-level").map((d) => ({
 				x: d.bbox.x / result.width,
@@ -8432,8 +8832,16 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				h: d.bbox.height / result.height
 			})),
 			native
-		});
-		if (crops.length === 0) return result;
+		};
+		const crops = planRecoveryCrops(planInput);
+		if (crops.length === 0) {
+			const skipped = countRecoverySkips(planInput);
+			this.addRecoverySkips(deviceId, {
+				tooLarge: skipped.tooLarge,
+				covered: skipped.covered
+			});
+			return result;
+		}
 		this.lastRecoveryAt.set(deviceId, now);
 		const log = this.ctx.logger.withTags({ deviceId });
 		const started = Date.now();
@@ -8473,7 +8881,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			recovered: added,
 			ms: Date.now() - started,
 			now,
-			classes: fused.slice(result.detections.length).map((d) => d.macroClass)
+			classes: fused.slice(result.detections.length).map((d) => `${d.macroClass}:${d.score.toFixed(3)}`)
 		});
 		return added > 0 ? {
 			...result,
@@ -8522,6 +8930,26 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			lease.release(reason);
 		}
 	}
+	/**
+	* Fold a frame's non-run into the per-camera skip counters, drained by the
+	* next report line (D378). Counters, never lines: a skip happens several
+	* times a second per camera and a line per skip would be the noisiest thing
+	* in the log.
+	*/
+	addRecoverySkips(deviceId, delta) {
+		const current = this.recoverySkips.get(deviceId) ?? {
+			rateLimited: 0,
+			noMotion: 0,
+			tooLarge: 0,
+			covered: 0
+		};
+		this.recoverySkips.set(deviceId, {
+			rateLimited: current.rateLimited + (delta.rateLimited ?? 0),
+			noMotion: current.noMotion + (delta.noMotion ?? 0),
+			tooLarge: current.tooLarge + (delta.tooLarge ?? 0),
+			covered: current.covered + (delta.covered ?? 0)
+		});
+	}
 	/** Aggregate the pass per camera and report once per {@link RECOVERY_LOG_INTERVAL_MS}. */
 	reportRecovery(deviceId, sample) {
 		const stats = this.recoveryStats.get(deviceId) ?? {
@@ -8548,6 +8976,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			}
 		});
 		if (sample.now - stats.reportedAt >= RECOVERY_LOG_INTERVAL_MS) {
+			const skips = this.recoverySkips.get(deviceId) ?? {
+				rateLimited: 0,
+				noMotion: 0,
+				tooLarge: 0,
+				covered: 0
+			};
 			this.ctx.logger.info("small-subject recovery: pass report", {
 				tags: { deviceId },
 				meta: {
@@ -8555,9 +8989,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					crops: next.crops,
 					recovered: next.recovered,
 					avgMsPerPass: next.passes > 0 ? Math.round(next.ms / next.passes) : 0,
-					windowMs: sample.now - stats.reportedAt
+					windowMs: sample.now - stats.reportedAt,
+					skipRateLimited: skips.rateLimited,
+					skipNoMotion: skips.noMotion,
+					skipTooLarge: skips.tooLarge,
+					skipCovered: skips.covered
 				}
 			});
+			this.recoverySkips.delete(deviceId);
 			this.recoveryStats.set(deviceId, {
 				passes: 0,
 				crops: 0,