@camstack/addon-pipeline 1.2.205 → 1.2.207

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-CR3_dWir.js");
-const require_node = require("../node-Re3uLz8K.js");
-const require_default_detection_model = require("../default-detection-model-BGsoboIK.js");
-const require_worker_protocol = require("../worker-protocol-lIjbPNbH.js");
+const require_dist = require("../dist-CNPNWUoG.js");
+const require_node = require("../node-h-nvNfmU.js");
+const require_default_detection_model = require("../default-detection-model-BSYGuA-l.js");
+const require_worker_protocol = require("../worker-protocol-C3cr5_6w.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-CKXcDP-V.js");
+const require_lazy_sharp = require("../lazy-sharp-BW3zCwk0.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
@@ -3406,6 +3406,456 @@ function summarizeRunnerHardware(hardware, cpuCores = node_os.cpus().length) {
 		cpuCores
 	};
 }
+/** Area of a normalised rectangle, never negative. Shared with the D396 recipe. */
+function normalizedArea(r) {
+	return Math.max(0, r.w) * Math.max(0, r.h);
+}
+var area = normalizedArea;
+function intersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+}
+/**
+* Share of `region` not covered by any detection box. The sum of pairwise
+* intersections over-counts where detections overlap each other, which only
+* makes the pass MORE conservative; clipped at 1.
+*/
+function uncoveredFraction(region, detections) {
+	const regionArea = area(region);
+	if (regionArea <= 0) return 0;
+	let covered = 0;
+	for (const detection of detections) covered += intersection(region, detection);
+	return 1 - Math.min(1, covered / regionArea);
+}
+/**
+* THE square-placement rule of this pass — one owner, shared by both recipes.
+*
+* A crop is a square of `side` native pixels centred where it can be and slid
+* inside the frame where it cannot. Both region rules place their squares
+* through this function so a crop means the same rectangle whichever rule
+* chose the region.
+*/
+function squareAround(centreX, centreY, side, native) {
+	return {
+		left: Math.round(Math.max(0, Math.min(native.width - side, centreX - side / 2))),
+		top: Math.round(Math.max(0, Math.min(native.height - side, centreY - side / 2))),
+		side
+	};
+}
+function contains(crop, x, y) {
+	return x >= crop.left && x <= crop.left + crop.side && y >= crop.top && y <= crop.top + crop.side;
+}
+/**
+* Squares for one region: one when it fits the largest side, otherwise up to
+* two tiles along its longer axis (a person-sized blob with something small
+* at either end). The padded region decides the side, never the frame.
+*/
+function cropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const padded = longest * 1.5;
+	const side = Math.round(Math.min(Math.max(padded, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (padded <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/**
+* 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).
+*
+* 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 }) => 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;
+		const centreX = crop.left + crop.side / 2;
+		const centreY = crop.top + crop.side / 2;
+		if (planned.some((existing) => contains(existing, centreX, centreY))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
+/**
+* Boxes the executor produced on the crop VIEW → the result's own space.
+*
+* Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
+* square it was cut from (`crop`, native px) and the space the full-frame
+* result reports in (`result`, native px on the `frameRef` path, the inline
+* ≤640 view otherwise). A box touching the view edge was clipped by the crop
+* and is dropped: half a person is not a person, and the tracker would take
+* the half as the whole.
+*/
+function remapCropDetections(detections, crop, view, result, native) {
+	const viewToNative = crop.side / Math.max(1, view.width);
+	const nativeToResultX = result.width / Math.max(1, native.width);
+	const nativeToResultY = result.height / Math.max(1, native.height);
+	const out = [];
+	for (const detection of detections) {
+		const { x, y, width, height } = detection.bbox;
+		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,
+				width: width * viewToNative * nativeToResultX,
+				height: height * viewToNative * nativeToResultY
+			}
+		});
+	}
+	return out;
+}
+function boxIntersection(a, b) {
+	return Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+}
+function sameSubject(recovered, existing) {
+	const inter = boxIntersection(recovered, existing);
+	if (inter <= 0) return false;
+	const areaR = recovered.width * recovered.height;
+	const union = areaR + existing.width * existing.height - inter;
+	if (union > 0 && inter / union >= .5) return true;
+	return areaR > 0 && inter / areaR >= .7;
+}
+/**
+* Class-aware NMS of the recovered boxes against the full-frame ones. Every
+* full-frame box is kept as it is — the second pass only ADDS. A recovered box
+* is added when no full-frame box of the same macro class is the same subject
+* (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
+* re-minted so a crop's `d0` cannot collide with the frame's.
+*/
+function fuseRecoveredDetections(full, recovered) {
+	const accepted = [];
+	for (const [index, candidate] of recovered.entries()) {
+		if ([...full, ...accepted].some((existing) => existing.macroClass === candidate.macroClass && sameSubject(candidate.bbox, existing.bbox))) continue;
+		accepted.push({
+			...candidate,
+			id: `recovered-${index}-${candidate.id}`
+		});
+	}
+	return [...full, ...accepted];
+}
+/**
+* The step the second pass runs: the enabled first-level object detector of
+* the camera's own tree, with its own model and no children. Same model as
+* the full pass so a recovered box is comparable to a full-frame one.
+*/
+function selectRecoveryStep(steps) {
+	const detector = steps.find((step) => step.addonId === "object-detection" && step.enabled !== false);
+	if (!detector) return null;
+	return {
+		addonId: detector.addonId,
+		...detector.modelId !== void 0 ? { modelId: detector.modelId } : {},
+		enabled: true
+	};
+}
+/**
+* The analyzer's last regions per camera, normalised, with the instant they
+* were measured. Refreshed off the motion path; read on the detection path.
+* A stale entry answers nothing — the regions of two seconds ago are not this
+* frame's. An EMPTY analyzer result replaces the previous regions: motion that
+* stopped is not motion.
+*/
+var MotionRegionMirror = class {
+	byDevice = /* @__PURE__ */ new Map();
+	note(deviceId, regions, frameWidth, frameHeight, now) {
+		if (frameWidth <= 0 || frameHeight <= 0) return;
+		this.byDevice.set(deviceId, {
+			at: now,
+			regions: regions.map((region) => ({
+				x: region.bbox.x / frameWidth,
+				y: region.bbox.y / frameHeight,
+				w: region.bbox.w / frameWidth,
+				h: region.bbox.h / frameHeight
+			}))
+		});
+	}
+	fresh(deviceId, now) {
+		const entry = this.byDevice.get(deviceId);
+		if (!entry || now - entry.at > 2e3) return [];
+		return entry.regions;
+	}
+	forget(deviceId) {
+		this.byDevice.delete(deviceId);
+	}
+};
+/**
+* Read the opt-in. Anything that is not the boolean `true` is the shipped
+* rule: a stored string or a number is a mis-write (this repo has shipped a
+* setting written into the wrong sqlite table before), and a mis-write must
+* not silently change what a camera detects on.
+*/
+function readRecoveryRecipe(settings) {
+	return settings?.["motionCropDispatch"] === true ? "motion-crop" : "uncovered-region";
+}
+/**
+* The recipe this camera's resolved step tree selects.
+*
+* Reads the ENABLED first-level detector's own settings, which is where
+* `pipelineOrchestrator.setCameraStepOverride` writes a per-camera value. A
+* tree with no enabled detector runs no second pass at all, so the answer
+* there is the shipped rule and it is never used.
+*/
+function readRecoveryRecipeForSteps(steps) {
+	return readRecoveryRecipe(steps.find((step) => step.addonId === "object-detection" && step.enabled !== false)?.settings);
+}
+/**
+* A motion box is grown ×1.5 about its centre before anything else.
+*
+* The motion step's box is the CHANGED pixels, which on a moving animal is the
+* leading edge plus its shadow, not the animal. The detector needs the subject
+* and the context it was trained on.
+*/
+var MOTION_CROP_MOTION_PAD = 1.5;
+/**
+* An intersecting tracked box is grown ×1.25 — less, because it is already a
+* subject rectangle rather than a change mask.
+*/
+var MOTION_CROP_TRACKED_PAD = 1.25;
+/**
+* The floor a `person` or `vehicle` box must clear when it came out of a CROP
+* rather than out of the full frame.
+*
+* Collected, not assumed: 3 085 quiet frames produced 27 motion-positive
+* frames and 28 crop invocations. The full-frame arm produced 0 boxes above
+* any gate; the crop arm produced 3, of which two are genuine false positives,
+* and both are night-IR corners upscaled into a 320 model — `vehicle 0.749`
+* and `person 0.701`. Zero false `animal` at any gate, which is why `animal`
+* is deliberately absent from this table: the class the pass exists to recover
+* is the class that never produced a false positive, and gating it would cost
+* the whole measured gain.
+*
+* This is a CROP-ONLY floor, applied on top of the per-macro floors the
+* executor already enforced. A full-frame `person` at 0.70 is untouched — the
+* full-frame arm is the one arm with ground truth behind its floor
+* (`minConfidencePerson` 0.65, raised on 2026-07-30 from a measured
+* distribution).
+*
+* The cost of this floor is stated rather than assumed away: it can also
+* remove a real distant person or vehicle recovered from a crop at 0.70–0.80.
+* Nothing in the quiet-footage sample measures that, so the floor is a
+* constant here rather than a slider, and the runner reports every drop it
+* makes per camera.
+*/
+var CROP_CLASS_FLOORS = Object.freeze({
+	person: .8,
+	vehicle: .8
+});
+/**
+* Apply the crop-only class floors, REPORTING every drop.
+*
+* A class with no entry in {@link CROP_CLASS_FLOORS} is kept: a floor this
+* table cannot express is not a floor of zero, and silently dropping a class
+* nobody measured is the exact shape of silent drop this repo has paid for
+* three separate times.
+*/
+function applyCropClassFloors(detections) {
+	const kept = [];
+	const dropped = [];
+	for (const detection of detections) {
+		const floor = CROP_CLASS_FLOORS[detection.macroClass];
+		if (floor !== void 0 && detection.score < floor) {
+			dropped.push({
+				macroClass: detection.macroClass,
+				score: detection.score,
+				floor
+			});
+			continue;
+		}
+		kept.push(detection);
+	}
+	return {
+		kept,
+		dropped
+	};
+}
+function scaleAbout(rect, factor) {
+	const w = rect.w * factor;
+	const h = rect.h * factor;
+	return {
+		x: rect.x + rect.w / 2 - w / 2,
+		y: rect.y + rect.h / 2 - h / 2,
+		w,
+		h
+	};
+}
+function overlaps(a, b) {
+	return Math.min(a.x + a.w, b.x + b.w) > Math.max(a.x, b.x) && Math.min(a.y + a.h, b.y + b.h) > Math.max(a.y, b.y);
+}
+function union(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		w: Math.max(a.x + a.w, b.x + b.w) - x,
+		h: Math.max(a.y + a.h, b.y + b.h) - y
+	};
+}
+function clampToFrame(rect) {
+	const x = Math.max(0, rect.x);
+	const y = Math.max(0, rect.y);
+	return {
+		x,
+		y,
+		w: Math.min(1, rect.x + rect.w) - x,
+		h: Math.min(1, rect.y + rect.h) - y
+	};
+}
+/**
+* Merge transitively every seed whose padded box overlaps another, and answer
+* the union rectangles.
+*
+* Transitive on purpose: a person, the dog beside them and the dog's shadow
+* are three components of one subject, and cutting three crops for them spends
+* two inferences on pixels the first one already showed the detector.
+*/
+function mergeSeeds(seeds) {
+	const merged = [];
+	for (const seed of seeds) {
+		let current = seed;
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (let i = merged.length - 1; i >= 0; i -= 1) {
+				const other = merged[i];
+				if (other === void 0 || !overlaps(current, other)) continue;
+				current = union(current, other);
+				merged.splice(i, 1);
+				changed = true;
+			}
+		}
+		merged.push(current);
+	}
+	return merged;
+}
+/**
+* The regions the measured recipe judges this frame on.
+*
+* Motion boxes padded {@link MOTION_CROP_MOTION_PAD}; every full-frame box
+* that intersects a RAW motion box padded {@link MOTION_CROP_TRACKED_PAD} and
+* added as a seed of its own; everything that overlaps merged; the result
+* clamped to the frame, ordered largest first and capped at
+* {@link MOTION_CROP_MAX_REGIONS}.
+*
+* There is deliberately no coverage gate and no size gate here. Those belong
+* to the shipped rule, and they are what makes it a rule about a subject
+* BESIDE a detected one; the measurement says the pass is worth running on the
+* detected subject's own region too.
+*/
+function planMotionCropRegions(input) {
+	if (input.regions.length === 0) return [];
+	const seeds = input.regions.map((r) => scaleAbout(r, MOTION_CROP_MOTION_PAD));
+	for (const detection of input.detections) {
+		if (!input.regions.some((region) => overlaps(detection, region))) continue;
+		seeds.push(scaleAbout(detection, MOTION_CROP_TRACKED_PAD));
+	}
+	return mergeSeeds(seeds).map(clampToFrame).filter((r) => r.w > 0 && r.h > 0).toSorted((a, b) => normalizedArea(b) - normalizedArea(a)).slice(0, 3);
+}
+/**
+* The square the detector is fed for one measured region.
+*
+* "Grow to the detector's input aspect ratio without ever shrinking" is a
+* SQUARE here, and that is a fact about the production detector rather than a
+* simplification: `yolov9m-320-int8` takes 320×320, as does every hardware
+* default in the catalog.
+*
+* The side is the region's longer side, floored at
+* {@link RECOVERY_CROP_MIN_SIDE_PX} — the growth is what magnifies the subject
+* — and ceilinged at {@link RECOVERY_CROP_MAX_SIDE_PX}. The ceiling is NOT a
+* simplification either: at 1024 px the same 320 model scored the reference
+* dog 0.52–0.76, and at 1280 px lost it entirely
+* (`docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`). A
+* region longer than the ceiling is TILED along its longer axis, never zoomed
+* out.
+*/
+function motionCropsForRegion(region, native) {
+	const widthPx = region.w * native.width;
+	const heightPx = region.h * native.height;
+	const longest = Math.max(widthPx, heightPx);
+	const side = Math.round(Math.min(Math.max(longest, 640), 800));
+	const centreX = (region.x + region.w / 2) * native.width;
+	const centreY = (region.y + region.h / 2) * native.height;
+	if (longest <= 800) return [squareAround(centreX, centreY, side, native)];
+	const alongX = widthPx >= heightPx;
+	const quarter = longest / 4;
+	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
+}
+/** `true` when `inner` lies entirely inside `outer`. */
+function cropContains(outer, inner) {
+	return inner.left >= outer.left && inner.top >= outer.top && inner.left + inner.side <= outer.left + outer.side && inner.top + inner.side <= outer.top + outer.side;
+}
+/**
+* The crops the measured recipe runs on this frame.
+*
+* Dedupe is by CONTAINMENT only. Two squares that merely overlap both run: the
+* pixels the second adds are pixels no other crop shows the detector, and the
+* fusion step downstream already refuses a duplicate BOX. Dropping a crop
+* because it overlapped would drop the subject sitting at its edge, which is
+* the whole population this pass exists for.
+*
+* A frame that cannot hold the smallest crop yields nothing: it is already
+* seen at scale.
+*/
+function planMotionCrops(input) {
+	const { native } = input;
+	if (Math.min(native.width, native.height) < 640) return [];
+	const planned = [];
+	for (const region of planMotionCropRegions(input)) for (const crop of motionCropsForRegion(region, native)) {
+		if (planned.some((existing) => cropContains(existing, crop))) continue;
+		planned.push(crop);
+	}
+	return planned;
+}
 //#endregion
 //#region src/pipeline-runner/motion-frame-view.ts
 var MOTION_FRAME_VIEW = {
@@ -5326,218 +5776,6 @@ var PipelineRunner = class {
 		return null;
 	}
 };
