@camstack/addon-pipeline 1.2.333 → 1.2.335

package/dist/{default-detection-model-Biwf5-ML.js → custom-model-catalog-CL-xJa8w.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DJV7Z6Bb.js");
+const require_dist = require("./dist-C5DlS_lW.js");
 const require_worker_protocol = require("./worker-protocol-C-G8qmye.js");
 let node_crypto = require("node:crypto");
 //#region src/detection-pipeline/registry/effective-confidence.ts
@@ -290,7 +290,7 @@ var ovFormat = (url, sizeMB) => {
 var ovPrecisionVariant = (baseId, ovDir, baseName, precision, sizeMB, legacy = false) => ({
 	id: `${baseId}-${precision}`,
 	name: `${baseName} (${precision.toUpperCase()})`,
-	description: `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
+	description: precision === "int8" ? `${baseName} — OpenVINO INT8 variant for Intel iGPU/CPU; scale by hardware. On the Intel NPU it loses recall — use the base model there` : `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
 	inputSize: {
 		width: 640,
 		height: 640
@@ -326,9 +326,11 @@ var YOLOV9_TIER_NAME = {
 };
 /**
 * The Ultralytics YOLOv9 family (COCO-pretrained Ultralytics weights,
-* re-exported by CamStack — not trained by us) — the NPU-detection line. Unlike
-* yolo26 (whose arch the Intel NPU rejects → 0 frames), yolov9 COMPILES AND RUNS
-* on the Intel NPU ("AI Boost"). Empirically: the yolov9t-320-int8 export = ~298 fps on the
+* re-exported by CamStack — not trained by us) — the default NPU-detection line.
+* It runs on the Intel NPU ("AI Boost"), and its INT8 builds are as accurate
+* there as on the CPU. YOLO26 runs on the NPU too since OpenVINO 2025.4
+* (measured 2026-10-07): its base IRs match the CPU, its INT8 IRs lose recall
+* there (see `yolo26Reduced`). Empirically: the yolov9t-320-int8 export = ~298 fps on the
 * NPU vs yolo26n = 103 on the iGPU (~2.9×). t/s/m/c × {320,640}; each size ships
 * a base entry (onnx + coreml + openvino **fp16**) + an OpenVINO **int8** entry
 * (the NPU/iGPU-optimal config). CoreML (fp16) runs on the Mac ANE — the
@@ -344,7 +346,7 @@ var yolov9Reduced = (tier, res, sizes) => {
 			resolution: res
 		},
 		name: `YOLOv9 ${name} @${res}`,
-		description: `YOLOv9 ${name} @${res}×${res} (Ultralytics) — OpenVINO fp16, runs on Intel NPU + iGPU (NPU-compatible; yolo26 is not).`,
+		description: `YOLOv9 ${name} @${res}×${res} (Ultralytics) — OpenVINO fp16, runs on Intel NPU + iGPU.`,
 		inputSize: {
 			width: res,
 			height: res
@@ -394,6 +396,11 @@ var yolov9Reduced = (tier, res, sizes) => {
 * grouped under `{family, tier, resolution}`, plus an OpenVINO INT8 entry (best
 * on Intel/N100) grouped with `precision:'int8'`. The grouped selector surfaces
 * `resolution` as a variant axis alongside precision.
+*
+* Intel NPU (OpenVINO 2025.4, measured 2026-10-07): every YOLO26 IR compiles
+* and runs. The base IRs are as accurate as the CPU; the INT8 IRs lose recall
+* there (`yolo26s-int8` 0.58 on the NPU vs 0.70 on CPU/iGPU, `yolo26m-int8`
+* 0.78 vs 0.83), so on an NPU the base IR is the one to run.
 */
 var yolo26Reduced = (tier, res, sizes) => {
 	const name = YOLO26_TIER_NAME[tier] ?? tier.toUpperCase();
@@ -436,7 +443,7 @@ var yolo26Reduced = (tier, res, sizes) => {
 			resolution: res
 		},
 		name: `YOLO26 ${name} @${res} (INT8)`,
-		description: `YOLO26 ${name} @${res} — OpenVINO INT8 for Intel iGPU/CPU; the N100's fastest config`,
+		description: `YOLO26 ${name} @${res} — OpenVINO INT8 for Intel iGPU/CPU; the N100's fastest config. On the Intel NPU it loses recall — use the base model there`,
 		inputSize: {
 			width: res,
 			height: res
@@ -447,7 +454,11 @@ var yolo26Reduced = (tier, res, sizes) => {
 		formats: { openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}-int8.xml`), sizes.ovInt8) }
 	}];
 };
-var OBJECT_DETECTION_MODELS = [
+/** Variant family of the YOLO26 builds with an instance-segmentation head. */
+var YOLO26_SEG_FAMILY = "yolo26-seg";
+/** What choosing a seg build as the root means, in the catalog's own words. */
+var YOLO26_SEG_ROOT_NOTE = "As the root model it detects like YOLO26 and also supplies the Segmentation step its masks (detection + masks, slightly heavier).";
+var OBJECT_DETECTION_MODEL_ENTRIES = [
 	{
 		id: "yolo26n",
 		license: ULTRALYTICS_AGPL,
@@ -617,6 +628,102 @@ var OBJECT_DETECTION_MODELS = [
 			runtimes: ["python"]
 		} }
 	},
+	{
+		id: "yolo26n-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "n",
+			resolution: 640
+		},
+		name: "YOLO26-seg Nano",
+		description: `YOLO26 Nano with its instance-segmentation head — ultra-lightweight. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
+				sizeMB: 11
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
+				sizeMB: 6,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
+		}
+	},
+	{
+		id: "yolo26s-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "s",
+			resolution: 640
+		},
+		name: "YOLO26-seg Small",
+		description: `YOLO26 Small with its instance-segmentation head — balanced. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
+				sizeMB: 40
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
+				sizeMB: 20,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
+		}
+	},
+	{
+		id: "yolo26m-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "m",
+			resolution: 640
+		},
+		name: "YOLO26-seg Medium",
+		description: `YOLO26 Medium with its instance-segmentation head — high accuracy. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
+				sizeMB: 90
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
+				sizeMB: 45,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
+		}
+	},
 	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5, true),
 	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
 	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19, true),
@@ -724,6 +831,254 @@ var OBJECT_DETECTION_MODELS = [
 	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112, true),
 	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56, true)
 ];
