@camstack/addon-pipeline 1.1.53 → 1.1.55

package/dist/step-definitions-CP9kVSml.mjs

@@ -0,0 +1,1479 @@
+import { S as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-RWGGPwVx.mjs";
+//#region src/detection-pipeline/registry/model-catalogs.ts
+var HF_REPO = "camstack/camstack-models";
+var HF_SCRYPTED = "scrypted/plugin-models";
+var hf = (path) => hfModelUrl(HF_REPO, path);
+var hfScrypted = (path) => hfModelUrl(HF_SCRYPTED, path);
+/**
+* Build an OpenVINO format entry (always python runtime).
+*
+* OpenVINO IR is a two-file bundle: a `.xml` topology + a sibling `.bin`
+* weights file with the same basename. We declare the `.bin` in `files` so
+* the (format-agnostic) downloader fetches it alongside the `.xml` — without
+* the weights, OpenVINO compile fails with "Empty weights data in bin file".
+* A plain `.onnx` run through the OpenVINO runtime (e.g. yamnet) has no
+* sibling, so none is added.
+*/
+var ovFormat = (url, sizeMB) => {
+	const base = url.split("/").pop() ?? "";
+	const files = base.endsWith(".xml") ? [base.replace(/\.xml$/, ".bin")] : void 0;
+	return {
+		url,
+		sizeMB,
+		runtimes: ["python"],
+		...files ? { files } : {}
+	};
+};
+/**
+* Build a precision-variant catalog entry (OpenVINO-only) derived from a base
+* detection model. fp16 halves the weights (Intel iGPU/NPU sweet spot); int8 is
+* NNCF post-training-quantized (~4× smaller, fastest on CPU/iGPU at a small
+* accuracy cost). The IRs live next to the base `.xml` on HF as
+* `camstack-<id>-<precision>.xml`. Lets an operator scale the model to the node
+* (e.g. yolo26x-int8 on a 265K, yolo26n-int8 on an N100).
+*/
+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`,
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [],
+	preprocessMode: "letterbox",
+	formats: { openvino: ovFormat(hf(`${ovDir}/camstack-${baseId}-${precision}.xml`), sizeMB) },
+	...legacy ? { legacy: true } : {},
+	...precision === "int8" ? { group: {
+		family: baseId.slice(0, -1),
+		tier: baseId.slice(-1),
+		precision: "int8"
+	} } : {}
+});
+var MLPACKAGE_FILES = [
+	"Manifest.json",
+	"Data/com.apple.CoreML/model.mlmodel",
+	"Data/com.apple.CoreML/weights/weight.bin"
+];
+var YOLO26_TIER_NAME = {
+	n: "Nano",
+	s: "Small",
+	m: "Medium",
+	l: "Large"
+};
+/**
+* Reduced-input YOLO26 variants (2026-07-11). A lower square input (320 / 256)
+* is the biggest, cheapest latency lever measured across every runtime — Mac
+* ANE, Intel Ultra NPU, and especially the N100 — at a small-object accuracy
+* cost. Each resolution ships a base (fp32) entry (onnx + coreml + openvino)
+* 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.
+*/
+var yolo26Reduced = (tier, res, sizes) => {
+	const name = YOLO26_TIER_NAME[tier] ?? tier.toUpperCase();
+	return [{
+		id: `yolo26${tier}-${res}`,
+		group: {
+			family: "yolo26",
+			tier,
+			resolution: res
+		},
+		name: `YOLO26 ${name} @${res}`,
+		description: `YOLO26 ${name}, reduced ${res}×${res} input — faster on ANE / hub NPU / N100 at a small-object accuracy cost`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf(`objectDetection/yolo26/onnx/camstack-yolo26${tier}-${res}.onnx`),
+				sizeMB: sizes.onnx
+			},
+			coreml: {
+				url: hf(`objectDetection/yolo26/coreml/camstack-yolo26${tier}-${res}.mlpackage`),
+				sizeMB: sizes.coreml,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}.xml`), sizes.ovFp32)
+		}
+	}, {
+		id: `yolo26${tier}-${res}-int8`,
+		group: {
+			family: "yolo26",
+			tier,
+			precision: "int8",
+			resolution: res
+		},
+		name: `YOLO26 ${name} @${res} (INT8)`,
+		description: `YOLO26 ${name} @${res} — OpenVINO INT8 for Intel iGPU/CPU; the N100's fastest config`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: { openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}-int8.xml`), sizes.ovInt8) }
+	}];
+};
+var OBJECT_DETECTION_MODELS = [
+	{
+		id: "yolov9t",
+		legacy: true,
+		name: "YOLOv9 Tiny",
+		description: "YOLOv9 Tiny — ultra-lightweight next-gen detector",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+				sizeMB: 8
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+				sizeMB: 4,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9t.xml"), 6)
+		}
+	},
+	{
+		id: "yolov9s",
+		legacy: true,
+		name: "YOLOv9 Small",
+		description: "YOLOv9 Small — improved efficiency over YOLOv8s",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+				sizeMB: 28
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+				sizeMB: 14,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9s.xml"), 16)
+		}
+	},
+	{
+		id: "yolov9c",
+		legacy: true,
+		name: "YOLOv9 C",
+		description: "YOLOv9 C — high-accuracy compact model",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+				sizeMB: 97
+			},
+			coreml: {
+				url: hf("objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolov9/openvino/camstack-yolov9c.xml"), 49)
+		}
+	},
+	{
+		id: "yolo26n",
+		group: {
+			family: "yolo26",
+			tier: "n"
+		},
+		name: "YOLO26 Nano",
+		description: "YOLO26 Nano — latest generation ultra-lightweight detector with attention mechanism",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26n.onnx"),
+				sizeMB: 10
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26n.mlpackage"),
+				sizeMB: 5,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26n.xml"), 9)
+		}
+	},
+	{
+		id: "yolo26s",
+		group: {
+			family: "yolo26",
+			tier: "s"
+		},
+		name: "YOLO26 Small",
+		description: "YOLO26 Small — balanced speed/accuracy with attention-based architecture",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26s.onnx"),
+				sizeMB: 37
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26s.mlpackage"),
+				sizeMB: 18,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26s.xml"), 36)
+		}
+	},
+	{
+		id: "yolo26m",
+		group: {
+			family: "yolo26",
+			tier: "m"
+		},
+		name: "YOLO26 Medium",
+		description: "YOLO26 Medium — high accuracy general-purpose detector",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26m.onnx"),
+				sizeMB: 78
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26m.mlpackage"),
+				sizeMB: 39,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26m.xml"), 78)
+		}
+	},
+	{
+		id: "yolo26l",
+		group: {
+			family: "yolo26",
+			tier: "l"
+		},
+		name: "YOLO26 Large",
+		description: "YOLO26 Large — maximum accuracy for demanding deployments",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26l.onnx"),
+				sizeMB: 95
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26l.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26l.xml"), 95)
+		}
+	},
+	{
+		id: "yolo26x",
+		legacy: true,
+		name: "YOLO26 XLarge",
+		description: "YOLO26 XLarge — highest accuracy, attention-based architecture",
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hf("objectDetection/yolo26/onnx/camstack-yolo26x.onnx"),
+				sizeMB: 213
+			},
+			coreml: {
+				url: hf("objectDetection/yolo26/coreml/camstack-yolo26x.mlpackage"),
+				sizeMB: 107,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/yolo26/openvino/camstack-yolo26x.xml"), 213)
+		}
+	},
+	{
+		id: "scrypted-yolov9t-relu",
+		legacy: true,
+		name: "YOLOv9 Tiny ReLU",
+		description: "YOLOv9t ReLU — optimized for int8 quantization",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9t_relu/scrypted_yolov9t_relu.onnx"),
+				sizeMB: 8.1
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9t_relu/scrypted_yolov9t_relu.mlpackage"),
+				sizeMB: 4,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9t_relu.xml"), 6)
+		}
+	},
+	{
+		id: "scrypted-yolov9s-relu",
+		legacy: true,
+		name: "YOLOv9 Small ReLU",
+		description: "YOLOv9s ReLU — improved efficiency, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9s_relu/scrypted_yolov9s_relu.onnx"),
+				sizeMB: 27.9
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9s_relu/scrypted_yolov9s_relu.mlpackage"),
+				sizeMB: 14,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9s_relu.xml"), 16)
+		}
+	},
+	{
+		id: "scrypted-yolov9c-relu",
+		legacy: true,
+		name: "YOLOv9 C ReLU",
+		description: "YOLOv9c ReLU — high-accuracy, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9c_relu/scrypted_yolov9c_relu.onnx"),
+				sizeMB: 96.9
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9c_relu/scrypted_yolov9c_relu.mlpackage"),
+				sizeMB: 48,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9c_relu.xml"), 49)
+		}
+	},
+	{
+		id: "scrypted-yolov9m-relu",
+		legacy: true,
+		name: "YOLOv9 M ReLU",
+		description: "YOLOv9m ReLU — medium, int8 ready",
+		inputSize: {
+			width: 320,
+			height: 320
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		formats: {
+			onnx: {
+				url: hfScrypted("onnx/scrypted_yolov9m_relu/scrypted_yolov9m_relu.onnx"),
+				sizeMB: 76.6
+			},
+			coreml: {
+				url: hfScrypted("coreml/scrypted_yolov9m_relu/scrypted_yolov9m_relu.mlpackage"),
+				sizeMB: 38,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("objectDetection/scrypted-yolov9-relu/openvino/scrypted_yolov9m_relu.xml"), 38)
+		}
+	},
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "fp16", 5, true),
+	ovPrecisionVariant("yolov9t", "objectDetection/yolov9/openvino", "YOLOv9 Tiny", "int8", 3, true),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "fp16", 15, true),
+	ovPrecisionVariant("yolov9s", "objectDetection/yolov9/openvino", "YOLOv9 Small", "int8", 8, true),
+	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),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "int8", 10),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "fp16", 41, true),
+	ovPrecisionVariant("yolo26m", "objectDetection/yolo26/openvino", "YOLO26 Medium", "int8", 21),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "fp16", 50, true),
+	ovPrecisionVariant("yolo26l", "objectDetection/yolo26/openvino", "YOLO26 Large", "int8", 25),
+	...yolo26Reduced("n", 320, {
+		onnx: 10.47,
+		coreml: 5.05,
+		ovFp32: 10.05,
+		ovInt8: 3.29
+	}),
+	...yolo26Reduced("n", 256, {
+		onnx: 10.47,
+		coreml: 5.05,
+		ovFp32: 10.05,
+		ovInt8: 3.29
+	}),
+	...yolo26Reduced("s", 320, {
+		onnx: 38.82,
+		coreml: 19.23,
+		ovFp32: 38.4,
+		ovInt8: 10.43
+	}),
+	...yolo26Reduced("s", 256, {
+		onnx: 38.82,
+		coreml: 19.23,
+		ovFp32: 38.4,
+		ovInt8: 10.43
+	}),
+	...yolo26Reduced("m", 320, {
+		onnx: 83.31,
+		coreml: 41.07,
+		ovFp32: 82.09,
+		ovInt8: 21.47
+	}),
+	...yolo26Reduced("m", 256, {
+		onnx: 83.31,
+		coreml: 41.07,
+		ovFp32: 82.09,
+		ovInt8: 21.47
+	}),
+	...yolo26Reduced("l", 320, {
+		onnx: 101.74,
+		coreml: 49.97,
+		ovFp32: 99.85,
+		ovInt8: 26.31
+	}),
+	...yolo26Reduced("l", 256, {
+		onnx: 101.74,
+		coreml: 49.97,
+		ovFp32: 99.85,
+		ovInt8: 26.31
+	}),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112, true),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56, true)
+];
+var FACE_DETECTION_MODELS = [{
+	id: "scrfd-2.5g",
+	name: "SCRFD 2.5G",
+	description: "SCRFD 2.5G — balanced face detection model",
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [{
+		id: "face",
+		name: "Face"
+	}],
+	preprocessMode: "letterbox",
+	formats: {
+		onnx: {
+			url: hf("faceDetection/scrfd/onnx/camstack-scrfd-2.5g.onnx"),
+			sizeMB: 3.1
+		},
+		coreml: {
+			url: hf("faceDetection/scrfd/coreml/camstack-scrfd-2.5g.mlpackage"),
+			sizeMB: 1.7,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceDetection/scrfd/openvino/camstack-scrfd-2.5g.xml"), 1.8)
+	}
+}, {
+	id: "scrypted-yolov9t-face",
+	name: "YOLOv9t Face ReLU",
+	description: "YOLOv9t face detection — YOLO-based, fast, 320x320 ReLU",
+	inputSize: {
+		width: 320,
+		height: 320
+	},
+	labels: [{
+		id: "face",
+		name: "Face"
+	}],
+	preprocessMode: "letterbox",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.onnx"),
+			sizeMB: 8.1
+		},
+		coreml: {
+			url: hfScrypted("coreml/scrypted_yolov9t_relu_face/scrypted_yolov9t_relu_face.mlpackage"),
+			sizeMB: 4,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceDetection/scrypted-yolov9-face/openvino/scrypted_yolov9t_relu_face.xml"), 6)
+	}
+}];
+var FACE_EMBEDDING_MODELS = [{
+	id: "arcface-r100",
+	name: "ArcFace R100",
+	description: "ArcFace ResNet-100 — high-accuracy face recognition embeddings (512-d)",
+	inputSize: {
+		width: 112,
+		height: 112
+	},
+	inputLayout: "nhwc",
+	labels: [{
+		id: "embedding",
+		name: "Face Embedding"
+	}],
+	preprocessMode: "resize",
+	faceAlignment: true,
+	formats: {
+		onnx: {
+			url: hf("faceRecognition/arcface/onnx/camstack-arcface-arcface.onnx"),
+			sizeMB: 130
+		},
+		coreml: {
+			url: hf("faceRecognition/arcface/coreml/camstack-arcface-r100.mlpackage"),
+			sizeMB: 65,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceRecognition/arcface/openvino/camstack-arcface-r100.xml"), 65)
+	}
+}, {
+	id: "inception-resnet-v1",
+	name: "Inception ResNet V1",
+	description: "FaceNet-style face recognition embeddings (512-d) — hosted on plugin-models HF repo",
+	inputSize: {
+		width: 160,
+		height: 160
+	},
+	labels: [{
+		id: "embedding",
+		name: "Face Embedding"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/inception_resnet_v1/inception_resnet_v1.onnx"),
+			sizeMB: 89.6
+		},
+		coreml: {
+			url: hfScrypted("coreml/inception_resnet_v1/inception_resnet_v1.mlpackage"),
+			sizeMB: 45,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceRecognition/inception-resnet-v1/openvino/camstack-inception-resnet-v1.xml"), 45)
+	}
+}];
+var PLATE_DETECTION_MODELS = [{
+	id: "yolov8n-plate",
+	name: "YOLOv8 Nano — License Plate",
+	description: "YOLOv8 Nano fine-tuned for license plate detection",
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [{
+		id: "plate",
+		name: "License Plate"
+	}],
+	preprocessMode: "letterbox",
+	formats: {
+		onnx: {
+			url: hf("plateDetection/yolov8-plate/onnx/camstack-yolov8n-plate.onnx"),
+			sizeMB: 12
+		},
+		coreml: {
+			url: hf("plateDetection/yolov8-plate/coreml/camstack-yolov8n-plate.mlpackage"),
+			sizeMB: 5.9,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateDetection/yolov8-plate/openvino/camstack-yolov8n-plate.xml"), 6.1)
+	}
+}];
+var PLATE_OCR_MODELS = [{
+	id: "vgg-english-g2",
+	name: "VGG English G2",
+	description: "EasyOCR VGG English G2 — text recognition for license plates and scene text",
+	inputSize: {
+		width: 384,
+		height: 64
+	},
+	labels: [{
+		id: "text",
+		name: "Plate Text"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hfScrypted("onnx/vgg_english_g2/vgg_english_g2.onnx"),
+			sizeMB: 14.4
+		},
+		coreml: {
+			url: hfScrypted("coreml/vgg_english_g2/vgg_english_g2.mlpackage"),
+			sizeMB: 11.2,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateRecognition/vgg_english_g2/openvino/vgg_english_g2.xml"), 7.2)
+	}
+}];
+var ANIMAL_CLASSIFIER_MODELS = [{
+	id: "animals-10",
+	name: "Animal Classifier (10)",
+	description: "ViT-based animal type classifier — cat, cow, dog, dolphin, eagle, panda, horse, monkey, sheep, spider",
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "animal-type",
+		name: "Animal Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/animals-10/onnx/camstack-animals-10.onnx"),
+			sizeMB: 328
+		},
+		coreml: {
+			url: hf("animalClassification/animals-10/coreml/camstack-animals-10.mlpackage"),
+			sizeMB: 164,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/animals-10/openvino/camstack-animals-10.xml"), 164)
+	}
+}];
+var BIRD_CLASSIFIER_MODELS = [{
+	id: "bird-nabirds-404",
+	name: "NABirds (404 species)",
+	description: "ResNet50 trained on NABirds — 404 North American species",
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "species",
+		name: "Bird Species"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404.onnx"),
+			sizeMB: 93
+		},
+		coreml: {
+			url: hf("animalClassification/bird-nabirds/coreml/camstack-bird-nabirds-404.mlpackage"),
+			sizeMB: 47,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"), 47)
+	},
+	extraFiles: [{
+		url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404-labels.json"),
+		filename: "camstack-bird-nabirds-404-labels.json",
+		sizeMB: .02
+	}]
+}];
+var VEHICLE_CLASSIFIER_MODELS = [{
+	id: "vehicle-type-efficientnet",
+	name: "Vehicle Type (EfficientNet)",
+	description: "EfficientNet-B4 vehicle make/model/year classifier — 8,949 classes from VMMRdb",
+	inputSize: {
+		width: 380,
+		height: 380
+	},
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "vehicle-type",
+		name: "Vehicle Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("vehicleClassification/efficientnet/onnx/camstack-vehicle-type-efficientnet.onnx"),
+			sizeMB: 135
+		},
+		coreml: {
+			url: hf("vehicleClassification/efficientnet/coreml/camstack-vehicle-type-efficientnet.mlpackage"),
+			sizeMB: 10,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("vehicleClassification/efficientnet/openvino/camstack-vehicle-type-efficientnet.xml"), 68)
+	},
+	extraFiles: [{
+		url: hf("vehicleClassification/efficientnet/camstack-vehicle-type-labels.json"),
+		filename: "camstack-vehicle-type-labels.json",
+		sizeMB: .2
+	}]
+}];
+var SEGMENTATION_REFINER_MODELS = [{
+	id: "u2netp",
+	name: "U2-Net Portable",
+	description: "U2-Net-P — ultra-lightweight salient object segmentation (4.7 MB)",
+	inputSize: {
+		width: 320,
+		height: 320
+	},
+	labels: [{
+		id: "mask",
+		name: "Segmentation Mask"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("segmentationRefiner/u2netp/onnx/camstack-u2netp.onnx"),
+			sizeMB: 5
+		},
+		coreml: {
+			url: hf("segmentationRefiner/u2netp/coreml/camstack-u2netp.mlpackage"),
+			sizeMB: 3,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
+	}
+}];
+var INSTANCE_SEGMENTATION_MODELS = [
+	{
+		id: "yolo26n-seg",
+		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",
+		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",
+		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)
+		}
+	}
+];
+var CLIP_EMBEDDING_MODELS = [
+	{
+		id: "mobileclip-s0",
+		name: "MobileCLIP S0",
+		description: "MobileCLIP S0 — Apple ultra-fast CLIP vision encoder, 512-dim, 256×256 (40 MB ONNX)",
+		inputSize: {
+			width: 256,
+			height: 256
+		},
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
+		formats: {
+			onnx: {
+				url: hf("clip/mobileclip-s0/onnx/camstack-mobileclip-s0-vision.onnx"),
+				sizeMB: 40
+			},
+			openvino: ovFormat(hf("clip/mobileclip-s0/openvino/camstack-mobileclip-s0-vision.xml"), 25),
+			coreml: {
+				url: hf("clip/mobileclip-s0/coreml/camstack-mobileclip-s0-vision.mlpackage"),
+				sizeMB: 30,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			}
+		}
+	},
+	{
+		id: "mobileclip-s1",
+		name: "MobileCLIP S1",
+		description: "MobileCLIP S1 — Apple balanced CLIP vision encoder, 512-dim, 256×256 (90 MB ONNX)",
+		inputSize: {
+			width: 256,
+			height: 256
+		},
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
+		formats: {
+			onnx: {
+				url: hf("clip/mobileclip-s1/onnx/camstack-mobileclip-s1-vision.onnx"),
+				sizeMB: 90
+			},
+			openvino: ovFormat(hf("clip/mobileclip-s1/openvino/camstack-mobileclip-s1-vision.xml"), 55),
+			coreml: {
+				url: hf("clip/mobileclip-s1/coreml/camstack-mobileclip-s1-vision.mlpackage"),
+				sizeMB: 65,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			}
+		}
+	},
+	{
+		id: "mobileclip-s2",
+		name: "MobileCLIP S2",
+		description: "MobileCLIP S2 — Apple high-accuracy CLIP vision encoder, 512-dim, 256×256 (150 MB ONNX)",
+		inputSize: {
+			width: 256,
+			height: 256
+		},
+		labels: [{
+			id: "embedding",
+			name: "CLIP Embedding"
+		}],
+		preprocessMode: "resize",
+		inputNormalization: "none",
+		formats: {
+			onnx: {
+				url: hf("clip/mobileclip-s2/onnx/camstack-mobileclip-s2-vision.onnx"),
+				sizeMB: 150
+			},
+			openvino: ovFormat(hf("clip/mobileclip-s2/openvino/camstack-mobileclip-s2-vision.xml"), 90),
+			coreml: {
+				url: hf("clip/mobileclip-s2/coreml/camstack-mobileclip-s2-vision.mlpackage"),
+				sizeMB: 110,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			}
+		}
+	}
+];
+var AUDIO_CLASSIFIER_MODELS = [{
+	id: "yamnet-onnx",
+	name: "YAMNet",
+	description: "Google YAMNet — 521-class audio event classifier (3.2 MB ONNX, runs on any platform)",
+	inputSize: {
+		width: 1,
+		height: 16e3
+	},
+	labels: [],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
+			sizeMB: 3.2
+		},
+		openvino: ovFormat(hf("audioClassification/yamnet/openvino/camstack-yamnet.xml"), 3.2),
+		coreml: {
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
+			sizeMB: 3.2,
+			runtimes: ["python"]
+		}
+	}
+}, {
+	id: "apple-soundanalysis",
+	name: "Apple SoundAnalysis",
+	description: "macOS built-in — 303 sound categories, Neural Engine accelerated, zero download",
+	inputSize: {
+		width: 1,
+		height: 16e3
+	},
+	labels: [],
+	preprocessMode: "resize",
+	formats: { coreml: {
+		url: "",
+		sizeMB: 0
+	} }
+}];
+//#endregion
+//#region src/detection-pipeline/registry/step-definitions.ts
+var ANIMAL_10_LABELS = [
+	"cat",
+	"cow",
+	"dog",
+	"dolphin",
+	"eagle",
+	"giant panda",
+	"horse",
+	"monkey",
+	"sheep",
+	"spider"
+];
+var VGG_G2_CHARSET = ["", ..."0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("")];
+/**
+* Detail-subtree dispatch cadence a `PipelineStepBase` step gets when its
+* definition literal doesn't declare one explicitly. Conservative default
+* for the "specialized, opt-in" classifier steps that predate the cadence
+* table — dispatch once per track, cap at 3 attempts.
+*/
+var DEFAULT_STEP_CADENCE = {
+	trigger: "once",
+	maxPerTrack: 3
+};
+var PipelineStepBase = class {
+	definition;
+	constructor(definition) {
+		this.definition = {
+			...definition,
+			cadence: definition.cadence ?? DEFAULT_STEP_CADENCE
+		};
+	}
+	getConfigSchema() {
+		return [];
+	}
+};
+var ObjectDetectionStep = class {
+	definition = {
+		id: "object-detection",
+		name: "Object Detection",
+		slot: "detector",
+		postprocessor: "yolo",
+		extractMode: "full-frame",
+		inputClasses: null,
+		outputClasses: [
+			"person",
+			"vehicle",
+			"animal"
+		],
+		models: [...OBJECT_DETECTION_MODELS],
+		defaultModelId: "yolo26n",
+		defaultConfidence: .5,
+		labels: COCO_80_LABELS.map((l) => l.id),
+		classMap: COCO_TO_MACRO
+	};
+	getConfigSchema() {
+		return [
+			{
+				type: "multiselect",
+				key: "enabledMacroClasses",
+				label: "Enabled Classes",
+				description: "Which macro classes to detect (empty = all three).",
+				options: [
+					{
+						value: "person",
+						label: "Person"
+					},
+					{
+						value: "vehicle",
+						label: "Vehicle"
+					},
+					{
+						value: "animal",
+						label: "Animal"
+					}
+				],
+				default: [
+					"person",
+					"vehicle",
+					"animal"
+				]
+			},
+			{
+				type: "slider",
+				key: "minConfidencePerson",
+				label: "Min Confidence — Person",
+				description: "Drop person predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			},
+			{
+				type: "slider",
+				key: "minConfidenceVehicle",
+				label: "Min Confidence — Vehicle",
+				description: "Drop vehicle predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			},
+			{
+				type: "slider",
+				key: "minConfidenceAnimal",
+				label: "Min Confidence — Animal",
+				description: "Drop animal predictions below this score.",
+				min: 0,
+				max: 1,
+				step: .05,
+				default: .5,
+				showValue: true
+			}
+		];
+	}
+};
+var AudioClassifierStep = class {
+	definition = {
+		id: "audio-classifier",
+		name: "Audio Classifier",
+		slot: "audio-classifier",
+		postprocessor: "yamnet",
+		extractMode: "full-frame",
+		inputClasses: null,
+		outputClasses: ["audio"],
+		models: [...AUDIO_CLASSIFIER_MODELS],
+		defaultModelId: "yamnet-onnx",
+		defaultModelIdByFormat: { coreml: "apple-soundanalysis" },
+		enabledByDefault: true,
+		defaultConfidence: .3
+	};
+	getConfigSchema() {
+		return [{
+			type: "multiselect",
+			key: "enabledAudioClasses",
+			label: "Audio Classes",
+			description: "Which audio macro classes to surface (empty = all).",
+			options: AUDIO_MACRO_LABELS.map((l) => ({
+				value: l.id,
+				label: `${l.icon ?? ""} ${l.name}`.trim()
+			})),
+			default: [
+				"scream",
+				"crying",
+				"dog",
+				"alarm",
+				"doorbell",
+				"glass_breaking",
+				"gunshot",
+				"siren",
+				"footsteps"
+			]
+		}, {
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop predictions whose score is below this threshold.",
+			default: .3,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
+	}
+};
+var AnimalClassifierStep = class {
+	definition = {
+		id: "animal-classifier",
+		name: "Animal Classifier",
+		slot: "classifier",
+		postprocessor: "softmax",
+		extractMode: "crop-roi",
+		inputClasses: ["animal"],
+		outputClasses: ["animal-type"],
+		models: [...ANIMAL_CLASSIFIER_MODELS],
+		defaultModelId: "animals-10",
+		enabledByDefault: false,
+		defaultConfidence: .2,
+		labels: [...ANIMAL_10_LABELS],
+		cadence: {
+			trigger: "once",
+			maxPerTrack: 3,
+			stickyOnConfidence: .7
+		}
+	};
+	getConfigSchema() {
+		return [{
+			type: "multiselect",
+			key: "enabledClasses",
+			label: "Species",
+			description: "Which animal species to keep (empty = all). The classifier still scores every label but only the selected classes are returned on the detection.",
+			options: ANIMAL_10_LABELS.map((l) => ({
+				value: l,
+				label: l
+			})),
+			default: []
+		}, {
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop classifications whose score is below this threshold.",
+			default: this.definition.defaultConfidence,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
+	}
+};
+var ClassifierWithMinConfidence = class extends PipelineStepBase {
+	getConfigSchema() {
+		return [{
+			type: "slider",
+			key: "minConfidence",
+			label: "Min Confidence",
+			description: "Drop classifications whose score is below this threshold.",
+			default: this.definition.defaultConfidence,
+			min: 0,
+			max: 1,
+			step: .05,
+			showValue: true
+		}];
+	}
+};
+var STEP_FACE_DETECTION = new PipelineStepBase({
+	id: "face-detection",
+	name: "Face Detection",
+	slot: "cropper",
+	postprocessor: "scrfd",
+	extractMode: "crop-roi",
+	inputClasses: ["person"],
+	outputClasses: ["face"],
+	models: [...FACE_DETECTION_MODELS],
+	defaultModelId: "scrfd-2.5g",
+	defaultConfidence: .5,
+	defaultMinParentScore: .7,
+	cadence: {
+		trigger: "improve",
+		minIntervalMs: 1e3
+	}
+});
+var STEP_FACE_EMBEDDING = new PipelineStepBase({
+	id: "face-embedding",
+	name: "Face Embedding",
+	slot: "classifier",
+	postprocessor: "arcface",
+	extractMode: "crop-roi",
+	inputClasses: ["face"],
+	outputClasses: ["identity"],
+	models: [...FACE_EMBEDDING_MODELS],
+	defaultModelId: "arcface-r100",
+	defaultConfidence: 0,
+	cadence: {
+		trigger: "improve",
+		minIntervalMs: 1e3,
+		stickyOnConfidence: .6
+	}
+});
+var STEP_CLIP_EMBEDDING = new PipelineStepBase({
+	id: "clip-embedding",
+	name: "CLIP Embedding",
+	slot: "classifier",
+	postprocessor: "clip",
+	extractMode: "crop-roi",
+	inputClasses: [
+		"person",
+		"vehicle",
+		"animal"
+	],
+	outputClasses: ["embedding"],
+	models: [...CLIP_EMBEDDING_MODELS],
+	defaultModelId: "mobileclip-s1",
+	enabledByDefault: true,
+	backfillIntoExistingOverrides: true,
+	defaultConfidence: 0,
+	defaultMinParentScore: .4,
+	group: "CLIP",
+	cadence: { trigger: "improve" }
+});
+var STEP_PLATE_DETECTION = new PipelineStepBase({
+	id: "plate-detection",
+	name: "Plate Detection",
+	slot: "cropper",
+	postprocessor: "yolo",
+	extractMode: "crop-roi",
+	inputClasses: ["vehicle"],
+	outputClasses: ["plate"],
+	models: [...PLATE_DETECTION_MODELS],
+	defaultModelId: "yolov8n-plate",
+	defaultConfidence: .5,
+	defaultMinParentScore: .7,
+	labels: ["plate"],
+	cadence: {
+		trigger: "once",
+		maxPerTrack: 5
+	}
+});
+var STEP_PLATE_OCR = new PipelineStepBase({
+	id: "plate-ocr",
+	name: "Plate OCR",
+	slot: "classifier",
+	postprocessor: "ctc",
+	extractMode: "crop-roi",
+	inputClasses: ["plate"],
+	outputClasses: ["plate-text"],
+	models: [...PLATE_OCR_MODELS],
+	defaultModelId: "vgg-english-g2",
+	defaultConfidence: 0,
+	charset: [...VGG_G2_CHARSET],
+	cadence: {
+		trigger: "once",
+		maxPerTrack: 5
+	}
+});
+var STEP_BIRD_CLASSIFIER = new ClassifierWithMinConfidence({
+	id: "bird-classifier",
+	name: "Bird Classifier",
+	slot: "classifier",
+	postprocessor: "softmax",
+	extractMode: "crop-roi",
+	inputClasses: ["animal"],
+	outputClasses: ["species"],
+	models: [...BIRD_CLASSIFIER_MODELS],
+	defaultModelId: "bird-nabirds-404",
+	enabledByDefault: false,
+	defaultConfidence: .2,
+	cadence: {
+		trigger: "once",
+		maxPerTrack: 3,
+		stickyOnConfidence: .7
+	}
+});
+var STEP_VEHICLE_CLASSIFIER = new ClassifierWithMinConfidence({
+	id: "vehicle-classifier",
+	name: "Vehicle Classifier",
+	slot: "classifier",
+	postprocessor: "softmax",
+	extractMode: "crop-roi",
+	inputClasses: ["vehicle"],
+	outputClasses: ["vehicle-type"],
+	models: [...VEHICLE_CLASSIFIER_MODELS],
+	defaultModelId: "vehicle-type-efficientnet",
+	enabledByDefault: false,
+	defaultConfidence: .3,
+	cadence: {
+		trigger: "once",
+		maxPerTrack: 3,
+		stickyOnConfidence: .7
+	}
+});
+var STEP_SEGMENTATION = new PipelineStepBase({
+	id: "segmentation",
+	name: "Segmentation",
+	slot: "refiner",
+	postprocessor: "saliency",
+	extractMode: "crop-roi",
+	inputClasses: null,
+	outputClasses: ["mask"],
+	models: [...SEGMENTATION_REFINER_MODELS],
+	defaultModelId: "u2netp",
+	enabledByDefault: false,
+	defaultConfidence: 0,
+	group: "Segmentation"
+});
+new PipelineStepBase({
+	id: "instance-segmentation",
+	name: "Instance Segmentation",
+	slot: "refiner",
+	postprocessor: "yolo-seg",
+	extractMode: "full-frame",
+	inputClasses: null,
+	outputClasses: ["mask"],
+	models: [...INSTANCE_SEGMENTATION_MODELS],
+	defaultModelId: "yolo26n-seg",
+	enabledByDefault: false,
+	defaultConfidence: .25,
+	labels: COCO_80_LABELS.map((l) => l.id),
+	classMap: COCO_TO_MACRO,
+	group: "Segmentation"
+});
+var STEP_OBJECT_DETECTION_INSTANCE = new ObjectDetectionStep();
+var STEP_AUDIO_CLASSIFIER_INSTANCE = new AudioClassifierStep();
+var ALL_PIPELINE_STEPS = [
+	STEP_OBJECT_DETECTION_INSTANCE,
+	STEP_FACE_DETECTION,
+	STEP_FACE_EMBEDDING,
+	STEP_CLIP_EMBEDDING,
+	STEP_PLATE_DETECTION,
+	STEP_PLATE_OCR,
+	new AnimalClassifierStep(),
+	STEP_BIRD_CLASSIFIER,
+	STEP_VEHICLE_CLASSIFIER,
+	STEP_SEGMENTATION,
+	STEP_AUDIO_CLASSIFIER_INSTANCE
+];
+/** Compat: flat array of StepDefinition for existing consumers */
+var ALL_STEPS = ALL_PIPELINE_STEPS.map((s) => s.definition);
+var STEP_MAP = new Map(ALL_PIPELINE_STEPS.map((s) => [s.definition.id, s]));
+/**
+* Look up a pipeline step by ID (class instance with getConfigSchema).
+* @throws if the step ID is not registered.
+*/
+function getStep(stepId) {
+	const step = STEP_MAP.get(stepId);
+	if (!step) throw new Error(`Unknown pipeline step: "${stepId}". Available: ${ALL_PIPELINE_STEPS.map((s) => s.definition.id).join(", ")}`);
+	return step;
+}
+/**
+* Look up a step definition by ID (compat shortcut).
+* @throws if the step ID is not registered.
+*/
+function getStepDefinition(stepId) {
+	return getStep(stepId).definition;
+}
+/**
+* Get the default model ID for a step given the current model format.
+*
+* Resolution order:
+*   1. `def.defaultModelIdByFormat?.[format]` — the step's declared
+*      per-format preference — if that model exists in `def.models` AND
+*      has a build for `format`.
+*   2. `def.defaultModelId` — the step's plain declared default — if it
+*      exists in `def.models` AND has a build for `format`.
+*   3. The smallest-by-size model among those with a `format` build
+*      (legacy fallback, preserved for steps/formats with no declared
+*      preference reachable).
+*   4. `def.defaultModelId` unchanged, when ZERO models have a `format`
+*      build — an unloadable case flagged elsewhere, not resolved here.
+*/
+function getDefaultModelForFormat(stepId, format) {
+	const def = getStepDefinition(stepId);
+	const hasFormatBuild = (modelId) => def.models.find((m) => m.id === modelId)?.formats[format] !== void 0;
+	const declaredForFormat = def.defaultModelIdByFormat?.[format];
+	if (declaredForFormat !== void 0 && hasFormatBuild(declaredForFormat)) return declaredForFormat;
+	if (hasFormatBuild(def.defaultModelId)) return def.defaultModelId;
+	const available = def.models.filter((m) => m.formats[format] && m.legacy !== true);
+	if (available.length === 0) return def.defaultModelId;
+	return [...available].toSorted((a, b) => {
+		return (a.formats[format]?.sizeMB ?? Infinity) - (b.formats[format]?.sizeMB ?? Infinity);
+	})[0].id;
+}
+/**
+* The single node-local authority for turning a CHOSEN model (or none) into a
+* concrete model that has a build for this node's engine `format`. Fuses the
+* two previously-duplicated decisions (orchestrator `pickDefaultModelId` +
+* provider `substituteIncompatibleModels`):
+*
+*   - chosen === null            → the addon's default model for `format`.
+*   - chosen is a catalog model  → keep it if it has a `format` build; else
+*                                  the addon's default model for `format`
+*                                  (a substitution — the caller surfaces it).
+*   - chosen is NOT in the catalog (custom/unknown) → returned unchanged; the
+*                                  operator owns a custom model's format compat.
+*   - unknown stepId             → chosen returned unchanged (never throws).
+*/
+function resolveModelForFormat(stepId, chosenModelId, format) {
+	let def;
+	try {
+		def = getStepDefinition(stepId);
+	} catch {
+		return chosenModelId ?? "";
+	}
+	if (chosenModelId === null) return getDefaultModelForFormat(stepId, format);
+	const entry = def.models.find((m) => m.id === chosenModelId);
+	if (!entry) return chosenModelId;
+	if (entry.formats[format]) return chosenModelId;
+	return getDefaultModelForFormat(stepId, format);
+}
+//#endregion
+export { getStepDefinition as a, getStep as i, ALL_STEPS as n, resolveModelForFormat as o, getDefaultModelForFormat as r, ALL_PIPELINE_STEPS as t };