@camstack/addon-pipeline 1.1.53 → 1.1.55

package/dist/detection-pipeline/index.js

@@ -3,7 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-DWb62H5U.js");
+const require_dist = require("../dist-DI57FC8K.js");
+const require_step_definitions = require("../step-definitions-CNBFKjZe.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BLXzxpRB.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
@@ -298,1437 +299,6 @@ function projectNodeEngine(store, nodeId) {
 	return out;
 }
 //#endregion
-//#region src/detection-pipeline/registry/model-catalogs.ts
-var HF_REPO = "camstack/camstack-models";
-var HF_SCRYPTED = "scrypted/plugin-models";
-var hf = (path) => require_dist.hfModelUrl(HF_REPO, path);
-var hfScrypted = (path) => require_dist.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("")];
-var PipelineStepBase = class {
-	definition;
-	constructor(definition) {
-		this.definition = definition;
-	}
-	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: require_dist.COCO_80_LABELS.map((l) => l.id),
-		classMap: require_dist.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: require_dist.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]
-	};
-	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
-});
-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
-});
-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"
-});
-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"]
-});
-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]
-});
-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
-});
-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
-});
-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: require_dist.COCO_80_LABELS.map((l) => l.id),
-	classMap: require_dist.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
 //#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";
@@ -1788,7 +358,7 @@ function classifyAccelerator(backend, device) {
 * missing-build fallback branch is unit-testable without a live catalog —
 * mirrors `collectZeroBuildIssues`' injection seam.
 */
-function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
+function resolveDefaultDetectionModel(backend, device, format, getStepDef = require_step_definitions.getStepDefinition) {
 	let def;
 	try {
 		def = getStepDef(OBJECT_DETECTION_STEP_ID);
@@ -2819,7 +1389,7 @@ var EngineFactory = class {
 		await this.poolManager.applyConfig(steps);
 	}
 	buildPoolModelConfig(stepId, modelId, poolRuntime) {
-		const def = getStepDefinition(stepId);
+		const def = require_step_definitions.getStepDefinition(stepId);
 		const modelEntry = def.models.find((m) => m.id === modelId);
 		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog`);
 		const format = RUNTIME_TO_FORMAT[poolRuntime];
@@ -3723,6 +2293,110 @@ function bboxShortSide(bbox) {
 	return Math.min(bbox[2] - bbox[0], bbox[3] - bbox[1]);
 }
 /**
+* Padded region (clamped to the frame) around a face bbox — the area a native
+* crop must cover so the warp has room around a tilted / edge face. Mirrors the
+* padding {@link alignFaceCrop} applies internally (`padRatio` default 0.4), so
+* the native and fallback paths sample the same neighbourhood.
+*/
+function paddedFaceRegion(faceBbox, imageWidth, imageHeight, padRatio = .4) {
+	const bw = faceBbox[2] - faceBbox[0];
+	const bh = faceBbox[3] - faceBbox[1];
+	const padX = bw * padRatio;
+	const padY = bh * padRatio;
+	return {
+		left: Math.max(0, Math.floor(faceBbox[0] - padX)),
+		top: Math.max(0, Math.floor(faceBbox[1] - padY)),
+		right: Math.min(imageWidth, Math.ceil(faceBbox[2] + padX)),
+		bottom: Math.min(imageHeight, Math.ceil(faceBbox[3] + padY))
+	};
+}
+/**
+* Warp a raw RGB crop of `region` (native-resolution pixels of exactly that
+* detection-space region) so `landmarksImageSpace` land on the ArcFace
+* template. Landmarks are mapped from image space into the crop's local pixel
+* space by the per-axis region→crop scale (handles `maxWidth` downscale of the
+* native crop). Channels default to RGB (3) — the format the decode worker's
+* native surface produces.
+*/
+async function alignFaceCropFromRgb(rgb, region, landmarksImageSpace, opts = {}) {
+	const outSize = opts.outSize ?? 112;
+	const quality = opts.quality ?? 95;
+	const channels = opts.channels ?? 3;
+	const regionW = region.right - region.left;
+	const regionH = region.bottom - region.top;
+	if (regionW < 1 || regionH < 1) throw new Error(`alignFaceCropFromRgb: degenerate region ${regionW}x${regionH}`);
+	if (rgb.width < 2 || rgb.height < 2) throw new Error(`alignFaceCropFromRgb: degenerate crop ${rgb.width}x${rgb.height}`);
+	const scaleX = rgb.width / regionW;
+	const scaleY = rgb.height / regionH;
+	const localLandmarks = landmarksImageSpace.map((l) => ({
+		x: (l.x - region.left) * scaleX,
+		y: (l.y - region.top) * scaleY
+	}));
+	const aligned = warpToTemplate({
+		data: rgb.bytes,
+		width: rgb.width,
+		height: rgb.height,
+		channels
+	}, localLandmarks, opts.template ?? ARCFACE_TEMPLATE_112, outSize);
+	return {
+		jpeg: await (0, sharp.default)(Buffer.from(aligned.data), { raw: {
+			width: aligned.width,
+			height: aligned.height,
+			channels: aligned.channels
+		} }).jpeg({ quality }).toBuffer(),
+		width: aligned.width,
+		height: aligned.height
+	};
+}
+/**
+* Produce a landmark-aligned face crop, preferring a NATIVE-resolution crop
+* (design B — the quality win) and FALLING BACK to today's downscaled
+* full-frame alignment on any native miss/error (never worse than before).
+*
+* The native path requests the padded face region from `nativeCropProvider`
+* (a best-effort local cap round-trip bound to this frame), warps the native
+* pixels; the fallback path re-uses {@link alignFaceCrop} on the downscaled
+* JPEG. ArcFace input is a fixed `outSize`×`outSize` either way — only the crop
+* SOURCE changes, so model cost is unchanged.
+*/
+async function buildAlignedFaceCrop(args) {
+	if (args.nativeCropProvider) try {
+		const region = paddedFaceRegion(args.faceBbox, args.imageWidth, args.imageHeight);
+		const roi = {
+			x: region.left / args.imageWidth,
+			y: region.top / args.imageHeight,
+			w: (region.right - region.left) / args.imageWidth,
+			h: (region.bottom - region.top) / args.imageHeight
+		};
+		const native = await args.nativeCropProvider(roi, args.nativeMaxWidth);
+		if (native && native.width >= 2 && native.height >= 2 && native.bytes.length >= native.width * native.height * 3) return {
+			...await alignFaceCropFromRgb(native, region, args.landmarksImageSpace, { outSize: args.outSize }),
+			source: "native",
+			nativeFaceShortSidePx: nativeFaceShortSide(args.faceBbox, region, native)
+		};
+	} catch {}
+	return {
+		...await alignFaceCrop(args.fullFrameJpeg, args.faceBbox, args.landmarksImageSpace, args.imageWidth, args.imageHeight, { outSize: args.outSize }),
+		source: "fallback"
+	};
+}
+/**
+* Short side (px) of `faceBbox` (in detection space) re-measured in the NATIVE
+* crop's resolution. The native crop covers `region` (detection-space padded
+* region) rendered at `native.width × native.height` native pixels, so the
+* per-axis scale `native / region` maps the detection face size to its native
+* size. This is the size an embedder actually sees, so the gate uses it.
+*/
+function nativeFaceShortSide(faceBbox, region, native) {
+	const regionW = Math.max(1, region.right - region.left);
+	const regionH = Math.max(1, region.bottom - region.top);
+	const scaleX = native.width / regionW;
+	const scaleY = native.height / regionH;
+	const faceW = (faceBbox[2] - faceBbox[0]) * scaleX;
+	const faceH = (faceBbox[3] - faceBbox[1]) * scaleY;
+	return Math.min(faceW, faceH);
+}
+/**
 * Produce an aligned 112x112 JPEG of a face from the full-frame JPEG and the
 * face's 5 landmarks (in absolute image-space coordinates). Decodes a padded
 * region around the face bbox to raw RGB, warps to the ArcFace template, and
@@ -3950,7 +2624,8 @@ function buildFrameResult(input) {
 			...embedding !== void 0 ? {
 				embedding,
 				...embeddingModelId !== void 0 ? { embeddingModelId } : {}
-			} : {}
+			} : {},
+			...m.faceAlignedCrop !== void 0 ? { faceAlignedCrop: m.faceAlignedCrop } : {}
 		};
 		if (input.debug) {
 			const cleanDebug = pruneUndefined({
@@ -4031,7 +2706,8 @@ function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
 			mask: det.mask,
 			maskWidth: det.maskWidth,
 			maskHeight: det.maskHeight
-		} : {}
+		} : {},
+		...det.landmarks !== void 0 ? { landmarks: det.landmarks } : {}
 	};
 }
 //#endregion
@@ -4149,6 +2825,33 @@ function formatTopResult(output) {
 * resolution — a deeper change tracked separately.
 */
 var DEFAULT_MIN_FACE_SIZE_PX = 28;
+/**
+* Cheap pre-native floor (px, detection space): below this a face is treated as
+* genuinely degenerate — SCRFD landmarks are unreliable and even a large native
+* upscale can't rescue it — so it is skipped WITHOUT paying a native-crop
+* round-trip. Above the floor, the real {@link DEFAULT_MIN_FACE_SIZE_PX} gate is
+* evaluated on the NATIVE face size (see the face branch of `executeChildren`).
+*/
+var MIN_FACE_DETECTION_FLOOR_PX = 6;
+/**
+* Cap (px) on the width of the NATIVE face crop fetched for embedding (design
+* B). The arcface input is a fixed 112² warp, so a wider native crop buys no
+* embedding quality past a modest margin but does inflate the per-face transport
+* of the best-effort native-crop round-trip. 320px keeps a distant face well
+* above the downscaled detection resolution while bounding the crop payload.
+*/
+var NATIVE_FACE_CROP_MAX_WIDTH = 320;
+/**
+* StepOutput kinds that synthesize a full-frame detection when they run at
+* the tree ROOT (see `synthesizeRootDetection`) — classifier/embedding steps
+* promoted to root by `pipelineRunner.runDetailSubtree` (task 6b), e.g.
+* `clip-embedding`, `animal-classifier`. Detector (`'detections'`) roots take
+* the normal path; `'text'`/`'mask'` roots are out of scope and still
+* `continue` with no output, matching pre-existing behaviour.
+*/
+function isEnrichmentOutput(output) {
+	return output.kind === "classifications" || output.kind === "embedding";
+}
 var PipelineExecutor = class {
 	opts;
 	constructor(opts) {
@@ -4166,6 +2869,23 @@ var PipelineExecutor = class {
 		logger.warn(message, { meta });
 	}
 	/**
+	* Surface WHY a face embedding was skipped — a detected face simply too small
+	* (distance / night) is the common silent cause of "faces stopped collecting".
+	* Reports the detection-space short side AND, when the skip was decided on the
+	* native crop, the NATIVE face size so an operator sees the size that actually
+	* gated. Throttled so it isn't per-frame spam.
+	*/
+	warnFaceTooSmall(child, detShortSidePx, minFaceSizePx, nativeFaceShortSidePx) {
+		this.throttledWarn(`face-small:${child.stepId}`, 3e4, "face detected but too small to embed — skipping", {
+			step: child.stepId,
+			model: child.modelId,
+			faceShortSidePx: Math.round(detShortSidePx),
+			minFaceSizePx,
+			gatedOn: nativeFaceShortSidePx === void 0 ? "detection" : "native",
+			...nativeFaceShortSidePx === void 0 ? {} : { nativeFaceShortSidePx: Math.round(nativeFaceShortSidePx) }
+		});
+	}
+	/**
 	* Execute the full pipeline tree against a frame.
 	*
 	* `rootInput` carries the frame in its source representation
@@ -4178,7 +2898,7 @@ var PipelineExecutor = class {
 	*
 	* @returns FrameResult + optional trace
 	*/
-	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts) {
+	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeFaceCropProvider) {
 		const startMs = Date.now();
 		const verbosity = runOpts?.traceVerbosity ?? "off";
 		const traceBuilder = new ExecutionTraceBuilder(verbosity, deviceId, imageWidth, imageHeight, this.opts.engineRuntime);
@@ -4201,7 +2921,27 @@ var PipelineExecutor = class {
 			const rootStart = Date.now();
 			const rootOutput = await this.executeStep(rootStep, rootInput, imageWidth, imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg);
 			const rootMs = Date.now() - rootStart;
-			if (rootOutput.kind !== "detections") continue;
+			if (rootOutput.kind !== "detections") {
+				if (isEnrichmentOutput(rootOutput)) {
+					const mutable = this.synthesizeRootDetection(rootOutput, rootStep, idGen, rootMs, imageWidth, imageHeight);
+					applyChildOutput(mutable, rootStep, rootOutput, rootMs, ctx);
+					try {
+						await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, nativeFaceCropProvider);
+					} catch (err) {
+						this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
+							tags: { deviceId },
+							meta: {
+								rootStepId: rootStep.stepId,
+								parentClass: mutable.macroClass,
+								parentScore: mutable.score,
+								error: require_dist.errMsg(err)
+							}
+						});
+					}
+					firstLevel.push(mutable);
+				}
+				continue;
+			}
 			for (const det of rootOutput.detections) {
 				const mutable = toMutableRootDetection(det, rootStep, idGen, rootMs);
 				if (rootStep.definition.classMap) {
@@ -4216,7 +2956,7 @@ var PipelineExecutor = class {
 					continue;
 				}
 				try {
-					await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg);
+					await this.executeChildren(rootStep.children, mutable, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, nativeFaceCropProvider);
 				} catch (err) {
 					this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
 						tags: { deviceId },
@@ -4252,6 +2992,29 @@ var PipelineExecutor = class {
 			trace: traceBuilder.build(firstLevel.length + details.length)
 		};
 	}
+	/**
+	* Build a full-frame `MutableObjectDetection` for a ROOT step whose engine
+	* output is a classification/embedding rather than detections — there is
+	* no detector to bound a smaller box, so the synthesized detection covers
+	* the entire input frame (`bbox = [0, 0, imageWidth, imageHeight]`).
+	* `macroClass` is the step's own output semantic (`outputClasses[0]`,
+	* falling back to `inputClasses[0]` when `outputClasses` is empty, then
+	* the step id as a last resort so the field is never empty). `score` is
+	* the output's own confidence when it has one (the classifier's top-1
+	* score) — an embedding carries no confidence, so it defaults to 1.
+	*/
+	synthesizeRootDetection(output, rootStep, idGen, rootStepLatencyMs, imageWidth, imageHeight) {
+		return toMutableRootDetection({
+			class: rootStep.definition.outputClasses[0] ?? rootStep.definition.inputClasses?.[0] ?? rootStep.stepId,
+			score: output.kind === "classifications" ? output.classifications[0]?.score ?? 1 : 1,
+			bbox: [
+				0,
+				0,
+				imageWidth,
+				imageHeight
+			]
+		}, rootStep, idGen, rootStepLatencyMs);
+	}
 	async executeStep(step, input, inputWidth, inputHeight, inputType, _parentBbox, parentClass, traceBuilder, stepTimings, poolAgg) {
 		const preprocessStart = Date.now();
 		const preprocessMs = Date.now() - preprocessStart;
@@ -4318,8 +3081,9 @@ var PipelineExecutor = class {
 		});
 		return output;
 	}
-	async executeChildren(children, parentDetection, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg) {
+	async executeChildren(children, parentDetection, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, nativeFaceCropProvider) {
 		for (const child of children) {
+			if (plane === "frame" && child.definition.inputClasses !== null) continue;
 			if (!this.matchesInputClasses(parentDetection.macroClass, child.inputClasses)) continue;
 			const minParentScore = child.settings?.minParentScore ?? child.definition?.defaultMinParentScore;
 			if (typeof minParentScore === "number" && parentDetection.score < minParentScore) continue;
@@ -4333,23 +3097,43 @@ var PipelineExecutor = class {
 				let cropH;
 				if (modelEntry?.faceAlignment) {
 					const minFaceSize = typeof child.settings?.["minFaceSize"] === "number" ? child.settings["minFaceSize"] : DEFAULT_MIN_FACE_SIZE_PX;
-					const faceShortSide = bboxShortSide(parentDetection.bbox);
-					if (faceShortSide < minFaceSize) {
-						this.throttledWarn(`face-small:${child.stepId}`, 3e4, "face detected but too small to embed — skipping", {
-							step: child.stepId,
-							model: child.modelId,
-							faceShortSidePx: Math.round(faceShortSide),
-							minFaceSizePx: minFaceSize
-						});
+					const detShortSide = bboxShortSide(parentDetection.bbox);
+					if (detShortSide < MIN_FACE_DETECTION_FLOOR_PX) {
+						this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0);
 						continue;
 					}
 					const lms = parentDetection.landmarks;
 					if (lms && lms.length >= 5) {
-						const aligned = await alignFaceCrop(fullFrameJpeg, parentDetection.bbox, lms, imageWidth, imageHeight, { outSize: modelEntry.inputSize.width });
+						if (!nativeFaceCropProvider && detShortSide < minFaceSize) {
+							this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0);
+							continue;
+						}
+						const aligned = await buildAlignedFaceCrop({
+							fullFrameJpeg,
+							faceBbox: parentDetection.bbox,
+							landmarksImageSpace: lms,
+							imageWidth,
+							imageHeight,
+							outSize: modelEntry.inputSize.width,
+							...nativeFaceCropProvider ? {
+								nativeCropProvider: nativeFaceCropProvider,
+								nativeMaxWidth: NATIVE_FACE_CROP_MAX_WIDTH
+							} : {}
+						});
+						const gateShortSide = aligned.nativeFaceShortSidePx ?? detShortSide;
+						if (gateShortSide < minFaceSize) {
+							this.warnFaceTooSmall(child, detShortSide, minFaceSize, aligned.source === "native" ? gateShortSide : void 0);
+							continue;
+						}
 						cropJpegBuf = aligned.jpeg;
 						cropW = aligned.width;
 						cropH = aligned.height;
+						parentDetection.faceAlignedCrop = cropJpegBuf.toString("base64");
 					} else {
+						if (detShortSide < minFaceSize) {
+							this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0);
+							continue;
+						}
 						const crop = await cropJpeg(fullFrameJpeg, parentDetection.bbox, imageWidth, imageHeight);
 						cropJpegBuf = crop.jpeg;
 						cropW = crop.width;
@@ -4379,7 +3163,7 @@ var PipelineExecutor = class {
 								y: l.y + py1
 							}));
 						}
-						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg);
+						await this.executeChildren(child.children, detail, fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, plane, nativeFaceCropProvider);
 					}
 				}
 			} catch (err) {
@@ -4432,7 +3216,7 @@ function buildExecutableTree(steps, getEngine) {
 	return { roots: steps.filter((s) => s.enabled).filter((s) => s.slot !== "audio-classifier").map((s) => buildNode(s, getEngine)) };
 }
 function buildNode(step, getEngine) {
-	const definition = getStepDefinition(step.addonId);
+	const definition = require_step_definitions.getStepDefinition(step.addonId);
 	const engine = getEngine(step.addonId);
 	const children = (step.children ?? []).filter((c) => c.enabled).map((c) => buildNode(c, getEngine));
 	const mergedSettings = {
@@ -4457,7 +3241,7 @@ function buildNode(step, getEngine) {
 * entered recursively. Fields without a declared default are skipped.
 */
 function collectSchemaDefaults(stepId) {
-	const schema = getStep(stepId).getConfigSchema();
+	const schema = require_step_definitions.getStep(stepId).getConfigSchema();
 	const out = {};
 	walkFieldsForDefaults(schema, out);
 	return out;
@@ -4522,7 +3306,7 @@ function collectSubstitutions(steps, format) {
 	for (const step of steps) {
 		const chosen = step.modelId;
 		if (chosen != null) {
-			const running = resolveModelForFormat(step.addonId, chosen, format);
+			const running = require_step_definitions.resolveModelForFormat(step.addonId, chosen, format);
 			if (running !== chosen) result.push({
 				addonId: step.addonId,
 				chosen,
@@ -4548,7 +3332,7 @@ function collectSubstitutions(steps, format) {
 * black-box test. Unknown/custom addonIds (no registered `StepDefinition`)
 * are skipped, never thrown.
 */
-function collectZeroBuildIssues(steps, format, getStepDef = getStepDefinition) {
+function collectZeroBuildIssues(steps, format, getStepDef = require_step_definitions.getStepDefinition) {
 	const result = [];
 	for (const step of steps) {
 		let def;
@@ -4574,7 +3358,7 @@ function collectZeroBuildIssues(steps, format, getStepDef = getStepDefinition) {
 * tests can exercise the unknown-addon branch with a fabricated resolver
 * without `vi.mock`.
 */
-function collectUnknownAddonIssues(steps, getStepDef = getStepDefinition) {
+function collectUnknownAddonIssues(steps, getStepDef = require_step_definitions.getStepDefinition) {
 	const result = [];
 	for (const step of steps) {
 		try {
@@ -4614,13 +3398,13 @@ function resolveInputSteps(steps, format, engine) {
 	for (const s of steps) {
 		let def;
 		try {
-			def = getStepDefinition(s.addonId);
+			def = require_step_definitions.getStepDefinition(s.addonId);
 		} catch {
 			unknownAddonIds.push(s.addonId);
 			continue;
 		}
 		const chosenModelId = s.modelId ?? null;
-		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? resolveDefaultDetectionModel(engine.backend, engine.device, format) : resolveModelForFormat(s.addonId, chosenModelId, format);
+		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? resolveDefaultDetectionModel(engine.backend, engine.device, format) : require_step_definitions.resolveModelForFormat(s.addonId, chosenModelId, format);
 		if (chosenModelId !== null && runningModelId !== chosenModelId) substitutions.push({
 			addonId: s.addonId,
 			chosen: chosenModelId,
@@ -5423,7 +4207,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* first, then the custom registry. Returns undefined if neither has it.
 	*/
 	async resolveModelEntry(addonId, modelId) {
-		const fromCatalog = getStepDefinition(addonId).models.find((m) => m.id === modelId);
+		const fromCatalog = require_step_definitions.getStepDefinition(addonId).models.find((m) => m.id === modelId);
 		if (fromCatalog) return fromCatalog;
 		return (await this.getCustomModels()).get(addonId)?.find((m) => m.id === modelId);
 	}
@@ -5519,7 +4303,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Pure recursive resolver — builds the resolved step tree without touching `modelSubstitutions`. */
 	resolveStepModelTree(steps, format) {
 		return steps.map((step) => {
-			const resolved = resolveModelForFormat(step.addonId, step.modelId ?? null, format);
+			const resolved = require_step_definitions.resolveModelForFormat(step.addonId, step.modelId ?? null, format);
 			const children = step.children?.length ? this.resolveStepModelTree([...step.children], format) : step.children;
 			return resolved === step.modelId && children === step.children ? step : {
 				...step,
@@ -5667,7 +4451,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			for (const step of nodes) {
 				if (!step.enabled) continue;
 				try {
-					if (getStepDefinition(step.addonId).slot === "audio-classifier") continue;
+					if (require_step_definitions.getStepDefinition(step.addonId).slot === "audio-classifier") continue;
 				} catch {
 					continue;
 				}
@@ -5687,7 +4471,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async getCapabilities(_forceRefresh) {
 		const agentId = (this.addonCtx?.kernel?.cluster?.broker)?.nodeID ?? node_os.hostname();
 		const agentName = agentId;
-		const addons = ALL_PIPELINE_STEPS.map((s) => ({
+		const addons = require_step_definitions.ALL_PIPELINE_STEPS.map((s) => ({
 			id: s.definition.id,
 			name: s.definition.name,
 			models: s.definition.models.filter((m) => m.legacy !== true).map((m) => {
@@ -5871,6 +4655,38 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			debug: { totalInferenceMs: 0 }
 		};
 	}
+	/**
+	* Build the design-B native-face-crop provider for a runtime frame. Present
+	* ONLY when the frame arrived as a retention `frameHandle` (the key the owning
+	* pipeline-runner registered the frame's native surface under) and the sibling
+	* `pipeline-runner` cap is reachable via `ctx.api`. Each call is a best-effort
+	* round-trip pinned to the frame's OWNING node (`nodePin(handle.nodeId)` — the
+	* node that decoded it, i.e. THIS node for a local frame, never a cross-node
+	* hop) that returns the native ROI or `null` on a miss; the executor then
+	* falls back to the downscaled crop, so behaviour is never worse than before.
+	*/
+	buildNativeFaceCropProvider(handle) {
+		if (!handle) return void 0;
+		const api = this.addonCtx?.api;
+		if (!api) return void 0;
+		return async (roi, maxWidth) => {
+			try {
+				const native = await api.pipelineRunner.getNativeCrop.query({
+					handle,
+					bbox: roi,
+					...maxWidth !== void 0 ? { maxWidth } : {}
+				}, require_dist.nodePin(handle.nodeId));
+				if (!native || native.width <= 0 || native.height <= 0) return null;
+				return {
+					bytes: native.bytes,
+					width: native.width,
+					height: native.height
+				};
+			} catch {
+				return null;
+			}
+		};
+	}
 	async runPipeline(input, onProgress) {
 		const nodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
 		const sessionId = input.sessionId ?? `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -6127,7 +4943,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const effectiveDeviceId = input.deviceId ?? 0;
 			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
 			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
-			const { result, trace } = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, { traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full" });
+			const nativeFaceCropProvider = this.buildNativeFaceCropProvider(input.frameHandle);
+			const { result, trace } = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
+				traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
+				plane: input.plane
+			}, nativeFaceCropProvider);
 			if (isRuntime) {
 				if (trace && this.eventBus) this.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineTrace, {
 					type: "device",
@@ -7185,7 +6005,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 };
 function buildSchemaSlots(format, modelsDir, customByStep) {
 	const slotMap = /* @__PURE__ */ new Map();
-	for (const pipelineStep of ALL_PIPELINE_STEPS) {
+	for (const pipelineStep of require_step_definitions.ALL_PIPELINE_STEPS) {
 		const step = pipelineStep.definition;
 		const availableModels = mergeCustomModels(step.models, customByStep?.get(step.id) ?? []).filter((m) => m.formats[format] && m.legacy !== true);
 		if (availableModels.length === 0) continue;
@@ -7272,7 +6092,7 @@ function resolveChildSlots(slot) {
 */
 function buildDefaultStepTree(format, objectDetectionModelId) {
 	const makeStep = (stepId, children, opts) => {
-		const def = getStepDefinition(stepId);
+		const def = require_step_definitions.getStepDefinition(stepId);
 		if (!def.models.some((m) => m.formats[format])) return null;
 		return {
 			addonId: def.id,
@@ -7281,7 +6101,7 @@ function buildDefaultStepTree(format, objectDetectionModelId) {
 			inputClasses: def.inputClasses ?? [],
 			outputClasses: def.outputClasses,
 			enabled: opts?.enabled ?? true,
-			modelId: opts?.modelId ?? getDefaultModelForFormat(stepId, format),
+			modelId: opts?.modelId ?? require_step_definitions.getDefaultModelForFormat(stepId, format),
 			children,
 			...def.group ? { group: def.group } : {}
 		};
@@ -8028,7 +6848,7 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends require_dist.B
 		}).catch(() => {});
 	}
 	getModelCatalog() {
-		return ALL_STEPS.flatMap((s) => s.models.filter((m) => m.legacy !== true));
+		return require_step_definitions.ALL_STEPS.flatMap((s) => s.models.filter((m) => m.legacy !== true));
 	}
 	/**
 	* Proactively install the OpenVINO Python package when Intel hardware
@@ -8136,10 +6956,10 @@ var DetectionPipelineAddon = class DetectionPipelineAddon extends require_dist.B
 	}
 };
 //#endregion
-exports.ALL_STEPS = ALL_STEPS;
+exports.ALL_STEPS = require_step_definitions.ALL_STEPS;
 exports.DetectionPipelineProvider = DetectionPipelineProvider;
 exports.backendToFormat = backendToFormat;
 exports.default = DetectionPipelineAddon;
-exports.getDefaultModelForFormat = getDefaultModelForFormat;
-exports.getStepDefinition = getStepDefinition;
+exports.getDefaultModelForFormat = require_step_definitions.getDefaultModelForFormat;
+exports.getStepDefinition = require_step_definitions.getStepDefinition;
 exports.shouldInstallOpenvino = shouldInstallOpenvino;