+/**
+* The per-class confidence-floor DEFAULTS of each object-detection model
+* (D738), keyed by model id. Applied onto the catalog entries below as
+* `defaultClassFloors`; this is the ONLY place a model's floor is written. A
+* model absent here runs at the step slider's global default
+* (`ObjectDetectionStep.getConfigSchema`: person 0.65, vehicle 0.50, animal
+* 0.50).
+*
+* Measured 2026-10-07 (`docs/benchmarks/model-floors.json`, which also holds
+* precision/recall per class): the floor is the lowest score at which the model
+* makes no more false positives than the production root (`yolov9m-320-int8` at
+* 0.65 / 0.50 / 0.50) on the same 409 hub frames, against an ensemble
+* pseudo-ground-truth, rounded to 0.05, minimum 0.25. Floors carry about
+* +/-0.05-0.10 of noise. Where a floor hinges on a single high-score false
+* positive, the next-lower value the measurement gives is used instead (marked
+* below). A re-measurement replaces the JSON and these rows together; a spec
+* holds them equal.
+*
+* `package` is not calibrated (7 objects in the set) and stays at its global
+* default. Every catalog model NOT listed here (the 256 builds, yolo26 l/x,
+* the seg builds, the fp16 legacy IRs) is untuned and runs at the global
+* defaults.
+*/
+var OBJECT_DETECTION_CLASS_FLOORS = {
+	"ssd-mobilenet-v2-coco-edgetpu": {
+		person: .6,
+		vehicle: .35,
+		animal: .4
+	},
+	yolo26m: {
+		person: .4,
+		vehicle: .25,
+		animal: .3
+	},
+	"yolo26m-320": {
+		person: .7,
+		vehicle: .3,
+		animal: .4
+	},
+	"yolo26m-320-int8": {
+		person: .6,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolo26m-int8": {
+		person: .4,
+		vehicle: .35,
+		animal: .45
+	},
+	yolo26n: {
+		person: .65,
+		vehicle: .4,
+		animal: .5
+	},
+	"yolo26n-320": {
+		person: .6,
+		vehicle: .6,
+		animal: .4
+	},
+	"yolo26n-320-int8": {
+		person: .45,
+		vehicle: .55,
+		animal: .35
+	},
+	"yolo26n-int8": {
+		person: .55,
+		vehicle: .3,
+		animal: .4
+	},
+	yolo26s: {
+		person: .4,
+		vehicle: .45,
+		animal: .4
+	},
+	"yolo26s-320": {
+		person: .6,
+		vehicle: .45,
+		animal: .45
+	},
+	"yolo26s-320-int8": {
+		person: .5,
+		vehicle: .55,
+		animal: .45
+	},
+	"yolo26s-int8": {
+		person: .4,
+		vehicle: .3,
+		animal: .4
+	},
+	"yolov9c-320": {
+		person: .7,
+		vehicle: .45,
+		animal: .45
+	},
+	"yolov9c-320-int8": {
+		person: .7,
+		vehicle: .5,
+		animal: .25
+	},
+	"yolov9c-640": {
+		person: .55,
+		vehicle: .45,
+		animal: .3
+	},
+	"yolov9c-640-int8": {
+		person: .45,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolov9m-320": {
+		person: .7,
+		vehicle: .5,
+		animal: .55
+	},
+	"yolov9m-320-int8": {
+		person: .65,
+		vehicle: .4,
+		animal: .45
+	},
+	"yolov9m-640": {
+		person: .6,
+		vehicle: .4,
+		animal: .55
+	},
+	"yolov9m-640-int8": {
+		person: .55,
+		vehicle: .4,
+		animal: .7
+	},
+	"yolov9s-320": {
+		person: .7,
+		vehicle: .55,
+		animal: .4
+	},
+	"yolov9s-320-int8": {
+		person: .7,
+		vehicle: .45,
+		animal: .4
+	},
+	"yolov9s-640": {
+		person: .7,
+		vehicle: .4,
+		animal: .6
+	},
+	"yolov9s-640-int8": {
+		person: .5,
+		vehicle: .3,
+		animal: .55
+	},
+	"yolov9t-320": {
+		person: .55,
+		vehicle: .45,
+		animal: .3
+	},
+	"yolov9t-320-int8": {
+		person: .55,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolov9t-640": {
+		person: .65,
+		vehicle: .5,
+		animal: .5
+	},
+	"yolov9t-640-int8": {
+		person: .6,
+		vehicle: .55,
+		animal: .55
+	}
+};
+/**
+* The floor on the DETECTION score below which a root detector's own fine
+* label (a species, a vehicle type — the D736 root supply) is not taken (D741).
+* Keyed by root model, then by the supplied step. Below it the detection keeps
+* its macro class with no fine label; it is never dropped. A floor of 1 means
+* "never take this label from this root". A root or step absent here has no
+* extra floor — the macro floor alone gates the label, as before D741.
+*
+* Measured 2026-10-07 (`docs/benchmarks/classifier-floors.json`): the
+* lowest detection score from which the root's species was right ~90% of the
+* time, against a two-model zero-shot reference on 219 animal crops dominated
+* by one dog. Unlisted roots behave alike — ~0.89-0.90 at the macro floor for
+* 640 roots, ~0.74 for 320 roots. Vehicle types needed no extra floor on any
+* root (0.99-1.00 at the macro floor). The Coral SSD named the species wrongly
+* three times in four.
+*/
+var ROOT_SUPPLIED_LABEL_FLOORS = {
+	"yolov9m-320-int8": { "animal-classifier": .75 },
+	"yolov9m-640-int8": { "animal-classifier": .7 },
+	"yolov9c-640-int8": { "animal-classifier": .75 },
+	yolo26s: { "animal-classifier": .45 },
+	yolo26m: { "animal-classifier": .7 },
+	"yolo26s-int8": { "animal-classifier": .55 },
+	"ssd-mobilenet-v2-coco-edgetpu": { "animal-classifier": 1 }
+};
+/** Stamp each entry's row of `floors` on it as `suppliedLabelFloors`. Fresh objects only. */
+function withSuppliedLabelFloors(entries, floors) {
+	return entries.map((entry) => {
+		const row = floors[entry.id];
+		return row === void 0 ? entry : {
+			...entry,
+			suppliedLabelFloors: { ...row }
+		};
+	});
+}
+/** Stamp each entry's row of `floors` on it as `defaultClassFloors`. Fresh objects only. */
+function withDefaultClassFloors(entries, floors) {
+	return entries.map((entry) => {
+		const row = floors[entry.id];
+		return row === void 0 ? entry : {
+			...entry,
+			defaultClassFloors: { ...row }
+		};
+	});
+}
+/**
+* Object-detection IRs that need f32 inference on an Intel GPU
+* (`gpuInferencePrecision`). At the GPU's default f16 the YOLO26 FP32 IRs of
+* the larger tiers return no valid detection — measured 2026-10-07 on the Core
+* Ultra iGPU and the N100: `yolo26s` (640) 0 true / 146 false positives,
+* `yolo26m` and `yolo26m-320` NaN scores; at f32 they match the CPU, at ~60%
+* more GPU latency. `yolo26n`, `yolo26n-320` and `yolo26s-320` were measured
+* correct at f16 and are NOT listed. The rest of the list is the same pattern
+* not yet measured (tier m / l / x at any input, tier s at 640, the seg builds
+* of those tiers): f32 costs latency, f16 risks a detector that silently finds
+* nothing. INT8 IRs and every YOLOv9 IR are correct at the device default.
+*/
+var OPENVINO_GPU_F32_MODEL_IDS = new Set([
+	"yolo26s",
+	"yolo26m",
+	"yolo26m-320",
+	"yolo26m-256",
+	"yolo26l",
+	"yolo26l-320",
+	"yolo26l-256",
+	"yolo26x",
+	"yolo26s-seg",
+	"yolo26m-seg"
+]);
+/** Stamp `gpuInferencePrecision: 'f32'` on the listed entries. Fresh objects only. */
+function withGpuF32(entries, ids) {
+	return entries.map((entry) => ids.has(entry.id) ? {
+		...entry,
+		gpuInferencePrecision: "f32"
+	} : entry);
+}
+[...OPENVINO_GPU_F32_MODEL_IDS];
+var OBJECT_DETECTION_MODELS = withSuppliedLabelFloors(withGpuF32(withDefaultClassFloors(OBJECT_DETECTION_MODEL_ENTRIES, OBJECT_DETECTION_CLASS_FLOORS), OPENVINO_GPU_F32_MODEL_IDS), ROOT_SUPPLIED_LABEL_FLOORS);
 var FACE_DETECTION_MODELS = [{
 	id: "yunet-2023mar",
 	license: YUNET_MIT,
@@ -739,7 +1094,7 @@ var FACE_DETECTION_MODELS = [{
 	}],
 	preprocessMode: "letterbox",
 	postprocessor: "yunet",
-	defaultConfidence: .85,
+	defaultConfidence: .7,
 	formats: {
 		onnx: {
 			url: hf("faceDetection/yunet/onnx/camstack-yunet-2023mar.onnx"),
@@ -891,7 +1246,8 @@ var ANIMAL_CLASSIFIER_MODELS = [{
 	id: "animal-classifier",
 	license: ANIMAL_CLASSIFIER_APACHE,
 	name: "Animal Classifier (8)",
-	description: "EfficientNet-Lite0 animal classifier — bird, cat, cow, deer, dog, horse, sheep, squirrel (Open Images V7, publicly distributable)",
+	description: "EfficientNet-Lite0 animal classifier — bird, cat, cow, deer, dog, horse, sheep, squirrel (Open Images V7, publicly distributable). Unreliable on home cameras: it has no reject class, so it names a species for anything it is given, and calls light curly-coated dogs sheep or cat at high confidence. Prefer a root detector that names animals itself.",
+	defaultConfidence: .8,
 	inputSize: {
 		width: 224,
 		height: 224
@@ -970,6 +1326,7 @@ var VEHICLE_CLASSIFIER_MODELS = [{
 	license: VEHICLE_TYPE_V1_NC,
 	name: "Vehicle Type (8)",
 	description: "MobileNetV3-Large vehicle type classifier — Ambulance, Bicycle, Bus, Car, Motorcycle, Taxi, Truck, Van (val 89.4%)",
+	defaultConfidence: .6,
 	inputSize: {
 		width: 224,
 		height: 224
@@ -1030,86 +1387,13 @@ var SEGMENTATION_REFINER_MODELS = [{
 		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
 	}
 }];
-var INSTANCE_SEGMENTATION_MODELS = [
-	{
-		id: "yolo26n-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Nano Seg",
-		description: "YOLO26 Nano Segmentation — ultra-lightweight instance segmentation with masks",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
-				sizeMB: 11
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
-				sizeMB: 6,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
-		}
-	},
-	{
-		id: "yolo26s-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Small Seg",
-		description: "YOLO26 Small Segmentation — balanced instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
-				sizeMB: 40
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
-				sizeMB: 20,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
-		}
-	},
-	{
-		id: "yolo26m-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Medium Seg",
-		description: "YOLO26 Medium Segmentation — high-accuracy instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
-				sizeMB: 90
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
-				sizeMB: 45,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
-		}
-	}
-];
+/**
+* The dormant `instance-segmentation` step's catalog: the YOLO26-seg entries of
+* {@link OBJECT_DETECTION_MODELS}, by reference. One entry per model (D703) —
+* the artifact lives once, in the root's catalog, where it can be selected as
+* the camera root and supply the `segmentation` step's masks (D737).
+*/
+var INSTANCE_SEGMENTATION_MODELS = OBJECT_DETECTION_MODELS.filter((m) => m.group?.family === YOLO26_SEG_FAMILY);
 var CLIP_EMBEDDING_MODELS = [{
 	id: "siglip2-b16-224",
 	license: SIGLIP2_APACHE,
@@ -1215,6 +1499,20 @@ var PipelineStepBase = class {
 		return [];
 	}
 };
+/**
+* The GLOBAL per-class confidence floors of the object-detection step — what a
+* model that declares no `defaultClassFloors` row runs at (D738). Tuned on the
+* YOLOv9 root; see the person slider for the measurement behind 0.65.
+*/
+var GLOBAL_CLASS_FLOORS = {
+	person: .65,
+	vehicle: .5,
+	animal: .5
+};
+/** The model's own default floor for `macroClass`, else the global one (D738). */
+function classFloorDefault(model, macroClass, globalFloor) {
+	return model?.defaultClassFloors?.[macroClass] ?? globalFloor;
+}
 var ObjectDetectionStep = class {
 	definition = {
 		id: "object-detection",
@@ -1237,7 +1535,7 @@ var ObjectDetectionStep = class {
 		labels: require_dist.COCO_80_LABELS.map((l) => l.id),
 		classMap: require_dist.COCO_TO_MACRO
 	};
-	getConfigSchema() {
+	getConfigSchema(model) {
 		return [
 			{
 				type: "multiselect",
@@ -1272,7 +1570,8 @@ var ObjectDetectionStep = class {
 				min: 0,
 				max: 1,
 				step: .05,
-				default: .65,
+				default: classFloorDefault(model, "person", GLOBAL_CLASS_FLOORS.person),
+				bindsToModel: true,
 				showValue: true
 			},
 			{
@@ -1294,7 +1593,8 @@ var ObjectDetectionStep = class {
 				min: 0,
 				max: 1,
 				step: .05,
-				default: .5,
+				default: classFloorDefault(model, "vehicle", GLOBAL_CLASS_FLOORS.vehicle),
+				bindsToModel: true,
 				showValue: true
 			},
 			{
@@ -1305,7 +1605,8 @@ var ObjectDetectionStep = class {
 				min: 0,
 				max: 1,
 				step: .05,
-				default: .5,
+				default: classFloorDefault(model, "animal", GLOBAL_CLASS_FLOORS.animal),
+				bindsToModel: true,
 				showValue: true
 			},
 			{
@@ -1391,7 +1692,7 @@ var AnimalClassifierStep = class {
 		labelTier: 1,
 		models: [...ANIMAL_CLASSIFIER_MODELS],
 		defaultModelId: "animal-classifier",
-		enabledByDefault: false,
+		enabledByDefault: true,
 		defaultConfidence: .5,
 		labels: [...ANIMAL_10_LABELS],
 		cadence: {
@@ -1417,6 +1718,7 @@ var AnimalClassifierStep = class {
 			label: "Min Confidence",
 			description: "Drop classifications whose score is below this threshold.",
 			default: resolveModelDefaultConfidence(this.definition, model),
+			bindsToModel: true,
 			min: 0,
 			max: 1,
 			step: .05,
@@ -1458,6 +1760,7 @@ var PackageDetectionStep = class extends PipelineStepBase {
 			max: 1,
 			step: .05,
 			default: resolveModelDefaultConfidence(this.definition, model),
+			bindsToModel: true,
 			showValue: true
 		}];
 	}
@@ -1470,6 +1773,7 @@ var ClassifierWithMinConfidence = class extends PipelineStepBase {
 			label: "Min Confidence",
 			description: "Drop classifications whose score is below this threshold.",
 			default: resolveModelDefaultConfidence(this.definition, model),
+			bindsToModel: true,
 			min: 0,
 			max: 1,
 			step: .05,
@@ -1570,6 +1874,7 @@ var STEP_FACE_EMBEDDING = new FaceEmbeddingStep({
 	defaultModelId: "auraface-r100",
 	modelScope: "cluster",
 	defaultConfidence: 0,
+	defaultMinParentScore: .85,
 	cadence: {
 		trigger: "improve",
 		minIntervalMs: 1e3,
@@ -1705,7 +2010,7 @@ var STEP_VEHICLE_CLASSIFIER = new VehicleClassifierStep({
 	labelTier: 1,
 	models: [...VEHICLE_CLASSIFIER_MODELS],
 	defaultModelId: "vehicle-type-v1",
-	enabledByDefault: false,
+	enabledByDefault: true,
 	defaultConfidence: .5,
 	cadence: {
 		trigger: "once",
@@ -2959,6 +3264,122 @@ function rootObjectGate(steps) {
 	return (steps?.find((s) => s.enabled !== false))?.settings;
 }
 //#endregion
+//#region src/detection-pipeline/default-detection-model.ts
+/** The object-detection step id — the only slot this resolver applies to. */
+var OBJECT_DETECTION_STEP_ID = "object-detection";
+/**
+* Balanced default object-detection model per accelerator class. `'cpu'` maps to
+* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
+* INTEL NPU + iGPU default to the Ultralytics YOLOv9 re-export (int8 @320), which
+* runs on both (~298 fps measured on the NPU). YOLO26 also runs on the NPU since
+* OpenVINO 2025.4 (its base IRs as accurately as the CPU, its INT8 IRs with lost
+* recall) and is an operator pick there, not the default. Apple ANE uses the
+* CoreML yolov9 @320 build.
+*
+* Do **not** promote these ids to `yolov9m-640` / `*-640`. The controlled
+* evaluation recovered 0/3 misses at the current 0.50 threshold and failed the
+* false-positive and capacity gates — see
+* `docs/benchmarks/pipeline-frame-model-eval.md`. 640 remains an explicit
+* operator pick, not a hardware-aware default.
+*/
+var MODEL_BY_CLASS = {
+	"apple-ane": "yolov9m-320",
+	"intel-npu": "yolov9m-320-int8",
+	"intel-gpu": "yolov9m-320-int8",
+	cpu: null
+};
+/**
+* Classify a node's engine into an {@link AcceleratorClass} from its resolved
+* `backend` + `device`. Pure, total, never throws.
+*
+* OpenVINO's default device is `'auto'` (the python pool resolves NPU > GPU >
+* CPU at load). Because OpenVINO is only ever OFFERED when an Intel iGPU is
+* present, the GPU is the guaranteed accelerator while the NPU is an explicit
+* opt-in — so `'auto'` (and any non-cpu/non-npu device) is treated as
+* GPU-class conservatively. An operator who explicitly pins `device: 'npu'`
+* gets the NPU-tuned m-320.
+*
+* Also accepts the accelerator carried in the `backend` slot (e.g. `'ane'`,
+* `'mps'`, `'npu'`, `'intel-gpu'`) so a caller passing a device-style backend
+* still classifies correctly — real callers pass onnx/openvino/coreml.
+*/
+function classifyAccelerator(backend, device) {
+	const b = backend.toLowerCase();
+	const d = device?.toLowerCase() ?? null;
+	if (b === "coreml" || b === "ane" || b === "mps") return "apple-ane";
+	if (b === "openvino") {
+		if (d === "npu") return "intel-npu";
+		if (d === "cpu") return "cpu";
+		return "intel-gpu";
+	}
+	if (b === "npu" || b === "intel-npu") return "intel-npu";
+	if (b === "gpu" || b === "intel-gpu" || b === "gpu-openvino") return "intel-gpu";
+	return "cpu";
+}
+/**
+* Resolve the hardware-aware default object-detection model id for a node's
+* engine `(backend, device, format)`.
+*
+* Guarantees:
+*   - never throws (hot default-tree path);
+*   - never returns a model id without a build for `format` (unless the step
+*     has ZERO builds for `format`, which is unloadable regardless of pick and
+*     flagged by `collectZeroBuildIssues`) — an unmapped backend, a `'cpu'`
+*     class, a mapped id missing from the catalog, or a mapped id without a
+*     `format` build all fall back to the step's PER-FORMAT default
+*     (`getDefaultModelForFormatFromDef`), NOT the bare `defaultModelId`.
+*
+* `getStepDef` is injectable (defaults to the real catalog lookup) so the
+* missing-build fallback branch is unit-testable without a live catalog —
+* mirrors `collectZeroBuildIssues`' injection seam.
+*/
+function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
+	let def;
+	try {
+		def = getStepDef(OBJECT_DETECTION_STEP_ID);
+	} catch {
+		return "yolo26n";
+	}
+	const candidate = MODEL_BY_CLASS[classifyAccelerator(backend, device)];
+	if (candidate !== null) {
+		const entry = def.models.find((m) => m.id === candidate);
+		if (entry && entry.formats[format] !== void 0) return candidate;
+	}
+	return getDefaultModelForFormatFromDef(def, format);
+}
+//#endregion
+//#region src/detection-pipeline/engine/resolve-device-engine.ts
+/**
+* Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
+* {@link PipelineEngineChoice} used to build that device's inference pool.
+* Throws on an unknown backend token so a bad `deviceKey` fails loud rather
+* than silently building a wrong pool. Format comes from the shared
+* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
+*/
+function resolveDeviceEngine(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
+	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
+	const format = require_dist.DEVICE_BACKEND_TO_FORMAT[backend];
+	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
+	return {
+		runtime: "python",
+		backend,
+		format,
+		device
+	};
+}
+/**
+* The inverse of {@link resolveDeviceEngine}: the `<backend>:<device>` key that
+* names the pool an engine belongs to. Every pool-level log line carries this —
+* without it a default pool logs anonymously and six hours of logs cannot tell
+* "the NPU is unused" from "the NPU IS the anonymous default pool".
+* Falls back to the bare backend when the engine carries no device.
+*/
+function deviceKeyOf(engine) {
+	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
+}
+//#endregion
 //#region src/pipeline-runner/device-jump.ts
 /**
 * Step-tree device jump (same-node, phase 1) — the PURE resolution core.
@@ -3268,88 +3689,6 @@ var CustomModelCatalog = class {
 	stepDefinition = (stepId) => mergedStepDefinition(stepId, this.byStep);
 };
 //#endregion
-//#region src/detection-pipeline/default-detection-model.ts
-/** The object-detection step id — the only slot this resolver applies to. */
-var OBJECT_DETECTION_STEP_ID = "object-detection";
-/**
-* Balanced default object-detection model per accelerator class. `'cpu'` maps to
-* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
-* INTEL NPU + iGPU default to the Ultralytics YOLOv9 re-export (int8 @320): yolo26 does NOT compile on
-* the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
-* measured). Apple ANE uses the CoreML yolov9 @320 build.
-*
-* Do **not** promote these ids to `yolov9m-640` / `*-640`. The controlled
-* evaluation recovered 0/3 misses at the current 0.50 threshold and failed the
-* false-positive and capacity gates — see
-* `docs/benchmarks/pipeline-frame-model-eval.md`. 640 remains an explicit
-* operator pick, not a hardware-aware default.
-*/
-var MODEL_BY_CLASS = {
-	"apple-ane": "yolov9m-320",
-	"intel-npu": "yolov9m-320-int8",
-	"intel-gpu": "yolov9m-320-int8",
-	cpu: null
-};
-/**
-* Classify a node's engine into an {@link AcceleratorClass} from its resolved
-* `backend` + `device`. Pure, total, never throws.
-*
-* OpenVINO's default device is `'auto'` (the python pool resolves NPU > GPU >
-* CPU at load). Because OpenVINO is only ever OFFERED when an Intel iGPU is
-* present, the GPU is the guaranteed accelerator while the NPU is an explicit
-* opt-in — so `'auto'` (and any non-cpu/non-npu device) is treated as
-* GPU-class conservatively. An operator who explicitly pins `device: 'npu'`
-* gets the NPU-tuned m-320.
-*
-* Also accepts the accelerator carried in the `backend` slot (e.g. `'ane'`,
-* `'mps'`, `'npu'`, `'intel-gpu'`) so a caller passing a device-style backend
-* still classifies correctly — real callers pass onnx/openvino/coreml.
-*/
-function classifyAccelerator(backend, device) {
-	const b = backend.toLowerCase();
-	const d = device?.toLowerCase() ?? null;
-	if (b === "coreml" || b === "ane" || b === "mps") return "apple-ane";
-	if (b === "openvino") {
-		if (d === "npu") return "intel-npu";
-		if (d === "cpu") return "cpu";
-		return "intel-gpu";
-	}
-	if (b === "npu" || b === "intel-npu") return "intel-npu";
-	if (b === "gpu" || b === "intel-gpu" || b === "gpu-openvino") return "intel-gpu";
-	return "cpu";
-}
-/**
-* Resolve the hardware-aware default object-detection model id for a node's
-* engine `(backend, device, format)`.
-*
-* Guarantees:
-*   - never throws (hot default-tree path);
-*   - never returns a model id without a build for `format` (unless the step
-*     has ZERO builds for `format`, which is unloadable regardless of pick and
-*     flagged by `collectZeroBuildIssues`) — an unmapped backend, a `'cpu'`
-*     class, a mapped id missing from the catalog, or a mapped id without a
-*     `format` build all fall back to the step's PER-FORMAT default
-*     (`getDefaultModelForFormatFromDef`), NOT the bare `defaultModelId`.
-*
-* `getStepDef` is injectable (defaults to the real catalog lookup) so the
-* missing-build fallback branch is unit-testable without a live catalog —
-* mirrors `collectZeroBuildIssues`' injection seam.
-*/
-function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
-	let def;
-	try {
-		def = getStepDef(OBJECT_DETECTION_STEP_ID);
-	} catch {
-		return "yolo26n";
-	}
-	const candidate = MODEL_BY_CLASS[classifyAccelerator(backend, device)];
-	if (candidate !== null) {
-		const entry = def.models.find((m) => m.id === candidate);
-		if (entry && entry.formats[format] !== void 0) return candidate;
-	}
-	return getDefaultModelForFormatFromDef(def, format);
-}
-//#endregion
 Object.defineProperty(exports, "ALL_PIPELINE_STEPS", {
 	enumerable: true,
 	get: function() {
@@ -3386,6 +3725,12 @@ Object.defineProperty(exports, "createSessionDecodeCoordinator", {
 		return createSessionDecodeCoordinator;
 	}
 });
+Object.defineProperty(exports, "deviceKeyOf", {
+	enumerable: true,
+	get: function() {
+		return deviceKeyOf;
+	}
+});
 Object.defineProperty(exports, "getDefaultModelForFormat", {
 	enumerable: true,
 	get: function() {
@@ -3446,6 +3791,12 @@ Object.defineProperty(exports, "resolveDefaultDetectionModel", {
 		return resolveDefaultDetectionModel;
 	}
 });
+Object.defineProperty(exports, "resolveDeviceEngine", {
+	enumerable: true,
+	get: function() {
+		return resolveDeviceEngine;
+	}
+});
 Object.defineProperty(exports, "resolveFrameViewGeometry", {
 	enumerable: true,
 	get: function() {