@camstack/addon-pipeline 1.2.328 → 1.2.330

package/dist/pipeline-runner/index.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-wJO7mXeO.js");
-const require_node = require("../node-BCrqaejt.js");
-const require_default_detection_model = require("../default-detection-model-1SadEKsW.js");
+const require_dist = require("../dist-CMeICL07.js");
+const require_node = require("../node-X_0Tka7-.js");
+const require_default_detection_model = require("../default-detection-model-B6gKGnfx.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");
@@ -1976,33 +1976,34 @@ function onboardRootDetections(slot, frame, gate) {
 	};
 }
 //#endregion
-//#region src/pipeline-runner/label-link.ts
+//#region src/pipeline-runner/root-supply.ts
 /**
-* The runner's half of the detector ↔ step label link (D715).
+* The runner's half of root-model supply (D715, D730).
 *
 * The runner holds the camera's WHOLE step tree (the attach config), so it is
-* the one place that can answer "who writes this effect?" for a camera: the
-* root model's declaration (`fillsClassifierEffects`) against the filled
-* step's own `labelLink` policy and class list (`resolveLabelLink`). Three
-* consumers read that one answer:
-*
-*  - the frame result — a linked label the executor wrote at score 0 is raised
-*    to the detection's score when the detector is authoritative;
-*  - the `detailSteps` announce — a skipped classifier is announced with
-*    `filledBy`, so post-analysis does not dispatch it for a subject the
-*    detector already named;
-*  - `package-detection` — when the root fills it, the package root is not
-*    dispatched at all and the root's own `package` boxes ARE the package
-*    result (the operator's package threshold moves onto the root's gate, and
-*    the frame says it looked).
+* the one place that can answer "does this camera use the root's output for
+* this step?": the root model's declaration (`rootSuppliesOf`) against the
+* step's own `useRootModel` flag, through the one decision `resolveRootSupply`.
+* Four consumers read that answer:
+*
+*  - linked labels — effective ⇒ raised to the detection's score (the root is
+*    the one writer), or DROPPED when the step's class list switched that
+*    class off (the detection stays at its macro); otherwise the score-0
+*    fallback the executor wrote;
+*  - root child boxes — a `plate` / `face` detail the root drew is kept only
+*    when its crop step's supply is effective;
+*  - the `detailSteps` announce — an effective step carries `filledBy` +
+*    `filledAs`, so post-analysis does not infer it;
+*  - `package-detection` — effective ⇒ the package root is not dispatched and
+*    the root's own `package` boxes ARE the package result.
 *
 * Pure: the caller passes the model resolver; no I/O, no clock.
 */
-/** The root step the fills are read from — the always-on camera root. */
-var LABEL_LINK_ROOT_STEP_ID = "object-detection";
+/** The root step the supplies are read from — the always-on camera root. */
+var ROOT_SUPPLY_ROOT_STEP_ID = "object-detection";
 var PACKAGE_STEP_ID = "package-detection";
 var PACKAGE_THRESHOLD_KEY = "minConfidencePackage";
