@camstack/addon-pipeline 1.2.621 → 1.2.623

package/dist/pipeline-runner/index.js

@@ -3,9 +3,10 @@ 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_custom_model_catalog = require("../custom-model-catalog-Il8UY4D4.js");
+const require_dist = require("../dist-BVo3wa7s.js");
+const require_node = require("../node-DqLsuN_A.js");
+const require_custom_model_catalog = require("../custom-model-catalog-BTBdgN2p.js");
+const require_worker_protocol = require("../worker-protocol-DngGEAT2.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
@@ -1773,6 +1774,7 @@ function startSessionDecodePump(deps) {
 			return child;
 		},
 		lease: deps.lease,
+		hwaccel: deps.hwaccel,
 		logger: deps.logger,
 		teardownMode: () => teardownMode,
 		onSessionTeardown: (teardown) => {
@@ -4555,456 +4557,6 @@ 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 = {
@@ -7302,6 +6854,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);
@@ -10955,6 +10598,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	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 require_worker_protocol.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
@@ -11547,6 +11198,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	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,
@@ -11732,6 +11384,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,
@@ -11913,6 +11566,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,
@@ -12169,7 +11823,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			this.addRecoverySkips(deviceId, { noMotion: 1 });
 			return result;
 		}
-		const step = selectRecoveryStep(steps);
+		const step = require_dist.selectRecoveryStep(steps);
 		if (step === null) return result;
 		if (result.width <= 0 || result.height <= 0) return result;
 		const native = {
@@ -12186,12 +11840,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			})),
 			native
 		};
-		const recipe = readRecoveryRecipeForSteps(steps);
-		const crops = recipe === "motion-crop" ? planMotionCrops(planInput) : planRecoveryCrops(planInput);
+		const recipe = require_dist.readRecoveryRecipeForSteps(steps);
+		const crops = recipe === "motion-crop" ? require_dist.planMotionCrops(planInput) : require_dist.planRecoveryCrops(planInput);
 		if (crops.length === 0) {
 			if (recipe === "motion-crop") this.addRecoverySkips(deviceId, { unmagnifiable: 1 });
 			else {
-				const skipped = countRecoverySkips(planInput);
+				const skipped = require_dist.countRecoverySkips(planInput);
 				this.addRecoverySkips(deviceId, {
 					tooLarge: skipped.tooLarge,
 					covered: skipped.covered
@@ -12217,7 +11871,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					...deviceKey ? { deviceKey } : {}
 				});
 				if (!cropResult) continue;
-				recovered.push(...remapCropDetections(cropResult.detections, crop, {
+				recovered.push(...require_dist.remapCropDetections(cropResult.detections, crop, {
 					width: view.width,
 					height: view.height
 				}, {
@@ -12232,13 +11886,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				} });
 			}
 		}
-		const floor = applyCropClassFloors(recovered);
+		const floor = require_dist.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 fused = require_dist.fuseRecoveredDetections(result.detections, floor.kept);
 		const added = fused.length - result.detections.length;
 		this.reportRecovery(deviceId, {
 			crops: cropsRun,
@@ -12782,6 +12436,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
+					hwaccel: this.resolveSessionHwaccel,
 					onWorkerGone: hooks.onWorkerGone,
 					logger: log,
 					source,