@camstack/addon-pipeline 1.2.329 → 1.2.330

package/dist/detection-pipeline/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-BlIWhjnu.js");
-const require_node = require("../node-BPpVMnZy.js");
-const require_default_detection_model = require("../default-detection-model-ChH7Y219.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_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
-const require_process_memory = require("../process-memory-BW06vOIQ.js");
+const require_process_memory = require("../process-memory-o4LFWbBN.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -759,7 +759,7 @@ var POOL_MODEL_LOAD_BOUNDS = {
 		hardMs: 6e5,
 		why: "A cold iGPU compile of the WHOLE model set measured ~25 s on the N100; one model is 1-3 s (YuNet 1.4 s on a fresh worker, 2026-09-26). 120 s is ~5x the worst measured set. No evidence of a legitimate compile past it; the hard bound gives one 5x more before the worker is recycled.",
 		gilMayBeHeldDuringCompile: false,
-		gilWhy: "The OpenVINO Python binding is believed to release the GIL around compile_model (gil_scoped_release). Not measured on the hub; the passive recipe in D653 checks it."
+		gilWhy: "The OpenVINO Python binding is believed to release the GIL around compile_model (gil_scoped_release). Not yet measured on this node."
 	},
 	coreml: {
 		softMs: 3e5,
@@ -5783,6 +5783,26 @@ var PLATE_OCR_CROP_POLICIES = {
 	}
 };
 /**
+* The margin around a plate box drawn by the ROOT model (D730) — a Frigate+
+* `license_plate` read in place of `plate-detection`'s own box.
+*
+* The margin is a property of the box's detector (see above), and this
+* detector's boxes have never been measured against the plate readers: 0.15 is
+* the value that served a TIGHT detector box (the deleted `yolov8n-plate`,
+* 7/7 Kia reads at 0.13–0.16), on the assumption that Frigate+ boxes are
+* tight as well. It is uncalibrated and needs measuring on a ground-truth set
+* of root-supplied plates before it is trusted; until then it applies to every
+* reader alike, replacing the reader's own detector-specific margin.
+*/
+var ROOT_SUPPLIED_PLATE_MARGIN_FRACTION = .15;
+/**
+* The margin a reader cuts around its plate box: the reader's own, unless the
+* box was drawn by the root model.
+*/
+function plateOcrMarginFraction(policy, boxFromRoot) {
+	return boxFromRoot ? ROOT_SUPPLIED_PLATE_MARGIN_FRACTION : policy.marginFraction;
+}
+/**
 * The crop policy for a step child, or `null` when the child is not a plate
 * reader at all (a face embedder, a classifier — nothing here applies to them).
 */
@@ -5812,6 +5832,79 @@ function expandBbox(bbox, marginFraction, imageWidth, imageHeight) {
 	];
 }
 //#endregion
