@camstack/addon-pipeline 1.2.621 → 1.2.623

package/dist/pipeline-runner/index.mjs

@@ -1,6 +1,7 @@
-import { A as NativeLeaseAdmissionSchema, Bn as MODEL_FORMATS, E as FailureCounters, Hn as createEvent, In as BaseAddon, Lt as linkedStepOf, M as NodeBenchRunnerInputSchema, P as PIPELINE_RAMP, Pn as errMsg, Qt as pickNativeLeaseOverride, Rt as loadContributionCapability, Un as customAction, V as ROOT_SUPPLIABLE_STEP_IDS, Wn as defineCustomActions, Y as allowedSuppliedEffect, Zt as pickDetailCropConvention, _ as DEFAULT_DETAIL_CROP_CONVENTION, _r as EventCategory, a as BackgroundRunRegistry, ar as _enum, dr as number, en as pipelineRunnerCapability, er as nodePin, fr as object, gt as deriveRootFaceRefineRect, hr as string, j as NativeLeaseSettingsSchema, kt as failureContributionCapability, lr as lazy, m as CROP_SUPPLY_SOURCES, mn as rootSuppliesOf, mt as deriveDetailCropRect, nt as buildBenchStepTree, or as array, pn as resolveRootSupply, rt as cameraOwnsMotionViaSensor, sr as boolean, un as resolveModelBoundSetting, ur as literal, x as DEVICE_RAMP, y as DEFAULT_NATIVE_LEASE_SETTINGS } from "../dist-DHqkQhTQ.mjs";
-import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-CkJLxlWI.mjs";
-import { a as stepsForElectedPool, b as getStepDefinition, d as rootObjectGate, f as localFrameRegistry, h as resolveFrameViewGeometry, i as placeDetailStep, l as resolveDefaultDetectionModel, m as createSessionDecodeCoordinator, p as isSessionDecodeReadGone, s as resolveDeviceEngine, t as CustomModelCatalog, u as macroGateVerdict, y as getStep } from "../custom-model-catalog-0_SnSXzN.mjs";
+import { $n as defineCustomActions, A as NativeLeaseAdmissionSchema, E as FailureCounters, Er as EventCategory, F as PIPELINE_RAMP, Ft as fuseRecoveredDetections, Gn as BaseAddon, Ht as linkedStepOf, M as NodeBenchRunnerInputSchema, Nt as failureContributionCapability, Q as applyCropClassFloors, Qn as customAction, Sn as rootSuppliesOf, U as ROOT_SUPPLIABLE_STEP_IDS, Un as errMsg, Ut as loadContributionCapability, Yn as MODEL_FORMATS, Z as allowedSuppliedEffect, Zn as createEvent, _ as DEFAULT_DETAIL_CROP_CONVENTION, a as BackgroundRunRegistry, an as planMotionCrops, at as buildBenchStepTree, br as number, bt as deriveRootFaceRefineRect, cn as readRecoveryRecipeForSteps, ft as countRecoverySkips, gr as boolean, hr as array, in as pipelineRunnerCapability, j as NativeLeaseSettingsSchema, lr as nodePin, m as CROP_SUPPLY_SOURCES, mr as _enum, nn as pickNativeLeaseOverride, on as planRecoveryCrops, ot as cameraOwnsMotionViaSensor, pn as remapCropDetections, tn as pickDetailCropConvention, vn as resolveModelBoundSetting, vr as lazy, vt as deriveDetailCropRect, wn as selectRecoveryStep, wr as string, x as DEVICE_RAMP, xn as resolveRootSupply, xr as object, y as DEFAULT_NATIVE_LEASE_SETTINGS, yr as literal } from "../dist-opSx6v5i.mjs";
+import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-CGIYuJMN.mjs";
+import { a as stepsForElectedPool, c as resolveDefaultDetectionModel, d as localFrameRegistry, f as isSessionDecodeReadGone, i as placeDetailStep, l as macroGateVerdict, m as resolveFrameViewGeometry, p as createSessionDecodeCoordinator, s as resolveDeviceEngine, t as CustomModelCatalog, u as rootObjectGate, v as getStep, y as getStepDefinition } from "../custom-model-catalog-D5zTw1LU.mjs";
+import { i as SessionHwaccelSource } from "../worker-protocol-_avq7y8O.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { c as withDetectionIntent, o as preRollRequestOf, t as DETECTION_PRE_ROLL_REQUEST_MS } from "../restream-intent-DyGmLAU9.mjs";
@@ -1766,6 +1767,7 @@ function startSessionDecodePump(deps) {
 			return child;
 		},
 		lease: deps.lease,
