@camstack/addon-pipeline 1.2.334 → 1.2.335

package/dist/{custom-model-catalog-CVeosmYm.js → custom-model-catalog-CL-xJa8w.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-C7v30DMP.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
@@ -451,7 +458,7 @@ var yolo26Reduced = (tier, res, sizes) => {
 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_MODELS = [
+var OBJECT_DETECTION_MODEL_ENTRIES = [
 	{
 		id: "yolo26n",
 		license: ULTRALYTICS_AGPL,
@@ -824,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,
@@ -839,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"),
@@ -991,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
@@ -1070,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
@@ -1242,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",
@@ -1264,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",
@@ -1299,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
 			},
 			{
@@ -1321,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
 			},
 			{
@@ -1332,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
 			},
 			{
@@ -1444,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,
@@ -1485,6 +1760,7 @@ var PackageDetectionStep = class extends PipelineStepBase {
 			max: 1,
 			step: .05,
 			default: resolveModelDefaultConfidence(this.definition, model),
+			bindsToModel: true,
 			showValue: true
 		}];
 	}
@@ -1497,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,
@@ -1597,6 +1874,7 @@ var STEP_FACE_EMBEDDING = new FaceEmbeddingStep({
 	defaultModelId: "auraface-r100",
 	modelScope: "cluster",
 	defaultConfidence: 0,
+	defaultMinParentScore: .85,
 	cadence: {
 		trigger: "improve",
 		minIntervalMs: 1e3,
@@ -2992,9 +3270,11 @@ 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.
+* 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