@camstack/addon-pipeline 1.1.53 → 1.1.55

package/dist/detection-pipeline/index.mjs

@@ -1,5 +1,6 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { H as createEvent, I as errMsg, L as BaseAddon, O as pipelineExecutorCapability, P as supportedRuntimes$1, S as hfModelUrl, U as hydrateSchema, V as EventCategory, X as sleep, a as COCO_TO_MACRO, b as detectionPipelineCapability, f as YAMNET_TO_MACRO, i as COCO_80_LABELS, j as runtimeDevices$1, q as parseJsonUnknown, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, v as defaultDeviceFor$1, x as evaluateZoneRules } from "../dist-BalxNwOt.mjs";
+import { D as nodePin, H as createEvent, I as errMsg, L as BaseAddon, O as pipelineExecutorCapability, P as supportedRuntimes$1, U as hydrateSchema, V as EventCategory, X as sleep, b as detectionPipelineCapability, f as YAMNET_TO_MACRO, j as runtimeDevices$1, q as parseJsonUnknown, t as APPLE_SA_TO_MACRO, v as defaultDeviceFor$1, x as evaluateZoneRules } from "../dist-RWGGPwVx.mjs";
+import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-CP9kVSml.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
@@ -290,1437 +291,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) => 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("")];
-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: 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]
-	};
-	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: 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
 //#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";
@@ -3715,6 +2285,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 sharp(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
@@ -3942,7 +2616,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({
@@ -4023,7 +2698,8 @@ function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
 			mask: det.mask,
 			maskWidth: det.maskWidth,
 			maskHeight: det.maskHeight
-		} : {}
+		} : {},
+		...det.landmarks !== void 0 ? { landmarks: det.landmarks } : {}
 	};
 }
 //#endregion
@@ -4141,6 +2817,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) {
@@ -4158,6 +2861,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
@@ -4170,7 +2890,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);
@@ -4193,7 +2913,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: errMsg(err)
+							}
+						});
+					}
+					firstLevel.push(mutable);
+				}
+				continue;
+			}
 			for (const det of rootOutput.detections) {
 				const mutable = toMutableRootDetection(det, rootStep, idGen, rootMs);
 				if (rootStep.definition.classMap) {
@@ -4208,7 +2948,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 },
@@ -4244,6 +2984,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;
@@ -4310,8 +3073,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;
@@ -4325,23 +3089,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;
@@ -4371,7 +3155,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) {
@@ -5863,6 +4647,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 } : {}
+				}, 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)}`;
@@ -6119,7 +4935,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(createEvent(EventCategory.PipelineTrace, {
 					type: "device",