+//#region src/detection-pipeline/pipeline/root-child-boxes.ts
+/**
+* Root child boxes (D730) — a root model's `license_plate` / `face` box made
+* into a DETAIL of the vehicle / person that contains it.
+*
+* The labels are deliberately absent from the root's classMap, so they never
+* make a first-level detection and therefore never a track (D683). When the
+* root declares a CROP supply for them, the executor keeps the boxes aside
+* instead of discarding them, and once the frame's first-level detections are
+* final this attaches each to its containing parent (`containingParentIndex`).
+* Whether the camera USES them is the runner's decision
+* (`pipeline-runner/root-supply.ts`); a box nothing contains is discarded.
+*
+* Pure.
+*/
+/** The crop supply a raw root class belongs to, if the root declares one. */
+function cropSupplyForLabel(supplies, rawClass) {
+	for (const supply of supplies ?? []) if (supply.kind === "crop" && supply.rootLabels.includes(rawClass)) return supply;
+}
+function toBox(b) {
+	return {
+		x: b[0],
+		y: b[1],
+		w: b[2] - b[0],
+		h: b[3] - b[1]
+	};
+}
+/**
+* Attach each candidate to the smallest first-level parent of its supply's
+* macro that contains it. Never mutates the parents.
+*/
+function attachRootChildBoxes(candidates, parents, modelId, idGen) {
+	const details = [];
+	const uncontained = [];
+	for (const candidate of candidates) {
+		const eligible = parents.filter((p) => p.kind === "first-level" && p.macroClass === candidate.supply.parentMacro);
+		const index = require_dist.containingParentIndex(toBox(candidate.bbox), eligible.map((p) => toBox(p.bbox)));
+		const parent = index >= 0 ? eligible[index] : void 0;
+		if (parent === void 0) {
+			uncontained.push(candidate);
+			continue;
+		}
+		const stepId = candidate.supply.stepId;
+		details.push({
+			id: idGen.next(),
+			kind: "detail",
+			macroClass: candidate.supply.childClass,
+			originalClass: candidate.rawClass,
+			score: candidate.score,
+			bbox: [
+				candidate.bbox[0],
+				candidate.bbox[1],
+				candidate.bbox[2],
+				candidate.bbox[3]
+			],
+			parentId: parent.id,
+			rootSupplied: {
+				stepId,
+				modelId
+			},
+			ownLabels: [],
+			alternateLabels: {},
+			stepLatencyMs: {},
+			modelIds: { [stepId]: modelId },
+			extractMode: "full-frame"
+		});
+	}
+	return {
+		details,
+		uncontained
+	};
+}
+//#endregion
 //#region src/detection-pipeline/pipeline/plate-warp.ts
 /**
 * Plate-crop WARP — perspective rectification of a licence-plate ROI to a
@@ -6368,6 +6461,7 @@ function buildFrameResult(input) {
 			} : {},
 			labels,
 			...m.parentId !== void 0 ? { parentId: m.parentId } : {},
+			...m.rootSupplied !== void 0 ? { rootSupplied: m.rootSupplied } : {},
 			...embedding !== void 0 ? {
 				embedding,
 				...embeddingModelId !== void 0 ? { embeddingModelId } : {}
@@ -6469,33 +6563,35 @@ function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
 //#endregion
 //#region src/detection-pipeline/pipeline/linked-label.ts
 /**
-* The detector's linked label (D715): when the model that RAN declares it
-* fills a step, a detection whose raw class names that step's effect carries
-* the effect as a `ScoredLabel` attributed to `detector-link:<stepId>` — in
-* the step's own vocabulary and tier, so tier 1 means one thing whichever
+* The detector's linked label (D715, D730): when the model that RAN declares a
+* LABEL supply for a step, a detection whose raw class names that step's effect
+* carries the effect as a `ScoredLabel` attributed to `detector-link:<stepId>`
+* — in the step's own vocabulary and tier, so tier 1 means one thing whichever
 * writer produced it.
 *
 * Written at score 0 here, always: the executor cannot see the camera's whole
 * step tree (a detail step placed on another pool is pruned from the dispatch),
-* so it cannot know who the writer is. The runner, which holds the attach
-* config, raises the score to the detection's own when the detector is
-* authoritative (`pipeline-runner/label-link.ts`). Score 0 is the fallback any
-* scored answer of the step outranks.
+* so it cannot know whether the camera USES the supply. The runner, which holds
+* the attach config, decides with `resolveRootSupply` (`pipeline-runner/root-supply.ts`):
+* effective ⇒ the label is raised to the detection's score, or dropped when the
+* step's class list switched it off; otherwise it stays the score-0 fallback
+* any scored answer of the step outranks.
 */
 /** The linked labels one mapped root detection carries. Pure. */