-function area(r) {
-	return Math.max(0, r.w) * Math.max(0, r.h);
-}
-function intersection(a, b) {
-	return Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
-}
-/**
-* Share of `region` not covered by any detection box. The sum of pairwise
-* intersections over-counts where detections overlap each other, which only
-* makes the pass MORE conservative; clipped at 1.
-*/
-function uncoveredFraction(region, detections) {
-	const regionArea = area(region);
-	if (regionArea <= 0) return 0;
-	let covered = 0;
-	for (const detection of detections) covered += intersection(region, detection);
-	return 1 - Math.min(1, covered / regionArea);
-}
-function squareAround(centreX, centreY, side, native) {
-	return {
-		left: Math.round(Math.max(0, Math.min(native.width - side, centreX - side / 2))),
-		top: Math.round(Math.max(0, Math.min(native.height - side, centreY - side / 2))),
-		side
-	};
-}
-function contains(crop, x, y) {
-	return x >= crop.left && x <= crop.left + crop.side && y >= crop.top && y <= crop.top + crop.side;
-}
-/**
-* Squares for one region: one when it fits the largest side, otherwise up to
-* two tiles along its longer axis (a person-sized blob with something small
-* at either end). The padded region decides the side, never the frame.
-*/
-function cropsForRegion(region, native) {
-	const widthPx = region.w * native.width;
-	const heightPx = region.h * native.height;
-	const longest = Math.max(widthPx, heightPx);
-	const padded = longest * 1.5;
-	const side = Math.round(Math.min(Math.max(padded, 640), 800));
-	const centreX = (region.x + region.w / 2) * native.width;
-	const centreY = (region.y + region.h / 2) * native.height;
-	if (padded <= 800) return [squareAround(centreX, centreY, side, native)];
-	const alongX = widthPx >= heightPx;
-	const quarter = longest / 4;
-	return [squareAround(alongX ? centreX - quarter : centreX, alongX ? centreY : centreY - quarter, side, native), squareAround(alongX ? centreX + quarter : centreX, alongX ? centreY : centreY + quarter, side, native)];
-}
-/**
-* 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).
-*
-* 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 }) => 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;
-		const centreX = crop.left + crop.side / 2;
-		const centreY = crop.top + crop.side / 2;
-		if (planned.some((existing) => contains(existing, centreX, centreY))) continue;
-		planned.push(crop);
-	}
-	return planned;
-}
-/**
-* Boxes the executor produced on the crop VIEW → the result's own space.
-*
-* Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
-* square it was cut from (`crop`, native px) and the space the full-frame
-* result reports in (`result`, native px on the `frameRef` path, the inline
-* ≤640 view otherwise). A box touching the view edge was clipped by the crop
-* and is dropped: half a person is not a person, and the tracker would take
-* the half as the whole.
-*/
-function remapCropDetections(detections, crop, view, result, native) {
-	const viewToNative = crop.side / Math.max(1, view.width);
-	const nativeToResultX = result.width / Math.max(1, native.width);
-	const nativeToResultY = result.height / Math.max(1, native.height);
-	const out = [];
-	for (const detection of detections) {
-		const { x, y, width, height } = detection.bbox;
-		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,
-				width: width * viewToNative * nativeToResultX,
-				height: height * viewToNative * nativeToResultY
-			}
-		});
-	}
-	return out;
-}
-function boxIntersection(a, b) {
-	return Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x)) * Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
-}
-function sameSubject(recovered, existing) {
-	const inter = boxIntersection(recovered, existing);
-	if (inter <= 0) return false;
-	const areaR = recovered.width * recovered.height;
-	const union = areaR + existing.width * existing.height - inter;
-	if (union > 0 && inter / union >= .5) return true;
-	return areaR > 0 && inter / areaR >= .7;
-}
-/**
-* Class-aware NMS of the recovered boxes against the full-frame ones. Every
-* full-frame box is kept as it is — the second pass only ADDS. A recovered box
-* is added when no full-frame box of the same macro class is the same subject
-* (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
-* re-minted so a crop's `d0` cannot collide with the frame's.
-*/
-function fuseRecoveredDetections(full, recovered) {
-	const accepted = [];
-	for (const [index, candidate] of recovered.entries()) {
-		if ([...full, ...accepted].some((existing) => existing.macroClass === candidate.macroClass && sameSubject(candidate.bbox, existing.bbox))) continue;
-		accepted.push({
-			...candidate,
-			id: `recovered-${index}-${candidate.id}`
-		});
-	}
-	return [...full, ...accepted];
-}
-/**
-* The step the second pass runs: the enabled first-level object detector of
-* the camera's own tree, with its own model and no children. Same model as
-* the full pass so a recovered box is comparable to a full-frame one.
-*/
-function selectRecoveryStep(steps) {
-	const detector = steps.find((step) => step.addonId === "object-detection" && step.enabled !== false);
-	if (!detector) return null;
-	return {
-		addonId: detector.addonId,
-		...detector.modelId !== void 0 ? { modelId: detector.modelId } : {},
-		enabled: true
-	};
-}
-/**
-* The analyzer's last regions per camera, normalised, with the instant they
-* were measured. Refreshed off the motion path; read on the detection path.
-* A stale entry answers nothing — the regions of two seconds ago are not this
-* frame's. An EMPTY analyzer result replaces the previous regions: motion that
-* stopped is not motion.
-*/
-var MotionRegionMirror = class {
-	byDevice = /* @__PURE__ */ new Map();
-	note(deviceId, regions, frameWidth, frameHeight, now) {
-		if (frameWidth <= 0 || frameHeight <= 0) return;
-		this.byDevice.set(deviceId, {
-			at: now,
-			regions: regions.map((region) => ({
-				x: region.bbox.x / frameWidth,
-				y: region.bbox.y / frameHeight,
-				w: region.bbox.w / frameWidth,
-				h: region.bbox.h / frameHeight
-			}))
-		});
-	}
-	fresh(deviceId, now) {
-		const entry = this.byDevice.get(deviceId);
-		if (!entry || now - entry.at > 2e3) return [];
-		return entry.regions;
-	}
-	forget(deviceId) {
-		this.byDevice.delete(deviceId);
-	}
-};
 //#endregion
 //#region src/pipeline-runner/stateless-step.ts
 function modelServability(step, modelId, format) {
@@ -5688,6 +5926,18 @@ function isUsable(bbox) {
 *    independently from the inference workers.
 */
 /**
+* The zero of the recovery skip counters — one frozen literal so a new reason
+* cannot be added to the map's shape and forgotten in one of the two places
+* that used to spell the zero out by hand.
+*/
+var EMPTY_RECOVERY_SKIPS = Object.freeze({
+	rateLimited: 0,
+	noMotion: 0,
+	tooLarge: 0,
+	covered: 0,
+	unmagnifiable: 0
+});
+/**
 * How often the small-subject recovery pass reports per camera. The pass runs
 * up to twice a second; one aggregated line every ten seconds says how often
 * it ran, what it cost and what it found — the numbers a "did the second
@@ -6142,7 +6392,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* 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.
+	* stale motion mirror, `tooLarge` / `covered` the shipped rule's two region
+	* gates, and `unmagnifiable` the measured recipe's only non-run — a frame
+	* whose short side is below the magnification floor (D396).
+	*
+	* Together with `passes` these count EVERY frame the pass was offered, which
+	* is what turns `crops` into the detector invocations per frame the cost of
+	* this feature is judged on.
 	*/
 	recoverySkips = /* @__PURE__ */ new Map();
 	/**
@@ -8849,13 +9105,17 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			})),
 			native
 		};
-		const crops = planRecoveryCrops(planInput);
+		const recipe = readRecoveryRecipeForSteps(steps);
+		const crops = recipe === "motion-crop" ? planMotionCrops(planInput) : planRecoveryCrops(planInput);
 		if (crops.length === 0) {
-			const skipped = countRecoverySkips(planInput);
-			this.addRecoverySkips(deviceId, {
-				tooLarge: skipped.tooLarge,
-				covered: skipped.covered
-			});
+			if (recipe === "motion-crop") this.addRecoverySkips(deviceId, { unmagnifiable: 1 });
+			else {
+				const skipped = countRecoverySkips(planInput);
+				this.addRecoverySkips(deviceId, {
+					tooLarge: skipped.tooLarge,
+					covered: skipped.covered
+				});
+			}
 			return result;
 		}
 		this.lastRecoveryAt.set(deviceId, now);
@@ -8890,11 +9150,19 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				} });
 			}
 		}
-		const fused = fuseRecoveredDetections(result.detections, recovered);
+		const floor = applyCropClassFloors(recovered);
+		if (floor.dropped.length > 0) log.info("small-subject recovery: crop boxes below the crop-only class floor", { meta: {
+			recipe,
+			dropped: floor.dropped,
+			nodeId: this.nodeId
+		} });
+		const fused = fuseRecoveredDetections(result.detections, floor.kept);
 		const added = fused.length - result.detections.length;
 		this.reportRecovery(deviceId, {
 			crops: cropsRun,
 			recovered: added,
+			floored: floor.dropped.length,
+			recipe,
 			ms: Date.now() - started,
 			now,
 			classes: fused.slice(result.detections.length).map((d) => `${d.macroClass}:${d.score.toFixed(3)}`)
@@ -8953,17 +9221,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* in the log.
 	*/
 	addRecoverySkips(deviceId, delta) {
-		const current = this.recoverySkips.get(deviceId) ?? {
-			rateLimited: 0,
-			noMotion: 0,
-			tooLarge: 0,
-			covered: 0
-		};
+		const current = this.recoverySkips.get(deviceId) ?? EMPTY_RECOVERY_SKIPS;
 		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)
+			covered: current.covered + (delta.covered ?? 0),
+			unmagnifiable: current.unmagnifiable + (delta.unmagnifiable ?? 0)
 		});
 	}
 	/** Aggregate the pass per camera and report once per {@link RECOVERY_LOG_INTERVAL_MS}. */
