@camstack/addon-pipeline 1.2.329 → 1.2.330

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { An as hydrateSchema, Bn as array, Dt as loadContributionCapability, En as createEvent, F as PoolMemoryWatchdog, Fn as parseJsonUnknown, Ht as pipelineExecutorCapability, K as YAMNET_TO_MACRO, Kn as object, Lt as overlayClusterStepSettings, Pn as nodePin, Rn as sleep, Sn as BaseAddon, St as hfModelUrl, T as FILLABLE_STEP_MACRO, Tt as linkedLabelStepId, Xn as union, Yn as string, Yt as resolveClusterStepModelId, Zn as EventCategory, at as defaultDeviceFor$1, b as DEVICE_BACKEND_TO_FORMAT, bn as errMsg, cn as supportedRuntimes$1, d as CLUSTER_MODEL_SCOPED_STEPS, en as resolvePoolMemoryPolicy, ft as enumerateInferenceDevices, h as DEFAULT_CLUSTER_STEP_SETTINGS, lt as detectionPipelineCapability, n as APPLE_SA_TO_MACRO, nn as runtimeDevices$1, pt as evaluateZoneRules, rn as stepModelRunsOnFormat, zt as pickClusterStepSettings } from "../dist-0HoA3wAi.mjs";
-import { s as readProcessCost } from "../node-HOMWRPzW.mjs";
-import { _ as getStep, a as buildSubtreeCanRun, b as landmarkPrecisionVerdict, c as macroGateVerdict, g as getDefaultModelForFormat, h as ALL_STEPS, i as mergeCustomModels, m as ALL_PIPELINE_STEPS, n as resolveDefaultDetectionModel, r as CustomModelCatalog, u as localFrameRegistry, v as getStepDefinition, x as resolveModelDefaultConfidence, y as resolveModelForFormat } from "../default-detection-model-j0nBpRoB.mjs";
+import { $n as union, Cn as errMsg, Dt as linkedLabelStepId, G as YAMNET_TO_MACRO, Ln as nodePin, N as PoolMemoryWatchdog, Nn as hydrateSchema, O as LABEL_SUPPLY_MACRO, Qn as string, Rn as parseJsonUnknown, Tn as BaseAddon, Un as array, Vn as sleep, Vt as pickClusterStepSettings, Wt as pipelineExecutorCapability, Yn as object, Zt as resolveClusterStepModelId, an as runtimeDevices$1, b as DEVICE_BACKEND_TO_FORMAT, d as CLUSTER_MODEL_SCOPED_STEPS, dn as supportedRuntimes$1, dt as detectionPipelineCapability, er as EventCategory, g as DEFAULT_CLUSTER_STEP_SETTINGS, ht as evaluateZoneRules, in as rootSuppliesOf, kn as createEvent, kt as loadContributionCapability, mt as enumerateInferenceDevices, n as APPLE_SA_TO_MACRO, nt as containingParentIndex, on as stepModelRunsOnFormat, ot as defaultDeviceFor$1, tn as resolvePoolMemoryPolicy, wt as hfModelUrl, zt as overlayClusterStepSettings } from "../dist-CuPEyZY2.mjs";
+import { s as readProcessCost } from "../node-USq5jYwq.mjs";
+import { _ as getStep, a as buildSubtreeCanRun, b as landmarkPrecisionVerdict, c as macroGateVerdict, g as getDefaultModelForFormat, h as ALL_STEPS, i as mergeCustomModels, m as ALL_PIPELINE_STEPS, n as resolveDefaultDetectionModel, r as CustomModelCatalog, u as localFrameRegistry, v as getStepDefinition, x as resolveModelDefaultConfidence, y as resolveModelForFormat } from "../default-detection-model-CPDT_eFT.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DuF8pa2w.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-07XYts8V.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -752,7 +752,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,
@@ -5776,6 +5776,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).
 */
@@ -5805,6 +5825,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 = 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
@@ -6361,6 +6454,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 } : {}
@@ -6462,33 +6556,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 (FILLABLE_STEP_MACRO[fill.stepId] !== macroClass) continue;
-		const effect = fill.labelToEffect[rawClass];
+	for (const supply of supplies) {
+		if (supply.kind !== "label") continue;
+		if (LABEL_SUPPLY_MACRO[supply.stepId] !== macroClass) continue;
+		const effect = supply.labelToEffect[rawClass];
 		if (effect === void 0 || effect === macroClass) continue;
-		const tier = getStepDefinition(fill.stepId).labelTier;
+		const tier = getStepDefinition(supply.stepId).labelTier;
 		out.push({
 			label: effect,
 			score: 0,
 			...tier !== void 0 ? { tier } : {},
-			stepId: linkedLabelStepId(fill.stepId),
+			stepId: linkedLabelStepId(supply.stepId),
 			modelId
 		});
 	}
@@ -6717,10 +6813,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);
@@ -6742,8 +6847,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) {
@@ -6764,7 +6894,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({
@@ -6846,6 +6976,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 {
@@ -7113,7 +7258,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;
@@ -7136,7 +7282,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"
 								}
 							});
@@ -7334,9 +7481,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 = 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
@@ -9482,7 +9638,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 {
@@ -11043,7 +11200,7 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 				...m.legacy !== void 0 ? { legacy: m.legacy } : {},
 				provider: m.provider ?? "camstack",
 				defaultConfidence: resolveModelDefaultConfidence(step, m),
-				...m.fillsClassifierEffects !== void 0 ? { fillsClassifierEffects: m.fillsClassifierEffects } : {}
+				...modelSuppliesField(step, m)
 			})),
 			defaultModelId: step.defaultModelId,
 			...step.defaultModelIdByFormat ? { defaultModelIdByFormat: { ...step.defaultModelIdByFormat } } : {},
@@ -11179,6 +11336,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 = 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).
 *
@@ -11427,7 +11593,7 @@ var DetectionPipelineAddon = class extends 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: "",
@@ -11471,7 +11637,7 @@ var DetectionPipelineAddon = class extends 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,