-function linkedLabelsFor(fills, rawClass, macroClass, modelId) {
-	if (fills === void 0 || fills.length === 0) return [];
+function linkedLabelsFor(supplies, rawClass, macroClass, modelId) {
+	if (supplies === void 0 || supplies.length === 0) return [];
 	const out = [];
-	for (const fill of fills) {
-		if (require_dist.FILLABLE_STEP_MACRO[fill.stepId] !== macroClass) continue;
-		const effect = fill.labelToEffect[rawClass];
+	for (const supply of supplies) {
+		if (supply.kind !== "label") continue;
+		if (require_dist.LABEL_SUPPLY_MACRO[supply.stepId] !== macroClass) continue;
+		const effect = supply.labelToEffect[rawClass];
 		if (effect === void 0 || effect === macroClass) continue;
-		const tier = require_default_detection_model.getStepDefinition(fill.stepId).labelTier;
+		const tier = require_default_detection_model.getStepDefinition(supply.stepId).labelTier;
 		out.push({
 			label: effect,
 			score: 0,
 			...tier !== void 0 ? { tier } : {},
-			stepId: require_dist.linkedLabelStepId(fill.stepId),
+			stepId: require_dist.linkedLabelStepId(supply.stepId),
 			modelId
 		});
 	}
@@ -6724,10 +6820,19 @@ var PipelineExecutor = class {
 			const rootView = rootInputViewProvider ? await rootInputViewProvider(rootStep, rootCrop) : null;
 			const cropPrep = !rootView && rootCrop !== void 0 ? await this.prepareCropZoneInput(rootCrop, fullFrameJpegProvider, imageWidth, imageHeight, deviceId) : null;
 			const rootStart = Date.now();
-			const rawRootOutput = await this.executeStep(rootStep, rootView?.input ?? cropPrep?.input ?? withInferenceDeviceId(rootInput, deviceId), rootView?.width ?? cropPrep?.width ?? imageWidth, rootView?.height ?? cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
+			const supplied = runOpts?.suppliedRoot?.stepId === rootStep.stepId ? runOpts.suppliedRoot : void 0;
+			const rawRootOutput = supplied ? {
+				kind: "detections",
+				detections: supplied.detections.map((d) => ({
+					class: rootStep.definition.outputClasses[0] ?? rootStep.stepId,
+					score: d.score,
+					bbox: d.bbox,
+					...d.landmarks !== void 0 ? { landmarks: d.landmarks } : {}
+				}))
+			} : await this.executeStep(rootStep, rootView?.input ?? cropPrep?.input ?? withInferenceDeviceId(rootInput, deviceId), rootView?.width ?? cropPrep?.width ?? imageWidth, rootView?.height ?? cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
 			const rootMs = Date.now() - rootStart;
 			if (rawRootOutput === null) continue;
-			const rootOutput = rootView && rawRootOutput.kind === "detections" ? reprojectViewDetections(rawRootOutput, rootView.geometry) : cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
+			const rootOutput = supplied ? rawRootOutput : rootView && rawRootOutput.kind === "detections" ? reprojectViewDetections(rawRootOutput, rootView.geometry) : cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
 			if (rootOutput.kind !== "detections") {
 				if (isEnrichmentOutput(rootOutput)) {
 					const mutable = this.synthesizeRootDetection(rootOutput, rootStep, idGen, rootMs, imageWidth, imageHeight);
@@ -6749,8 +6854,33 @@ var PipelineExecutor = class {
 				}
 				continue;
 			}
+			const rootChildCandidates = [];
+			const firstLevelStart = firstLevel.length;
 			for (const det of rootOutput.detections) {
-				const mutable = toMutableRootDetection(det, rootStep, idGen, rootMs);
+				const cropSupply = cropSupplyForLabel(rootStep.rootSupplies, det.class);
+				if (cropSupply !== void 0) {
+					rootChildCandidates.push({
+						rawClass: det.class,
+						score: det.score,
+						bbox: [
+							det.bbox[0],
+							det.bbox[1],
+							det.bbox[2],
+							det.bbox[3]
+						],
+						supply: cropSupply
+					});
+					continue;
+				}
+				const seeded = toMutableRootDetection(det, rootStep, idGen, rootMs);
+				const mutable = supplied ? {
+					...seeded,
+					rootSupplied: {
+						stepId: rootStep.stepId,
+						modelId: supplied.modelId
+					},
+					modelIds: { [rootStep.stepId]: supplied.modelId }
+				} : seeded;
 				if (rootStep.effectiveClassMap) {
 					const mapped = rootStep.effectiveClassMap.mapping[det.class];
 					if (mapped) {
@@ -6771,7 +6901,7 @@ var PipelineExecutor = class {
 						continue;
 					}
 				}
-				for (const linked of linkedLabelsFor(rootStep.fillsClassifierEffects, det.class, mutable.macroClass, rootStep.modelId)) mutable.ownLabels.push(linked);
+				for (const linked of linkedLabelsFor(rootStep.rootSupplies, det.class, mutable.macroClass, rootStep.modelId)) mutable.ownLabels.push(linked);
 				const filterVerdict = this.macroFilterVerdict(mutable.macroClass, mutable.score, rootStep.settings);
 				if (filterVerdict !== "pass") {
 					(discarded ??= []).push({
@@ -6853,6 +6983,21 @@ var PipelineExecutor = class {
 				}
 				firstLevel.push(mutable);
 			}
+			if (rootChildCandidates.length > 0) {
+				const attached = attachRootChildBoxes(rootChildCandidates, firstLevel.slice(firstLevelStart), rootStep.modelId, idGen);
+				details.push(...attached.details);
+				for (const c of attached.uncontained) (discarded ??= []).push({
+					bbox: [
+						c.bbox[0],
+						c.bbox[1],
+						c.bbox[2],
+						c.bbox[3]
+					],
+					macroClass: c.supply.childClass,
+					score: c.score,
+					reason: "class-filter"
+				});
+			}
 		}
 		const totalMs = Date.now() - startMs;
 		return {
@@ -7120,7 +7265,8 @@ var PipelineExecutor = class {
 					}
 				} else {
 					const cropPolicy = resolvePlateOcrCropPolicy(resolveEffectivePostprocessor(child.definition, child.modelId));
-					const cropBbox = cropPolicy ? expandBbox(parentDetection.bbox, cropPolicy.marginFraction, imageWidth, imageHeight) : parentDetection.bbox;
+					const marginFraction = cropPolicy ? plateOcrMarginFraction(cropPolicy, parentDetection.rootSupplied !== void 0) : 0;
+					const cropBbox = cropPolicy ? expandBbox(parentDetection.bbox, marginFraction, imageWidth, imageHeight) : parentDetection.bbox;
 					const nativeChild = nativeCropProvider && child.children.length === 0 ? await nativeChildCrop(nativeCropProvider, cropBbox, imageWidth, imageHeight, NATIVE_CHILD_CROP_MAX_WIDTH) : null;
 					if (nativeChild) {
 						cropJpegBuf = nativeChild.jpeg;
@@ -7143,7 +7289,8 @@ var PipelineExecutor = class {
 									plateLongSidePx: Math.round(plateLongSidePx),
 									plateShortSidePx: Math.round(Math.min(cropW, cropH)),
 									minPlateLongSidePx: cropPolicy.minLongSidePx,
-									marginFraction: cropPolicy.marginFraction,
+									marginFraction,
+									boxFrom: parentDetection.rootSupplied !== void 0 ? "root-model" : "step",
 									source: nativeChild ? "native" : "detection-tile"
 								}
 							});
@@ -7341,9 +7488,18 @@ function buildNode(step, getEngine, resolveModel, onMissingVariant, resolved) {
 		children,
 		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {},
 		...effectiveClassMap !== void 0 ? { effectiveClassMap } : {},
-		...modelEntry?.fillsClassifierEffects !== void 0 ? { fillsClassifierEffects: modelEntry.fillsClassifierEffects } : {}
+		...rootSuppliesField(definition, modelEntry)
 	};
 }
+/** A root step's supplies, omitted when it declares none (and for every child step). */
+function rootSuppliesField(definition, modelEntry) {
+	if (definition.inputClasses !== null) return {};
+	const supplies = require_dist.rootSuppliesOf(modelEntry, {
+		labels: definition.labels ?? [],
+		...definition.classMap !== void 0 ? { classMap: definition.classMap } : {}
+	});
+	return supplies.length > 0 ? { rootSupplies: supplies } : {};
+}
 /**
 * Walk the step's declared `getConfigSchema()` and collect every field
 * with a primitive `default` value into a plain record. Group fields
@@ -9489,7 +9645,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			execution = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
 				traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
 				plane: input.plane,
-				occasion: input.replay === true ? "replay" : "live"
+				occasion: input.replay === true ? "replay" : "live",
+				...input.suppliedRoot !== void 0 ? { suppliedRoot: input.suppliedRoot } : {}
 			}, nativeCropProvider, cropZoneBbox, rootInputViewProvider);
 			executionSucceeded = true;
 		} finally {
@@ -11050,7 +11207,7 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 				...m.legacy !== void 0 ? { legacy: m.legacy } : {},
 				provider: m.provider ?? "camstack",
 				defaultConfidence: require_default_detection_model.resolveModelDefaultConfidence(step, m),
-				...m.fillsClassifierEffects !== void 0 ? { fillsClassifierEffects: m.fillsClassifierEffects } : {}
+				...modelSuppliesField(step, m)
 			})),
 			defaultModelId: step.defaultModelId,
 			...step.defaultModelIdByFormat ? { defaultModelIdByFormat: { ...step.defaultModelIdByFormat } } : {},
@@ -11186,6 +11343,15 @@ function isDetailPlaneStep(addonId) {
 		return false;
 	}
 }
+/** A root model's supplies for the schema, omitted when it supplies nothing. */
+function modelSuppliesField(step, model) {
+	if (step.inputClasses !== null) return {};
+	const supplies = require_dist.rootSuppliesOf(model, {
+		labels: step.labels ?? [],
+		...step.classMap !== void 0 ? { classMap: step.classMap } : {}
+	});
+	return supplies.length > 0 ? { suppliesSteps: supplies } : {};
+}
 /**
 * What a dispatch runs after its per-step loads (D657).
 *
@@ -11434,7 +11600,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 					type: "select",
 					key: "batchMode",
 					label: "Batch dispatch mode",
-					description: "How the Python pool GROUPS predict requests — it never changes a model's compiled batch SHAPE, which is derived from (engine, device) at load and is not configurable (D202). `none` = one call per frame. `window` = per-model accumulator coalesces concurrent calls within Window (ms). Auto uses the matrix-sweep default for the current backend. Applies to THIS node only.",
+					description: "How the Python pool GROUPS predict requests — it never changes a model's compiled batch SHAPE, which is derived from (engine, device) at load and is not configurable. `none` = one call per frame. `window` = per-model accumulator coalesces concurrent calls within Window (ms). Auto uses the matrix-sweep default for the current backend. Applies to THIS node only.",
 					options: [
 						{
 							value: "",
@@ -11478,7 +11644,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 					type: "slider",
 					key: "maxBatchSize",
 					label: "Max batch size",
-					description: "Cap on how many requests are GROUPED into one batched predict call. Not the model's compiled batch shape — that is derived from (engine, device) at load and is not configurable (D202); a stacked tensor is only ever built for an export that declares a flexible batch axis itself. Auto = backend default. Applies to THIS node only.",
+					description: "Cap on how many requests are GROUPED into one batched predict call. Not the model's compiled batch shape — that is derived from (engine, device) at load and is not configurable; a stacked tensor is only ever built for an export that declares a flexible batch axis itself. Auto = backend default. Applies to THIS node only.",
 					min: 1,
 					max: 16,
 					step: 1,