-var EMPTY_LABEL_LINK_PLAN = { decisions: /* @__PURE__ */ new Map() };
+var EMPTY_ROOT_SUPPLY_PLAN = { states: /* @__PURE__ */ new Map() };
 function findStep(steps, addonId) {
 	for (const step of steps) {
 		if (step.addonId === addonId) return step;
@@ -2011,70 +2012,108 @@ function findStep(steps, addonId) {
 	}
 }
 /**
-* Plan a camera's label links from its configured tree. A root with no pinned
-* model runs the static default — a COCO model, which fills nothing.
+* Plan a camera's root supplies from its configured tree. A root with no
+* pinned model runs the step's default — a COCO model, which supplies the
+* animal and vehicle classifiers like any other root.
 */
-function planLabelLinks(steps, resolveModel) {
-	if (steps === void 0) return EMPTY_LABEL_LINK_PLAN;
+function planRootSupplies(steps, resolveModel) {
+	if (steps === void 0) return EMPTY_ROOT_SUPPLY_PLAN;
 	const root = steps.find((s) => s.addonId === "object-detection" && s.enabled !== false);
-	if (root?.modelId === void 0) return EMPTY_LABEL_LINK_PLAN;
-	const fills = resolveModel("object-detection", root.modelId)?.fillsClassifierEffects ?? [];
-	if (fills.length === 0) return {
-		rootModelId: root.modelId,
-		decisions: /* @__PURE__ */ new Map()
-	};
-	const decisions = /* @__PURE__ */ new Map();
-	for (const fill of fills) {
-		const step = findStep(steps, fill.stepId);
-		decisions.set(fill.stepId, require_dist.resolveLabelLink(fill, step === void 0 ? void 0 : {
-			enabled: step.enabled !== false,
-			...step.settings !== void 0 ? { settings: step.settings } : {}
-		}));
+	if (root === void 0) return EMPTY_ROOT_SUPPLY_PLAN;
+	const definition = require_default_detection_model.getStepDefinition(ROOT_SUPPLY_ROOT_STEP_ID);
+	const rootModelId = root.modelId ?? definition.defaultModelId;
+	const supplies = require_dist.rootSuppliesOf(resolveModel(ROOT_SUPPLY_ROOT_STEP_ID, rootModelId), {
+		labels: definition.labels ?? [],
+		...definition.classMap !== void 0 ? { classMap: definition.classMap } : {}
+	});
+	const states = /* @__PURE__ */ new Map();
+	for (const stepId of require_dist.ROOT_SUPPLIABLE_STEP_IDS) {
+		const settings = findStep(steps, stepId)?.settings;
+		states.set(stepId, {
+			...require_dist.resolveRootSupply(stepId, settings, supplies),
+			...settings !== void 0 ? { settings } : {}
+		});
 	}
 	return {
-		rootModelId: root.modelId,
-		decisions
+		rootModelId,
+		states
 	};
 }
-/** Steps this plan says must not be dispatched, with the model that fills them. */
-function filledStepIds(plan) {
+/** The steps whose supply is effective, with the model and the kind. */
+function suppliedSteps(plan) {
 	const out = /* @__PURE__ */ new Map();
 	if (plan.rootModelId === void 0) return out;
-	for (const [stepId, decision] of plan.decisions) if (decision.skip) out.set(stepId, plan.rootModelId);
+	for (const [stepId, state] of plan.states) if (state.effective && state.supply !== void 0) out.set(stepId, {
+		modelId: plan.rootModelId,
+		kind: state.supply.kind
+	});
 	return out;
 }
-function raiseLinkedLabels(detection, plan) {
+/** The steps whose supply just BECAME effective between two plans. */
+function newlySuppliedSteps(previous, next) {
+	const out = [];
+	for (const [stepId, state] of next.states) if (state.effective && previous?.states.get(stepId)?.effective !== true) out.push(stepId);
+	return out;
+}
+function authoritativeLabels(detection, plan) {
 	let changed = false;
-	const labels = detection.labels.map((label) => {
+	const labels = [];
+	for (const label of detection.labels) {
 		const stepId = require_dist.linkedStepOf(label.stepId);
-		if (stepId === void 0 || plan.decisions.get(stepId)?.authoritative !== true) return label;
-		if (label.score === detection.score) return label;
+		const state = stepId !== void 0 ? plan.states.get(stepId) : void 0;
+		if (state === void 0 || !state.effective) {
+			labels.push(label);
+			continue;
+		}
+		if (!require_dist.allowedSuppliedEffect(label.label, state.settings)) {
+			changed = true;
+			continue;
+		}
+		if (label.score === detection.score) {
+			labels.push(label);
+			continue;
+		}
 		changed = true;
-		return {
+		labels.push({
 			...label,
 			score: detection.score
-		};
-	});
+		});
+	}
 	return changed ? labels : void 0;
 }
+/** Whether a root child box survives: only under an effective crop supply. */
+function keepsDetection(detection, plan) {
+	const supplied = detection.rootSupplied;
+	if (supplied === void 0 || detection.kind !== "detail") return true;
+	const stepId = require_dist.ROOT_SUPPLIABLE_STEP_IDS.find((id) => id === supplied.stepId);
+	return stepId !== void 0 && plan.states.get(stepId)?.effective === true;
+}
 /**
-* Raise each linked label to its detection's score where the detector is the
-* authoritative writer of that effect. Every other linked label stays the
-* score-0 fallback the executor wrote. Never mutates; returns the input when
-* nothing changes.
+* Apply the plan to a frame: linked labels of an effective step become
+* authoritative (or are dropped by its class list), and root child boxes of a
+* crop step that is not effective are removed. Never mutates; returns the
+* input when nothing changes.
 */
-function applyLabelLinkAuthority(result, plan) {
-	if (plan.decisions.size === 0) return result;
+function applyRootSupplyAuthority(result, plan) {
+	if (plan.states.size === 0) return result;
 	let changed = false;
-	const detections = result.detections.map((d) => {
-		const labels = raiseLinkedLabels(d, plan);
-		if (labels === void 0) return d;
+	const detections = [];
+	for (const d of result.detections) {
+		if (!keepsDetection(d, plan)) {
+			changed = true;
+			continue;
+		}
+		const labels = authoritativeLabels(d, plan);
+		if (labels === void 0) {
+			detections.push(d);
+			continue;
+		}
 		changed = true;
-		return {
+		detections.push({
 			...d,
 			labels
-		};
-	});
+		});
+	}
 	return changed ? {
 		...result,
 		detections
@@ -2082,7 +2121,7 @@ function applyLabelLinkAuthority(result, plan) {
 }
 /** The root step's schema default for its class allow-list. */
 function rootDefaultMacroClasses() {
-	const field = require_default_detection_model.getStep(LABEL_LINK_ROOT_STEP_ID).getConfigSchema().find((f) => "key" in f && f.key === "enabledMacroClasses");
+	const field = require_default_detection_model.getStep(ROOT_SUPPLY_ROOT_STEP_ID).getConfigSchema().find((f) => "key" in f && f.key === "enabledMacroClasses");
 	const value = field !== void 0 && "default" in field ? field.default : void 0;
 	return Array.isArray(value) ? value : [];
 }
@@ -2103,18 +2142,19 @@ function withPackageAdmitted(root, packageStep) {
 	};
 }
 /**
-* When the root fills `package-detection` and that step's policy lets it be
-* skipped, drop the package root from the dispatch and let the camera root
-* report packages: its gate admits `package` at the package step's threshold.
-* Otherwise the tree is returned untouched.
+* When the root's `package` supply is effective for this camera, drop the
+* package root from the dispatch and let the camera root report packages: its
+* gate admits `package` at the package step's threshold. Otherwise (the root
+* declares no `package`, or the flag is off) the tree is returned untouched
+* and the package step runs its own model.
 */
 function applyPackageFill(steps, plan) {
-	if (plan.decisions.get(PACKAGE_STEP_ID)?.skip !== true) return {
+	if (plan.states.get(PACKAGE_STEP_ID)?.effective !== true) return {
 		steps,
 		filledByRoot: false
 	};
 	const packageStep = steps.find((s) => s.addonId === PACKAGE_STEP_ID);
-	if (packageStep === void 0) return {
+	if (packageStep === void 0 || packageStep.enabled === false) return {
 		steps,
 		filledByRoot: false
 	};
@@ -3296,6 +3336,150 @@ var FaceOutsideParentLog = class {
 	}
 };
 //#endregion
+//#region src/pipeline-runner/root-face-refine.ts
+/**
+* Root face refinement (D731) — how a ROOT model's `face` box becomes a face
+* the recogniser can use, without ever embedding an unaligned crop.
+*
+* A root face box has no landmarks. It is used as a LOCATION only:
+*
+*  1. one face-scoped square around it (`deriveRootFaceRefineRect`, box ×1.6)
+*     is cut from the frame's NATIVE surface — the native lease or nothing;
+*  2. the square is shrunk to {@link ROOT_FACE_REFINE_INPUT_PX} and laid in the
+*     top-left of a black canvas the size of the face detector's input, so the
+*     detector runs at an effective 160 px input on its own 640 graph — the
+*     network is convolutional, the black margin contains nothing, and no 160 px
+*     build of the model is needed. The canvas maps back to the frame through
+*     a "virtual" frame rectangle 640/160 times the square, so every existing
+*     crop→frame mapping (results, native child re-cuts) stays exact;
+*  3. the detector's best face in the square is kept — its landmarks come from
+*     the refinement input, where the face is large, which is the space the
+*     landmark-precision gate then measures it in;
+*  4. that face is handed back to the SAME step as its output
+*     (`suppliedRoot`), so the embedder child aligns it through the existing
+*     native-crop alignment, exactly like a detected face.
+*
+* No face in the square ⇒ nothing is embedded, and the drop is logged.
+*/
+/** The face detector's input side for the step as it will run. */
+function detectorInputPx(step) {
+	const def = require_default_detection_model.getStepDefinition(step.addonId);
+	const modelId = step.modelId ?? def.defaultModelId;
+	return def.models.find((m) => m.id === modelId)?.inputSize.width ?? 160;
+}
+/** Lay the refinement square, shrunk to the refine input, on a black canvas. */
+async function buildRefineCanvas(squareJpeg, canvasPx) {
+	const sharp = await require_lazy_sharp.getSharp();
+	const small = await sharp(squareJpeg).resize(160, 160, { fit: "fill" }).toBuffer();
+	const pad = Math.max(0, canvasPx - 160);
+	return sharp(small).extend({
+		top: 0,
+		left: 0,
+		bottom: pad,
+		right: pad,
+		background: {
+			r: 0,
+			g: 0,
+			b: 0
+		}
+	}).jpeg({ quality: 92 }).toBuffer();
+}
+/** The best face of a refinement pass, or `undefined` when it found none. */
+function bestFace(detections) {
+	return detections.filter((d) => d.macroClass === "face").reduce((best, d) => best === void 0 || d.score > best.score ? d : best, void 0);
+}
+/** The canvas-space face as the step's own output for the second pass. */
+function refinedAsSupplied(face, stepId, modelId) {
+	return {
+		stepId,
+		modelId,
+		detections: [{
+			bbox: [
+				face.bbox.x,
+				face.bbox.y,
+				face.bbox.x + face.bbox.width,
+				face.bbox.y + face.bbox.height
+			],
+			score: face.score,
+			...face.landmarks !== void 0 ? { landmarks: face.landmarks.map((p) => ({
+				x: p.x,
+				y: p.y
+			})) } : {}
+		}]
+	};
+}
+/**
+* Refine the root's face box for one step and run the requested chain on the
+* face it finds. `null` ⇒ no pixels (the native lease is the only source);
+* an empty list ⇒ the square held no face. Every drop is logged.
+*/
+async function refineRootFace(deps, input, supplied, step, requested, deviceKey) {
+	const handle = input.frameHandle;
+	const tags = { deviceId: input.deviceId };
+	if (handle === void 0) {
+		deps.logger.warn("root face refinement needs the native frame — no frame handle, dropped", {
+			tags,
+			meta: { stepId: step.addonId }
+		});
+		return null;
+	}
+	const box = supplied.boxes.reduce((best, b) => b.score > best.score ? b : best);
+	const square = require_dist.deriveRootFaceRefineRect(box.bbox, handle.width, handle.height);
+	const native = await deps.getNativeCrop(input.deviceId, handle, normalizeRect(square, handle.width, handle.height));
+	if (native === null || isNativeCropMiss(native)) {
+		deps.logger.warn("root face refinement: the native square missed — dropped", {
+			tags,
+			meta: {
+				stepId: step.addonId,
+				nativeMissReason: native === null ? null : native.miss
+			}
+		});
+		return null;
+	}
+	const canvasPx = detectorInputPx(step);
+	const scale = canvasPx / 160;
+	const virtualFrameSpace = {
+		x: native.frameSpace.x,
+		y: native.frameSpace.y,
+		w: native.frameSpace.w * scale,
+		h: native.frameSpace.h * scale
+	};
+	const crop = {
+		jpeg: await buildRefineCanvas(native.jpeg, canvasPx),
+		width: canvasPx,
+		height: canvasPx,
+		frameSpace: virtualFrameSpace,
+		source: "native"
+	};
+	const nativeCropRef = {
+		handle,
+		cropFrameSpace: virtualFrameSpace
+	};
+	const detectorOnly = {
+		...step,
+		children: []
+	};
+	const found = await deps.runPipeline([detectorOnly], crop.jpeg, input.deviceId, deviceKey, nativeCropRef);
+	const face = found === null ? void 0 : bestFace(found.detections);
+	if (face === void 0) {
+		deps.logger.warn("root face refinement found no face in the square — dropped, never embedded unaligned", {
+			tags,
+			meta: {
+				stepId: step.addonId,
+				rootModelId: supplied.modelId,
+				rootScore: box.score
+			}
+		});
+		return [];
+	}
+	const chain = requested === void 0 ? step : pruneChildStepsToRequested(step, requested);
+	if (chain.children === void 0 || chain.children.length === 0) return [toDetailResult(face, step.addonId, crop)];
+	const modelId = step.modelId ?? require_default_detection_model.getStepDefinition(step.addonId).defaultModelId;
+	const embedded = await deps.runPipeline([chain], crop.jpeg, input.deviceId, deviceKey, nativeCropRef, refinedAsSupplied(face, step.addonId, modelId));
+	if (embedded === null) return [toDetailResult(face, step.addonId, crop)];
+	return embedded.detections.map((d) => toDetailResult(d, step.addonId, crop));
+}
+//#endregion
 //#region src/pipeline-runner/detail-subtree.ts
 /** Did the subtree run refuse because the camera is not attached (park lapsed)? */
 function isDetailNotAttachedRefusal(outcome) {
@@ -3388,6 +3572,43 @@ function mapBboxToFrameSpace(bbox, crop) {
 		h: bbox.height * scaleY
 	};
 }
+/**
+* Map the root's FRAME-space boxes (D730) into the crop's pixels — the inverse
+* of {@link mapBboxToFrameSpace} — clamped to the crop. A box with nothing left
+* inside the crop is dropped. `null` when no box survives.
+*/
+function suppliedRootForCrop(supplied, crop) {
+	const scaleX = crop.width / crop.frameSpace.w;
+	const scaleY = crop.height / crop.frameSpace.h;
+	const detections = [];
+	for (const box of supplied.boxes) {
+		const x1 = Math.max(0, (box.bbox.x - crop.frameSpace.x) * scaleX);
+		const y1 = Math.max(0, (box.bbox.y - crop.frameSpace.y) * scaleY);
+		const x2 = Math.min(crop.width, (box.bbox.x + box.bbox.w - crop.frameSpace.x) * scaleX);
+		const y2 = Math.min(crop.height, (box.bbox.y + box.bbox.h - crop.frameSpace.y) * scaleY);
+		if (x2 <= x1 || y2 <= y1) continue;
+		detections.push({
+			bbox: [
+				x1,
+				y1,
+				x2,
+				y2
+			],
+			score: box.score
+		});
+	}
+	const [first, ...rest] = detections;
+	if (first === void 0) return null;
+	return {
+		stepId: supplied.stepId,
+		modelId: supplied.modelId,
+		detections: [first, ...rest]
+	};
+}
+/** Whether the root's box for this step is a location to refine in (a face). */
+function refinesSuppliedStep(stepId) {
+	return (stepId === "plate-detection" || stepId === "face-detection") && require_dist.CROP_SUPPLY_SOURCES[stepId].use === "refine";
+}
 /** Base64-encode a normalized float32 embedding vector. */
 function encodeEmbeddingBase64(embedding) {
 	return Buffer.from(Float32Array.from(embedding).buffer).toString("base64");
@@ -3591,6 +3812,18 @@ async function runDetailSubtree(deps, input) {
 	}
 	const requested = input.steps;
 	const steps = requested === void 0 ? matched : matched.map((step) => pruneChildStepsToRequested(step, requested));
+	const supplied = input.supplied;
+	if (supplied !== void 0 && refinesSuppliedStep(supplied.stepId)) {
+		const details = [];
+		for (const step of matched) {
+			if (step.addonId !== supplied.stepId) continue;
+			const placement = deps.placeStep?.(input.deviceId, step);
+			const refined = await refineRootFace(deps, input, supplied, placement?.step ?? step, requested, placement?.deviceKey);
+			if (refined === null) return null;
+			details.push(...refined);
+		}
+		return { details };
+	}
 	const { crop, nativeMiss } = await resolveCrop(deps, input, deps.resolveCropConvention(input.deviceId));
 	if (!crop) {
 		deps.logger.warn("runDetailSubtree: no crop source resolved — the dispatch produced nothing", {
@@ -3619,7 +3852,18 @@ async function runDetailSubtree(deps, input) {
 	let unjudgedFaces = 0;
 	for (const step of steps) {
 		const placement = deps.placeStep?.(input.deviceId, step);
-		const result = await deps.runPipeline([placement?.step ?? step], crop.jpeg, input.deviceId, placement?.deviceKey, nativeCropRef);
+		const suppliedRoot = input.supplied !== void 0 && input.supplied.stepId === step.addonId ? suppliedRootForCrop(input.supplied, crop) : void 0;
+		if (suppliedRoot === null) {
+			deps.logger.warn("runDetailSubtree: the root-supplied boxes fall outside the crop — nothing to read", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					stepId: step.addonId,
+					parentClass: input.parent.className
+				}
+			});
+			continue;
+		}
+		const result = await deps.runPipeline([placement?.step ?? step], crop.jpeg, input.deviceId, placement?.deviceKey, nativeCropRef, ...suppliedRoot !== void 0 ? [suppliedRoot] : []);
 		if (!result) continue;
 		for (const detection of result.detections) {
 			const detail = toDetailResult(detection, step.addonId, crop);
@@ -7342,15 +7586,15 @@ function isDetailPlaneStepId(stepId) {
 * Extracted as a pure function so the unit suite can exercise the
 * derivation without instantiating the full addon.
 */
-function deriveDetailSteps(steps, plan = EMPTY_LABEL_LINK_PLAN) {
+function deriveDetailSteps(steps, plan = EMPTY_ROOT_SUPPLY_PLAN) {
 	const stepIds = /* @__PURE__ */ new Set();
 	collectEnabledStepIds(steps, stepIds);
-	const filled = filledStepIds(plan);
+	const supplied = suppliedSteps(plan);
 	const announces = [];
 	for (const stepId of stepIds) {
 		const def = tryGetStepDefinition(stepId);
 		if (!def || def.inputClasses === null) continue;
-		const filledBy = filled.get(def.id);
+		const by = supplied.get(def.id);
 		announces.push({
 			stepId: def.id,
 			inputClasses: def.inputClasses,
@@ -7358,7 +7602,10 @@ function deriveDetailSteps(steps, plan = EMPTY_LABEL_LINK_PLAN) {
 				trigger: "once",
 				maxPerTrack: 3
 			},
-			...filledBy !== void 0 ? { filledBy } : {}
+			...by !== void 0 ? {
+				filledBy: by.modelId,
+				filledAs: by.kind
+			} : {}
 		});
 	}
 	return announces;
@@ -8490,7 +8737,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		if (!ctx.api) throw new Error("runCapacityRamp: ctx.api unavailable");
 		if (this.capacityRuns.get(input.sessionId)?.status.state === "running") throw new Error(`runCapacityRamp: session '${input.sessionId}' is already running`);
 		for (const [id, entry] of this.capacityRuns) if (entry.status.state === "running") throw new Error(`runCapacityRamp: ramp '${id}' is already running on this node — one at a time, the measurement owns the node`);
-		if (input.nodeId !== void 0 && input.nodeId !== this.nodeId) throw new Error(`runCapacityRamp: driver is node-local — this runner is '${this.nodeId}', refusing nodeId '${input.nodeId}'. Frames must not cross a node boundary per call (D9).`);
+		if (input.nodeId !== void 0 && input.nodeId !== this.nodeId) throw new Error(`runCapacityRamp: driver is node-local — this runner is '${this.nodeId}', refusing nodeId '${input.nodeId}'. Frames must not cross a node boundary per call.`);
 		const nonIdle = (this.runner?.getAllCameraMetrics() ?? []).filter((m) => m.phase !== "idle");
 		const contaminated = nonIdle.length > 0;
 		if (contaminated && input.allowActiveCameras !== true) throw new Error(`runCapacityRamp: node not quiet — ${nonIdle.length} camera(s) not idle (deviceIds ${nonIdle.map((m) => m.deviceId).join(", ")}). Pause detection first (scripts/capacity/pause-restore.mjs) or pass allowActiveCameras: true to run a knowingly contaminated measurement.`);
@@ -9540,7 +9787,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const outcome = await runDetailSubtree({
 			resolveChildSteps: (deviceId, parentClassName, filter) => this.resolveDetailChildSteps(deviceId, parentClassName, filter),
 			getNativeCrop: (deviceId, handle, paddedBbox) => this.getNativeCropForDetail(deviceId, handle, paddedBbox),
-			runPipeline: (steps, imageJpeg, deviceId, deviceKey, nativeCropRef) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey, nativeCropRef),
+			runPipeline: (steps, imageJpeg, deviceId, deviceKey, nativeCropRef, suppliedRoot) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey, nativeCropRef, suppliedRoot),
 			placeStep: (deviceId, step) => this.placeDetailStepForCamera(deviceId, step),
 			resolveCropConvention: () => convention,
 			logger: this.detailSubtreeLogger(),
@@ -9675,39 +9922,42 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	customModels = new require_default_detection_model.CustomModelCatalog({ warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras) });
 	/**
-	* Per camera, the label-link plan (D715) and the announce derived from it,
+	* Per camera, the root-supply plan (D730) and the announce derived from it,
 	* keyed on the two inputs it reads: the attach tree and the custom-model
 	* snapshot (a Frigate+ root is a custom model). Recomputed when either
 	* changes identity — at most once per catalog refresh.
 	*/
-	labelLinkCache = /* @__PURE__ */ new Map();
-	/** The camera's label-link plan; logs once per change of what is filled. */
-	labelLinkPlanFor(deviceId, steps) {
+	rootSupplyCache = /* @__PURE__ */ new Map();
+	/**
+	* The camera's root-supply plan. One INFO per (camera, step) when a step
+	* BECOMES supplied by the root — a COCO root now stops dispatching the
+	* animal and vehicle classifiers by default, and that must be readable per
+	* camera rather than inferred from a missing dispatch (D391).
+	*/
+	rootSupplyPlanFor(deviceId, steps) {
 		const byStep = this.customModels.current();
-		const cached = this.labelLinkCache.get(deviceId);
+		const cached = this.rootSupplyCache.get(deviceId);
 		if (cached !== void 0 && cached.steps === steps && cached.byStep === byStep) return cached.plan;
-		const plan = planLabelLinks(steps, (stepId, modelId) => this.customModels.stepDefinition(stepId)?.models.find((m) => m.id === modelId));
+		const plan = planRootSupplies(steps, (stepId, modelId) => this.customModels.stepDefinition(stepId)?.models.find((m) => m.id === modelId));
 		const announces = deriveDetailSteps(steps, plan);
-		this.labelLinkCache.set(deviceId, {
+		this.rootSupplyCache.set(deviceId, {
 			steps,
 			byStep,
 			plan,
 			announces
 		});
-		const describe = (p) => p === void 0 ? "" : [...p.decisions].map(([id, d]) => `${id}:${d.skip ? "skip" : d.authoritative ? "sole" : "fallback"}`).join(",");
-		if (describe(cached?.plan) !== describe(plan) && plan.decisions.size > 0) this.ctxIfReady?.logger.info("label link: the root model fills pipeline steps", {
-			tags: { deviceId },
-			meta: {
-				rootModelId: plan.rootModelId ?? null,
-				steps: [...plan.decisions].map(([stepId, d]) => ({
+		for (const stepId of newlySuppliedSteps(cached?.plan, plan)) {
+			const state = plan.states.get(stepId);
+			this.ctxIfReady?.logger.info("root model supplies a pipeline step — the step is not dispatched", {
+				tags: { deviceId },
+				meta: {
 					stepId,
-					policy: d.policy,
-					authoritative: d.authoritative,
-					skip: d.skip,
-					openGaps: d.openGaps
-				}))
-			}
-		});
+					rootModelId: plan.rootModelId ?? null,
+					kind: state?.supply?.kind ?? null,
+					uncovered: state?.supply?.kind === "label" ? state.supply.uncovered : []
+				}
+			});
+		}
 		return plan;
 	}
 	cropConvention = new CropConventionSource({ logger: {
@@ -9975,7 +10225,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		};
 	}
 	/** Real `runPipeline` dep: node-local `pipelineExecutor.runPipeline` on the `'full'` plane. */
-	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey, nativeCropRef) {
+	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey, nativeCropRef, suppliedRoot) {
 		const api = this.ctxIfReady?.api;
 		if (!api) return null;
 		const detailDeviceKey = stepDeviceKey ?? this.attached.get(deviceId)?.config?.deviceKey ?? this.freshParkedDetail(deviceId)?.deviceKey;
@@ -9986,7 +10236,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				deviceId,
 				...detailDeviceKey ? { deviceKey: detailDeviceKey } : {},
 				plane: "full",
-				...nativeCropRef ? { nativeCropRef } : {}
+				...nativeCropRef ? { nativeCropRef } : {},
+				...suppliedRoot ? { suppliedRoot } : {}
 			});
 		} catch (err) {
 			this.ctxIfReady?.logger.warn("runDetailSubtree: runPipeline failed", {
@@ -10105,7 +10356,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.lastDecodeUnexpectedEndAt.delete(deviceId);
 		this.packageGovernor.forget(deviceId);
 		this.packageGateSkips.delete(deviceId);
-		this.labelLinkCache.delete(deviceId);
+		this.rootSupplyCache.delete(deviceId);
 		this.packageZoneUnionByDevice.delete(deviceId);
 		this.packageZoneUnionAt.delete(deviceId);
 		this.lastMotionNearPackageZone.delete(deviceId);
@@ -10821,8 +11072,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			return null;
 		}
 		if (steps.length === 0) return null;
-		const labelLinkPlan = this.labelLinkPlanFor(deviceId, steps);
-		const packageFill = applyPackageFill(steps, labelLinkPlan);
+		const rootSupplyPlan = this.rootSupplyPlanFor(deviceId, steps);
+		const packageFill = applyPackageFill(steps, rootSupplyPlan);
 		let dispatchSteps = packageFill.steps;
 		if (dispatchSteps.some((s) => s.addonId === "package-detection" && s.enabled !== false)) {
 			this.refreshPackageZoneUnion(deviceId);
@@ -10911,7 +11162,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			return null;
 		}
 		if (result === null) return null;
-		const looked = withPackageLook(applyLabelLinkAuthority(result, labelLinkPlan), dispatchSteps, packageFill.filledByRoot);
+		const looked = withPackageLook(applyRootSupplyAuthority(result, rootSupplyPlan), dispatchSteps, packageFill.filledByRoot);
 		return this.recoverSmallSubjects(deviceId, frame, looked, dispatchSteps, camConfig?.deviceKey);
 	}
 	/**
@@ -11608,7 +11859,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	emitInferenceResult(deviceId, frame, result, handle, source, occasion) {
 		if (!this.ctx?.eventBus) return;
 		const capturedAt = frame.capturedAt;
-		const detailSteps = this.labelLinkCache.get(deviceId)?.announces ?? this.attached.get(deviceId)?.detailSteps;
+		const detailSteps = this.rootSupplyCache.get(deviceId)?.announces ?? this.attached.get(deviceId)?.detailSteps;
 		const payload = {
 			deviceId,
 			frame: result,