+		hwaccel: deps.hwaccel,
 		logger: deps.logger,
 		teardownMode: () => teardownMode,
 		onSessionTeardown: (teardown) => {
@@ -4547,456 +4549,6 @@ function summarizeRunnerHardware(hardware, cpuCores = os$1.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 = {
@@ -7294,6 +6846,97 @@ var PipelineRunner = class {
 	}
 };
 //#endregion
+//#region src/pipeline-runner/small-subject-recovery.ts
+/**
+* Small-subject recovery — a second detector pass at NATIVE resolution on
+* the moving regions the full-frame pass did not account for.
+*
+* ## Why
+*
+* The first-level detector sees the frame at its input size (320 px on every
+* hardware-aware default). A 4K frame is reduced 12×: a dog measured at
+* 89–277 px in the source is 7–38 px for the model and is not emitted. Camera 615, six
+* instants with a dog in the scene, five with no `animal` detection at all —
+* nothing downstream (tracker, gate, notifications) ever saw a subject. The
+* confirmation gate, which re-runs the same detector on a 320 px native crop
+* of the PERSON, found the dog at 0.74–0.91 as `bestIncompatibleClass`. The
+* measurement that decided the constants below is
+* `docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`: a
+* 640–800 px native square around the moving region brings the dog to
+* 0.82–0.91 with the SAME 320 model; a 1280 px square loses it again.
+*
+* ## What this is NOT (D52)
+*
+* Not a detail/CLIP crop. `deriveDetailCropRect` derives the rectangle a
+* detail or embedding step is fed from a KNOWN subject box, and one vector
+* index tolerates exactly one such derivation. This module derives a square
+* from a MOTION region, before any subject exists, for the FIRST-LEVEL
+* detector; its output is a detection, never a vector. Nothing here may be
+* reused for a detail crop, and nothing here calls the detail derivation.
+*
+* ## When it runs — NOT only when the frame is empty
+*
+* The trigger is an UNCOVERED MOTION REGION, deliberately broader than "the
+* full-frame pass found nothing". Camera 615, 2026-09-06 19:54:33 local: the
+* gate DID confirm an `animal` birth (bestScore 0.8983) — and the track held
+* 9 positions over 1 666 ms, then coasted out its `maxMissedMs` (4 000 ms) and
+* died at 19:54:39, before the dog reached the Aiuola zone. Both of its object
+* events carry `zones: []`, while in the same seconds the animal was in fact
+* at x≈3200, inside the zone. So the defect is not only "the subject is never
+* born" — it is "the subject is born and then the full-frame pass stops seeing
+* it", and a pass gated on "no detections at all" would not have run on a
+* single one of those frames, because the PERSON was still detected.
+*
+* Gating on the motion region instead makes the pass fire in both cases with
+* one rule: a moving thing the full-frame boxes do not account for. A live
+* track feeding on recovered boxes needs one hit per `maxMissedMs` to survive
+* and `minHits` (3) to be born; at {@link RECOVERY_MIN_INTERVAL_MS} the pass
+* supplies 2/s, which is 8× the coasting budget and births a subject in 1.5 s.
+*
+* ## Where
+*
+* In the runner, in-process, on the frame the full pass just ran on. The
+* pixels come from the same process-local `frameRef` lease the full pass
+* used; the crop is resolved as one compressed ≤640 px view. Frames never
+* cross a process boundary at frame rate (D9/D18) — a second crop of the
+* same frame on the same channel does not change that.
+*
+* The pure planning lives in `@camstack/types` (`pipeline/second-pass/`) so the
+* offline accuracy eval runs the same planner; this module re-exports it and
+* keeps the one stateful piece, the per-camera motion-region mirror. The
+* runner wires the lease, the executor call and the rate limit around it.
+*/
+/**
+* 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) {
 	const entry = step.models.find((m) => m.id === modelId);
@@ -10947,6 +10590,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	*/
 	resolveSessionLeaseKnobs = () => resolveNativeLeaseKnobs(process.env, this.nativeLease.current());
 	/**
+	* The decode hwaccel backends this node's kernel resolver offers (D926),
+	* refreshed on the acquire leg with the lease knobs and read when `start` is
+	* sent. A node whose libva cannot initialise the driver offers no vaapi/qsv,
+	* so its session workers never try them.
+	*/
+	sessionHwaccel = new SessionHwaccelSource();
+	resolveSessionHwaccel = () => this.sessionHwaccel.current();
+	/**
 	* Refresh the lease knobs before a decode worker is spawned. Awaited on the
 	* `acquire` leg of `startGuardedSessionDecode` (which always completes before
 	* `startPump` forks), so the spawn sees a value at most one TTL stale rather
@@ -11539,6 +11190,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 	*/
 	async acquireSessionDecodeRestream(api, deviceId, streamId, tag, hostname, ownerNodeId, detectionIntent) {
 		await this.refreshNativeLeaseSettings();
+		await this.sessionHwaccel.refresh(this.ctxIfReady?.kernel.hwaccel);
 		return acquireSessionDecodeRestreamFrom(api, this.ctx.logger, {
 			deviceId,
 			streamId,
@@ -11724,6 +11376,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,
@@ -11905,6 +11558,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,
@@ -12774,6 +12428,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends BaseAddon {
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,

package/dist/{process-memory-Dj3UgL1e.mjs → process-memory-Bd-TuWfM.mjs}

@@ -1,4 +1,4 @@
-import { Yt as parseProcStatus } from "./dist-DHqkQhTQ.mjs";
+import { $t as parseProcStatus } from "./dist-opSx6v5i.mjs";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
 //#region src/shared/node-topology-platform.ts

package/dist/{process-memory-DdIOhjYB.js → process-memory-DyxG-0mG.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-ClkumZgv.js");
+const require_dist = require("./dist-BVo3wa7s.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_child_process = require("node:child_process");

package/dist/recorder/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-ClkumZgv.js");
-const require_node = require("../node-0O_61WVW.js");
+const require_dist = require("../dist-BVo3wa7s.js");
+const require_node = require("../node-DqLsuN_A.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 let node_crypto = require("node:crypto");

package/dist/recorder/index.mjs

@@ -1,5 +1,5 @@
-import { B as RECORDING_SOURCE_CAMSTACK_ADDON, C as EVENT_PAD_MS, Cn as videoclipsCapability, Dt as evictionPolicyOfLocation, Et as evictionPolicyForMode, Ft as isFirstLevelMacroClass, G as VIDEOCLIPS_MAX_OFFER_BYTES, Gn as defineRecordKinds, Gt as modeMayWrite, H as RecordingConfigSchema, Ht as mayWriteToLocation, In as BaseAddon, Jn as hydrateSchema, K as VISIT_MERGE_GAP_MS, Mn as DeviceFeature, N as OpsLogEntrySchema, Nn as DeviceType, Ot as exportSubjectOf, Pn as errMsg$1, R as RECORDING_EXPORT_MAX_READ_BYTES, Rt as loadContributionCapability, S as EVENT_OWNER_TYPES, T as ExportRecordSchema, Tt as eventOverlapsClipWindow, U as RecordingSignalStatusSchema, Un as customAction, Ut as memoizePinnedFfmpeg, Vt as mayReadLocation, Wn as defineCustomActions, Wt as migrateLegacyDeviceSignalConfig, Z as armRemovalReconcile, _r as EventCategory, an as recordingSignalCapability, ar as _enum, at as clipExportFailure, dr as number, er as nodePin, fn as resolveRecordingProfiles, fr as object, gn as startMoverUnderClearance, hr as string, ht as deriveRecordingMode, in as recordingExportCapability, ir as userError, jt as gbToBytes, kn as evaluateSensorEdge, ln as resolveLocationMode, mr as record, nn as recordingArchiveCapability, nr as selectAssignedProfileSlots, o as BatteryStatusSchema, or as array, ot as clipExportFailureOf, pr as preprocess, pt as deriveBatteryPresence, rn as recordingCapability, rr as sleep$1, s as CLIP_BROKER_PACED_RATES, sn as resolveCreateExportSubject, sr as boolean, tt as batteryCapability, v as DEFAULT_EVENTS_BAND_BUFFER_SEC, vn as storageEvictableCapability, vt as deviceRemovalHookCapability, xn as stripRetiredBandPreBufferSec, yn as storageOccupancyCapability, yt as dominantClipLabels, z as RECORDING_SOURCE_CAMSTACK } from "../dist-DHqkQhTQ.mjs";
-import { i as NO_COST_CLAIM, o as physicalRootOf, t as ChildCostRegistry } from "../node-CkJLxlWI.mjs";
+import { $n as defineCustomActions, An as stripRetiredBandPreBufferSec, At as evictionPolicyForMode, B as RECORDING_SOURCE_CAMSTACK, Bt as isFirstLevelMacroClass, C as EVENT_PAD_MS, Cr as record, Ct as dominantClipLabels, Dn as storageEvictableCapability, Er as EventCategory, G as RecordingSignalStatusSchema, Gn as BaseAddon, Hn as DeviceType, It as gbToBytes, J as VISIT_MERGE_GAP_MS, Jt as memoizePinnedFfmpeg, Kt as mayReadLocation, Mn as videoclipsCapability, Mt as exportSubjectOf, On as storageOccupancyCapability, P as OpsLogEntrySchema, Qn as customAction, Rn as evaluateSensorEdge, S as EVENT_OWNER_TYPES, Sr as preprocess, St as deviceRemovalHookCapability, T as ExportRecordSchema, Tn as startMoverUnderClearance, Un as errMsg$1, Ut as loadContributionCapability, V as RECORDING_SOURCE_CAMSTACK_ADDON, Vn as DeviceFeature, W as RecordingConfigSchema, Xt as modeMayWrite, Yt as migrateLegacyDeviceSignalConfig, _n as resolveLocationMode, _t as deriveBatteryPresence, bn as resolveRecordingProfiles, br as number, ct as clipExportFailure, dn as recordingExportCapability, dr as selectAssignedProfileSlots, er as defineRecordKinds, et as armRemovalReconcile, fn as recordingSignalCapability, fr as sleep$1, gr as boolean, hn as resolveCreateExportSubject, hr as array, it as batteryCapability, jt as evictionPolicyOfLocation, kt as eventOverlapsClipWindow, ln as recordingArchiveCapability, lr as nodePin, lt as clipExportFailureOf, mr as _enum, o as BatteryStatusSchema, pr as userError, q as VIDEOCLIPS_MAX_OFFER_BYTES, qt as mayWriteToLocation, rr as hydrateSchema, s as CLIP_BROKER_PACED_RATES, un as recordingCapability, v as DEFAULT_EVENTS_BAND_BUFFER_SEC, wr as string, xr as object, yt as deriveRecordingMode, z as RECORDING_EXPORT_MAX_READ_BYTES } from "../dist-opSx6v5i.mjs";
+import { i as NO_COST_CLAIM, o as physicalRootOf, t as ChildCostRegistry } from "../node-CGIYuJMN.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { d as PREBUFFER_MAX_MS, l as withRecordingIntent, r as RECORDING_PRE_ROLL_REQUEST_MS } from "../restream-intent-DyGmLAU9.mjs";
 import { randomUUID } from "node:crypto";

package/dist/{segment-demux-js-BePzacki.js → segment-demux-js-B4bfTQpK.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-ClkumZgv.js");
+const require_dist = require("./dist-BVo3wa7s.js");
 let node_child_process = require("node:child_process");
 //#region src/stream-broker/recorded/avcc-annexb.ts
 /**