@@ -8972,6 +9236,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			passes: 0,
 			crops: 0,
 			recovered: 0,
+			floored: 0,
 			ms: 0,
 			reportedAt: sample.now
 		};
@@ -8979,12 +9244,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			passes: stats.passes + 1,
 			crops: stats.crops + sample.crops,
 			recovered: stats.recovered + sample.recovered,
+			floored: stats.floored + sample.floored,
 			ms: stats.ms + sample.ms,
 			reportedAt: stats.reportedAt
 		};
 		if (sample.recovered > 0) this.ctx.logger.info("small-subject recovery: the native crop pass found what the full frame missed", {
 			tags: { deviceId },
 			meta: {
+				recipe: sample.recipe,
 				crops: sample.crops,
 				recovered: sample.recovered,
 				classes: sample.classes,
@@ -8992,24 +9259,25 @@ 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
-			};
+			const skips = this.recoverySkips.get(deviceId) ?? EMPTY_RECOVERY_SKIPS;
+			const framesOffered = next.passes + skips.rateLimited + skips.noMotion + skips.tooLarge + skips.covered + skips.unmagnifiable;
 			this.ctx.logger.info("small-subject recovery: pass report", {
 				tags: { deviceId },
 				meta: {
+					recipe: sample.recipe,
 					passes: next.passes,
 					crops: next.crops,
 					recovered: next.recovered,
+					floored: next.floored,
+					framesOffered,
+					cropsPerFrame: framesOffered > 0 ? +(next.crops / framesOffered).toFixed(3) : 0,
 					avgMsPerPass: next.passes > 0 ? Math.round(next.ms / next.passes) : 0,
 					windowMs: sample.now - stats.reportedAt,
 					skipRateLimited: skips.rateLimited,
 					skipNoMotion: skips.noMotion,
 					skipTooLarge: skips.tooLarge,
-					skipCovered: skips.covered
+					skipCovered: skips.covered,
+					skipUnmagnifiable: skips.unmagnifiable
 				}
 			});
 			this.recoverySkips.delete(deviceId);
@@ -9017,6 +9285,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				passes: 0,
 				crops: 0,
 				recovered: 0,
+				floored: 0,
 				ms: 0,
 				reportedAt: sample.now
 			});