@camstack/addon-pipeline 1.2.338 → 1.2.339

package/dist/model-catalogs-x1G07ScE.mjs

@@ -0,0 +1,1445 @@
+import { wt as hfModelUrl } from "./dist-BylL-kRe.mjs";
+//#region src/detection-pipeline/registry/model-licenses.ts
+var COCO_DATA = {
+	name: "COCO 2017",
+	terms: "annotations CC-BY-4.0; images under their Flickr owners' terms",
+	url: "https://cocodataset.org/#termsofuse"
+};
+var WIDER_FACE_DATA = {
+	name: "WIDER FACE",
+	terms: "research-oriented terms; images CC BY-NC-ND",
+	url: "http://shuoyang1213.me/WIDERFACE/"
+};
+var ULTRALYTICS_AGPL = {
+	weights: "AGPL-3.0",
+	code: "AGPL-3.0",
+	data: COCO_DATA,
+	upstream: {
+		name: "Ultralytics",
+		url: "https://github.com/ultralytics/ultralytics"
+	},
+	url: "https://github.com/ultralytics/ultralytics/blob/main/LICENSE",
+	attribution: "© Ultralytics, AGPL-3.0. Corresponding source: the upstream Ultralytics checkpoint and build-camstack-models.py (with convert_lib.py) published at https://huggingface.co/camstack/camstack-models/tree/main/source.",
+	modifications: "exported to ONNX, OpenVINO IR and CoreML (scripts/build-camstack-models.py)",
+	hosting: "camstack-hf"
+};
+var ULTRALYTICS_YOLOV9_AGPL = {
+	...ULTRALYTICS_AGPL,
+	attribution: "© Ultralytics, AGPL-3.0 (Ultralytics YOLOv9 weights). YOLOv9 architecture: Chien-Yao Wang, I-Hau Yeh, Hong-Yuan Mark Liao, GPL-3.0 (https://github.com/WongKinYiu/yolov9). Corresponding source: the upstream Ultralytics checkpoint and build-camstack-models.py (with convert_lib.py) published at https://huggingface.co/camstack/camstack-models/tree/main/source."
+};
+/** The CamStack Coral COCO detector (SSD MobileNet V2). */
+var CORAL_COCO_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	upstream: {
+		name: "Google Coral test_data",
+		url: "https://github.com/google-coral/test_data"
+	},
+	url: "https://github.com/google-coral/test_data/blob/master/LICENSE",
+	attribution: "Coral Edge TPU models and AIY Vision Birds V1 © Google LLC, Apache-2.0.",
+	hosting: "third-party",
+	data: COCO_DATA
+};
+var RFDETR_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "parcel fine-tuning set (not recorded)",
+		terms: "UNVERIFIED"
+	},
+	upstream: {
+		name: "Roboflow RF-DETR",
+		url: "https://github.com/roboflow/rf-detr"
+	},
+	url: "https://github.com/roboflow/rf-detr/blob/develop/LICENSE",
+	attribution: "RF-DETR © Roboflow, Apache-2.0.",
+	modifications: "RF-DETR-M fine-tuned to 2 classes at 576; exported to ONNX, OpenVINO IR and CoreML; training checkpoint .pth also published",
+	hosting: "camstack-hf"
+};
+var YUNET_MIT = {
+	weights: "MIT",
+	code: "BSD-3-Clause",
+	data: WIDER_FACE_DATA,
+	upstream: {
+		name: "OpenCV Zoo YuNet",
+		url: "https://github.com/opencv/opencv_zoo/tree/main/models/face_detection_yunet"
+	},
+	url: "https://github.com/opencv/opencv_zoo/blob/main/models/face_detection_yunet/LICENSE",
+	attribution: "YuNet weights Copyright (c) 2020 Shiqi Yu, MIT. Training code: ShiqiYu/libfacedetection.train, BSD-3-Clause.",
+	modifications: "input contract baked into the graph (the pool RGB /255 becomes the upstream BGR 0..255: Mul(255) plus a channel Gather); internal tensor names cleared in the OpenVINO IR; ONNX fp32, OpenVINO IR fp32, CoreML fp16 (scripts/build-yunet-model.py); Edge TPU build: the bake folded into the first Conv, full-integer int8 post-training quantisation calibrated on CamStack person crops, compiled with edgetpu_compiler 14 (scripts/build-yunet-edgetpu.py)",
+	hosting: "camstack-hf"
+};
+var AURAFACE_APACHE = {
+	weights: "Apache-2.0",
+	upstream: {
+		name: "fal.ai AuraFace v1 (glintr100.onnx only)",
+		url: "https://huggingface.co/fal/AuraFace-v1"
+	},
+	url: "https://huggingface.co/fal/AuraFace-v1",
+	attribution: "AuraFace v1 by fal.ai, Apache-2.0.",
+	modifications: "input scaling y = 2x - 1 baked ahead of the first Conv (scripts/build-auraface-model.py); converted to OpenVINO IR and CoreML FP16",
+	hosting: "camstack-hf"
+};
+/**
+* open-lpr's YOLOX-tiny plate detector (D719). Weights Apache-2.0 by the
+* open-lpr repository licence and NOTICE (YOLOX code and its same-repository
+* COCO weights are Apache-2.0; no Ultralytics weights used) — the weights'
+* status is inferred from that statement, not from a per-file licence. The
+* NOTICE travels verbatim (Apache-2.0 §4(d)): licenses/models/NOTICE-open-lpr.txt
+* and the mirror folder's own NOTICE.
+*/
+var OPEN_LPR_YOLOX_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "Simanno annotated plate corpus plus community-contributed photographs, pseudo-labelled by a teacher model (not published; the upstream NOTICE says the photographs were uploaded without consent obtained)",
+		terms: "UNKNOWN"
+	},
+	upstream: {
+		name: "open-lpr models (faisalthaheem/open-lpr-models), YOLOX-tiny",
+		url: "https://huggingface.co/faisalthaheem/open-lpr-models"
+	},
+	url: "https://huggingface.co/faisalthaheem/open-lpr-models/blob/aed0df35ec2891c5a90437041ebeadb592cc516b/LICENSE",
+	attribution: "open-lpr models, Copyright the open-lpr contributors, Apache-2.0 (https://huggingface.co/faisalthaheem/open-lpr-models, tag detector-2026.10.1). YOLOX architecture and COCO pretraining by Megvii (https://github.com/Megvii-BaseDetection/YOLOX), Apache-2.0. The upstream NOTICE is reproduced verbatim (`NOTICE-open-lpr.txt`).",
+	modifications: "input contract baked into the graph (static 1x3x640x640 RGB /255 becomes the upstream BGR 0..255: Mul(255) plus a channel Gather) and the output reshaped to the YOLOv8 layout (cx, cy, w, h, obj*cls); ONNX fp32, OpenVINO IR fp16, CoreML fp16 (scripts/build-yolox-plate-model.py); Edge TPU build: the Focus stem rewritten as the equivalent 6x6 stride-2 Conv with the input bake folded into it, the graph cut before the grid decode (raw per-stride head), full-integer int8 post-training quantisation calibrated on CamStack vehicle crops, compiled with edgetpu_compiler 14 (scripts/build-yolox-plate-edgetpu.py)",
+	hosting: "camstack-hf"
+};
+var FAST_PLATE_OCR_MIT = {
+	weights: "MIT",
+	code: "MIT",
+	data: {
+		name: "fast-plate-ocr training set",
+		terms: "private, not released upstream"
+	},
+	upstream: {
+		name: "ankandrew/fast-plate-ocr",
+		url: "https://github.com/ankandrew/fast-plate-ocr"
+	},
+	url: "https://github.com/ankandrew/fast-plate-ocr/blob/master/LICENSE",
+	attribution: "fast-plate-ocr, MIT License, copyright (c) 2024 ankandrew (full notice: licenses/models/MIT-fast-plate-ocr.txt).",
+	modifications: "input head removed (recorded in the ONNX doc_string); converted to OpenVINO IR and CoreML",
+	hosting: "camstack-hf"
+};
+var ANIMAL_CLASSIFIER_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "Open Images V7",
+		terms: "annotations CC-BY-4.0 (Google LLC); images listed as CC-BY-2.0, no warranty",
+		url: "https://storage.googleapis.com/openimages/web/factsfigures_v7.html"
+	},
+	upstream: {
+		name: "timm EfficientNet-Lite0, fine-tuned by CamStack",
+		url: "https://github.com/huggingface/pytorch-image-models"
+	},
+	url: "https://github.com/huggingface/pytorch-image-models/blob/main/LICENSE",
+	attribution: "EfficientNet-Lite0 via timm (Ross Wightman), Apache-2.0. Open Images V7 annotations © Google LLC, CC BY 4.0; images listed by Google as CC BY 2.0, without warranty.",
+	modifications: "fine-tuned by CamStack on the Open Images V7 animal subset (8 classes); exported to ONNX, OpenVINO IR and CoreML",
+	hosting: "camstack-hf"
+};
+var AIY_BIRDS_APACHE = {
+	weights: "Apache-2.0",
+	upstream: {
+		name: "Google AIY Vision birds_V1",
+		url: "https://github.com/google-coral/test_data"
+	},
+	url: "https://github.com/google-coral/test_data/blob/master/LICENSE",
+	attribution: "Coral Edge TPU models and AIY Vision Birds V1 © Google LLC, Apache-2.0.",
+	modifications: "converted from TensorFlow with tf2onnx; OpenVINO IR and CoreML derived from it; the Edge TPU build is the Google full-integer quantised TFLite of the same model, compiled with edgetpu_compiler 14 (scripts/build-bird-classifier-edgetpu.py)",
+	hosting: "camstack-hf"
+};
+var VEHICLE_TYPE_V1_NC = {
+	weights: "CC-BY-NC-4.0",
+	code: "BSD-3-Clause",
+	data: {
+		name: "DrBimmer/vehicle-classification",
+		terms: "CC-BY-NC-4.0 — treated as binding the trained weights (conservative reading)",
+		url: "https://huggingface.co/datasets/DrBimmer/vehicle-classification"
+	},
+	upstream: {
+		name: "torchvision MobileNetV3-Large, fine-tuned by CamStack",
+		url: "https://github.com/pytorch/vision"
+	},
+	url: "https://creativecommons.org/licenses/by-nc/4.0/",
+	attribution: "torchvision MobileNetV3, BSD-3-Clause. Trained on the Vehicle classification dataset by DrBimmer (https://huggingface.co/datasets/DrBimmer/vehicle-classification), CC BY-NC 4.0.",
+	modifications: "fine-tuned by CamStack (8 classes); exported to ONNX, OpenVINO IR and CoreML",
+	hosting: "camstack-hf",
+	nonCommercial: true
+};
+var U2NET_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "DUTS-TR",
+		terms: "not checked"
+	},
+	upstream: {
+		name: "xuebinqin/U-2-Net",
+		url: "https://github.com/xuebinqin/U-2-Net"
+	},
+	url: "https://github.com/xuebinqin/U-2-Net/blob/master/LICENSE",
+	attribution: "U²-Net © Xuebin Qin et al., Apache-2.0.",
+	modifications: "converted to ONNX, OpenVINO IR and CoreML",
+	hosting: "camstack-hf"
+};
+var SIGLIP2_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "WebLI",
+		terms: "Google internal, not released"
+	},
+	upstream: {
+		name: "Google SigLIP 2 (google/siglip2-base-patch16-224)",
+		url: "https://huggingface.co/google/siglip2-base-patch16-224"
+	},
+	url: "https://huggingface.co/google/siglip2-base-patch16-224",
+	attribution: "SigLIP 2 © Google LLC, Apache-2.0.",
+	modifications: "input scaling y = 2x - 1 baked ahead of the patch embedding; converted to OpenVINO IR and CoreML FP16, an FP32 ONNX hosted as the verification reference (scripts/build-siglip2-model.py)",
+	hosting: "camstack-hf"
+};
+var YAMNET_APACHE = {
+	weights: "Apache-2.0",
+	code: "Apache-2.0",
+	data: {
+		name: "AudioSet ontology/labels",
+		terms: "CC-BY-4.0 (Google LLC)",
+		url: "https://research.google.com/audioset/"
+	},
+	upstream: {
+		name: "tensorflow/models research/audioset/yamnet",
+		url: "https://github.com/tensorflow/models/tree/master/research/audioset/yamnet"
+	},
+	url: "https://github.com/tensorflow/models/blob/master/LICENSE",
+	attribution: "YAMNet © Google LLC, Apache-2.0. AudioSet ontology and labels © Google LLC, CC BY 4.0.",
+	modifications: "converted from TensorFlow with tf2onnx; OpenVINO IR derived from it",
+	hosting: "camstack-hf"
+};
+var APPLE_SOUNDANALYSIS = {
+	weights: "LicenseRef-Apple-macOS",
+	upstream: {
+		name: "Apple SoundAnalysis (macOS built-in)",
+		url: "https://developer.apple.com/documentation/soundanalysis"
+	},
+	url: "https://www.apple.com/legal/sla/",
+	hosting: "built-in"
+};
+/** Compose a per-entry record: same upstream, entry-specific modifications / data. */
+function licensed(base, overrides) {
+	return {
+		...base,
+		...overrides
+	};
+}
+//#endregion
+//#region src/detection-pipeline/registry/model-catalogs.ts
+var HF_REPO = "camstack/camstack-models";
+var hf = (path) => hfModelUrl(HF_REPO, 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: precision === "int8" ? `${baseName} — OpenVINO INT8 variant for Intel iGPU/CPU; scale by hardware. On the Intel NPU it loses recall — use the base model there` : `${baseName} — OpenVINO ${precision.toUpperCase()} variant for Intel iGPU/NPU; scale by hardware`,
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [],
+	preprocessMode: "letterbox",
+	license: licensed(ULTRALYTICS_AGPL, { modifications: precision === "int8" ? "exported to OpenVINO IR, then OpenVINO NNCF INT8 post-training quantisation" : "OpenVINO FP16 export" }),
+	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",
+		resolution: 640
+	} } : {}
+});
+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"
+};
+var YOLOV9_TIER_NAME = {
+	t: "Tiny",
+	s: "Small",
+	m: "Medium",
+	c: "Compact"
+};
+/**
+* The Ultralytics YOLOv9 family (COCO-pretrained Ultralytics weights,
+* re-exported by CamStack — not trained by us) — the default NPU-detection line.
+* It runs on the Intel NPU ("AI Boost"), and its INT8 builds are as accurate
+* there as on the CPU. YOLO26 runs on the NPU too since OpenVINO 2025.4
+* (measured 2026-10-07): its base IRs match the CPU, its INT8 IRs lose recall
+* there (see `yolo26Reduced`). Empirically: the yolov9t-320-int8 export = ~298 fps on the
+* NPU vs yolo26n = 103 on the iGPU (~2.9×). t/s/m/c × {320,640}; each size ships
+* a base entry (onnx + coreml + openvino **fp16**) + an OpenVINO **int8** entry
+* (the NPU/iGPU-optimal config). CoreML (fp16) runs on the Mac ANE — the
+* apple-ane default detector (`default-detection-model.ts`).
+*
+* The CoreML packages were FP32 until 2026-10-07 and ran on the Mac GPU, never
+* the ANE. The FP16 re-export replaced them IN PLACE (same file names); the
+* revision every mirror artefact carries (the sha256 of its weight file, from
+* the downloader's generated table) makes a node holding the FP32 copy fetch
+* the FP16 one (D743, D744).
+*/
+var yolov9Reduced = (tier, res, sizes) => {
+	const name = YOLOV9_TIER_NAME[tier] ?? tier.toUpperCase();
+	return [{
+		id: `yolov9${tier}-${res}`,
+		group: {
+			family: "yolov9",
+			tier,
+			resolution: res
+		},
+		name: `YOLOv9 ${name} @${res}`,
+		description: `YOLOv9 ${name} @${res}×${res} (Ultralytics) — OpenVINO fp16, runs on Intel NPU + iGPU.`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		license: licensed(ULTRALYTICS_YOLOV9_AGPL, { modifications: `exported at ${res}×${res} to ONNX, OpenVINO IR FP16 and CoreML` }),
+		formats: {
+			onnx: {
+				url: hf(`objectDetection/yolov9/onnx/camstack-yolov9${tier}-${res}.onnx`),
+				sizeMB: sizes.onnx
+			},
+			coreml: {
+				url: hf(`objectDetection/yolov9/coreml/camstack-yolov9${tier}-${res}.mlpackage`),
+				sizeMB: sizes.coreml,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf(`objectDetection/yolov9/openvino/camstack-yolov9${tier}-${res}-fp16.xml`), sizes.ovFp16)
+		}
+	}, {
+		id: `yolov9${tier}-${res}-int8`,
+		group: {
+			family: "yolov9",
+			tier,
+			precision: "int8",
+			resolution: res
+		},
+		name: `YOLOv9 ${name} @${res} (INT8)`,
+		description: `YOLOv9 ${name} @${res} — OpenVINO INT8 for the Intel NPU / iGPU. The NPU's fastest config (Ultralytics YOLOv9 weights).`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		license: licensed(ULTRALYTICS_YOLOV9_AGPL, { modifications: `exported at ${res}×${res} to OpenVINO IR; OpenVINO NNCF INT8 post-training quantisation` }),
+		formats: { openvino: ovFormat(hf(`objectDetection/yolov9/openvino/camstack-yolov9${tier}-${res}-int8.xml`), sizes.ovInt8) }
+	}];
+};
+/**
+* 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.
+*
+* Intel NPU (OpenVINO 2025.4, measured 2026-10-07): every YOLO26 IR compiles
+* and runs. The base IRs are as accurate as the CPU; the INT8 IRs lose recall
+* there (`yolo26s-int8` 0.58 on the NPU vs 0.70 on CPU/iGPU, `yolo26m-int8`
+* 0.78 vs 0.83), so on an NPU the base IR is the one to run.
+*/
+var yolo26Reduced = (tier, res, sizes) => {
+	const name = YOLO26_TIER_NAME[tier] ?? tier.toUpperCase();
+	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",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: `re-exported at ${res}×${res} to ONNX, OpenVINO IR and CoreML` }),
+		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. On the Intel NPU it loses recall — use the base model there`,
+		inputSize: {
+			width: res,
+			height: res
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: `re-exported at ${res}×${res} to OpenVINO IR; OpenVINO NNCF INT8 post-training quantisation` }),
+		formats: { openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}-int8.xml`), sizes.ovInt8) }
+	}];
+};
+/** Variant family of the YOLO26 builds with an instance-segmentation head. */
+var YOLO26_SEG_FAMILY = "yolo26-seg";
+/** What choosing a seg build as the root means, in the catalog's own words. */
+var YOLO26_SEG_ROOT_NOTE = "As the root model it detects like YOLO26 and also supplies the Segmentation step its masks (detection + masks, slightly heavier).";
+var OBJECT_DETECTION_MODEL_ENTRIES = [
+	{
+		id: "yolo26n",
+		license: ULTRALYTICS_AGPL,
+		group: {
+			family: "yolo26",
+			tier: "n",
+			resolution: 640
+		},
+		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",
+		license: ULTRALYTICS_AGPL,
+		group: {
+			family: "yolo26",
+			tier: "s",
+			resolution: 640
+		},
+		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",
+		license: ULTRALYTICS_AGPL,
+		group: {
+			family: "yolo26",
+			tier: "m",
+			resolution: 640
+		},
+		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",
+		license: ULTRALYTICS_AGPL,
+		group: {
+			family: "yolo26",
+			tier: "l",
+			resolution: 640
+		},
+		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",
+		license: ULTRALYTICS_AGPL,
+		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: "ssd-mobilenet-v2-coco-edgetpu",
+		license: CORAL_COCO_APACHE,
+		name: "SSD MobileNet V2 (Coral)",
+		description: "SSD MobileNet V2 COCO — EdgeTPU-compiled full-integer TFLite, 300×300; runs on the Coral USB Edge TPU (~11 ms/frame)",
+		inputSize: {
+			width: 300,
+			height: 300
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "ssd",
+		formats: { tflite: {
+			url: "https://github.com/google-coral/test_data/raw/master/ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite",
+			sizeMB: 6.6,
+			runtimes: ["python"]
+		} }
+	},
+	{
+		id: "yolo26n-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "n",
+			resolution: 640
+		},
+		name: "YOLO26-seg Nano",
+		description: `YOLO26 Nano with its instance-segmentation head — ultra-lightweight. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
+				sizeMB: 11
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
+				sizeMB: 6,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
+		}
+	},
+	{
+		id: "yolo26s-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "s",
+			resolution: 640
+		},
+		name: "YOLO26-seg Small",
+		description: `YOLO26 Small with its instance-segmentation head — balanced. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
+				sizeMB: 40
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
+				sizeMB: 20,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
+		}
+	},
+	{
+		id: "yolo26m-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "m",
+			resolution: 640
+		},
+		name: "YOLO26-seg Medium",
+		description: `YOLO26 Medium with its instance-segmentation head — high accuracy. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
+				sizeMB: 90
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
+				sizeMB: 45,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
+		}
+	},
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5, true),
+	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
+	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19, true),
+	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
+	}),
+	...yolov9Reduced("t", 320, {
+		onnx: 8,
+		coreml: 4.3,
+		ovFp16: 4,
+		ovInt8: 3
+	}),
+	...yolov9Reduced("t", 640, {
+		onnx: 8,
+		coreml: 4.4,
+		ovFp16: 4,
+		ovInt8: 3
+	}),
+	...yolov9Reduced("s", 320, {
+		onnx: 27,
+		coreml: 14.1,
+		ovFp16: 14,
+		ovInt8: 8
+	}),
+	...yolov9Reduced("s", 640, {
+		onnx: 27,
+		coreml: 14.1,
+		ovFp16: 14,
+		ovInt8: 8
+	}),
+	...yolov9Reduced("m", 320, {
+		onnx: 76,
+		coreml: 38.6,
+		ovFp16: 38,
+		ovInt8: 20
+	}),
+	...yolov9Reduced("m", 640, {
+		onnx: 76,
+		coreml: 38.6,
+		ovFp16: 38,
+		ovInt8: 20
+	}),
+	...yolov9Reduced("c", 320, {
+		onnx: 97,
+		coreml: 48.7,
+		ovFp16: 49,
+		ovInt8: 25
+	}),
+	...yolov9Reduced("c", 640, {
+		onnx: 97,
+		coreml: 48.7,
+		ovFp16: 49,
+		ovInt8: 25
+	}),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "fp16", 112, true),
+	ovPrecisionVariant("yolo26x", "objectDetection/yolo26/openvino", "YOLO26 XLarge", "int8", 56, true)
+];
+/**
+* The per-class confidence-floor DEFAULTS of each object-detection model
+* (D738), keyed by model id. Applied onto the catalog entries below as
+* `defaultClassFloors`; this is the ONLY place a model's floor is written. A
+* model absent here runs at the step slider's global default
+* (`ObjectDetectionStep.getConfigSchema`: person 0.65, vehicle 0.50, animal
+* 0.50).
+*
+* Measured 2026-10-07 (`docs/benchmarks/model-floors.json`, which also holds
+* precision/recall per class): the floor is the lowest score at which the model
+* makes no more false positives than the production root (`yolov9m-320-int8` at
+* 0.65 / 0.50 / 0.50) on the same 409 hub frames, against an ensemble
+* pseudo-ground-truth, rounded to 0.05, minimum 0.25. Floors carry about
+* +/-0.05-0.10 of noise. Where a floor hinges on a single high-score false
+* positive, the next-lower value the measurement gives is used instead (marked
+* below). A re-measurement replaces the JSON and these rows together; a spec
+* holds them equal.
+*
+* `package` is not calibrated (7 objects in the set) and stays at its global
+* default. Every catalog model NOT listed here (the 256 builds, yolo26 l/x,
+* the seg builds, the fp16 legacy IRs) is untuned and runs at the global
+* defaults.
+*/
+var OBJECT_DETECTION_CLASS_FLOORS = {
+	"ssd-mobilenet-v2-coco-edgetpu": {
+		person: .6,
+		vehicle: .35,
+		animal: .4
+	},
+	yolo26m: {
+		person: .4,
+		vehicle: .25,
+		animal: .3
+	},
+	"yolo26m-320": {
+		person: .7,
+		vehicle: .3,
+		animal: .4
+	},
+	"yolo26m-320-int8": {
+		person: .6,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolo26m-int8": {
+		person: .4,
+		vehicle: .35,
+		animal: .45
+	},
+	yolo26n: {
+		person: .65,
+		vehicle: .4,
+		animal: .5
+	},
+	"yolo26n-320": {
+		person: .6,
+		vehicle: .6,
+		animal: .4
+	},
+	"yolo26n-320-int8": {
+		person: .45,
+		vehicle: .55,
+		animal: .35
+	},
+	"yolo26n-int8": {
+		person: .55,
+		vehicle: .3,
+		animal: .4
+	},
+	yolo26s: {
+		person: .4,
+		vehicle: .45,
+		animal: .4
+	},
+	"yolo26s-320": {
+		person: .6,
+		vehicle: .45,
+		animal: .45
+	},
+	"yolo26s-320-int8": {
+		person: .5,
+		vehicle: .55,
+		animal: .45
+	},
+	"yolo26s-int8": {
+		person: .4,
+		vehicle: .3,
+		animal: .4
+	},
+	"yolov9c-320": {
+		person: .7,
+		vehicle: .45,
+		animal: .45
+	},
+	"yolov9c-320-int8": {
+		person: .7,
+		vehicle: .5,
+		animal: .25
+	},
+	"yolov9c-640": {
+		person: .55,
+		vehicle: .45,
+		animal: .3
+	},
+	"yolov9c-640-int8": {
+		person: .45,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolov9m-320": {
+		person: .7,
+		vehicle: .5,
+		animal: .55
+	},
+	"yolov9m-320-int8": {
+		person: .65,
+		vehicle: .4,
+		animal: .45
+	},
+	"yolov9m-640": {
+		person: .6,
+		vehicle: .4,
+		animal: .55
+	},
+	"yolov9m-640-int8": {
+		person: .55,
+		vehicle: .4,
+		animal: .7
+	},
+	"yolov9s-320": {
+		person: .7,
+		vehicle: .55,
+		animal: .4
+	},
+	"yolov9s-320-int8": {
+		person: .7,
+		vehicle: .45,
+		animal: .4
+	},
+	"yolov9s-640": {
+		person: .7,
+		vehicle: .4,
+		animal: .6
+	},
+	"yolov9s-640-int8": {
+		person: .5,
+		vehicle: .3,
+		animal: .55
+	},
+	"yolov9t-320": {
+		person: .55,
+		vehicle: .45,
+		animal: .3
+	},
+	"yolov9t-320-int8": {
+		person: .55,
+		vehicle: .4,
+		animal: .3
+	},
+	"yolov9t-640": {
+		person: .65,
+		vehicle: .5,
+		animal: .5
+	},
+	"yolov9t-640-int8": {
+		person: .6,
+		vehicle: .55,
+		animal: .55
+	}
+};
+/**
+* The floor on the DETECTION score below which a root detector's own fine
+* label (a species, a vehicle type — the D736 root supply) is not taken (D741).
+* Keyed by root model, then by the supplied step. Below it the detection keeps
+* its macro class with no fine label; it is never dropped. A floor of 1 means
+* "never take this label from this root". A root or step absent here has no
+* extra floor — the macro floor alone gates the label, as before D741.
+*
+* Measured 2026-10-07 (`docs/benchmarks/classifier-floors.json`): the
+* lowest detection score from which the root's species was right ~90% of the
+* time, against a two-model zero-shot reference on 219 animal crops dominated
+* by one dog. Unlisted roots behave alike — ~0.89-0.90 at the macro floor for
+* 640 roots, ~0.74 for 320 roots. Vehicle types needed no extra floor on any
+* root (0.99-1.00 at the macro floor). The Coral SSD named the species wrongly
+* three times in four.
+*/
+var ROOT_SUPPLIED_LABEL_FLOORS = {
+	"yolov9m-320-int8": { "animal-classifier": .75 },
+	"yolov9m-640-int8": { "animal-classifier": .7 },
+	"yolov9c-640-int8": { "animal-classifier": .75 },
+	yolo26s: { "animal-classifier": .45 },
+	yolo26m: { "animal-classifier": .7 },
+	"yolo26s-int8": { "animal-classifier": .55 },
+	"ssd-mobilenet-v2-coco-edgetpu": { "animal-classifier": 1 }
+};
+/** Stamp each entry's row of `floors` on it as `suppliedLabelFloors`. Fresh objects only. */
+function withSuppliedLabelFloors(entries, floors) {
+	return entries.map((entry) => {
+		const row = floors[entry.id];
+		return row === void 0 ? entry : {
+			...entry,
+			suppliedLabelFloors: { ...row }
+		};
+	});
+}
+/** Stamp each entry's row of `floors` on it as `defaultClassFloors`. Fresh objects only. */
+function withDefaultClassFloors(entries, floors) {
+	return entries.map((entry) => {
+		const row = floors[entry.id];
+		return row === void 0 ? entry : {
+			...entry,
+			defaultClassFloors: { ...row }
+		};
+	});
+}
+/**
+* Object-detection IRs that need f32 inference on an Intel GPU
+* (`gpuInferencePrecision`). At the GPU's default f16 the YOLO26 FP32 IRs of
+* the larger tiers return no valid detection — measured 2026-10-07 on the Core
+* Ultra iGPU and the N100: `yolo26s` (640) 0 true / 146 false positives,
+* `yolo26m` and `yolo26m-320` NaN scores; at f32 they match the CPU, at ~60%
+* more GPU latency. `yolo26n`, `yolo26n-320` and `yolo26s-320` were measured
+* correct at f16 and are NOT listed. The rest of the list is the same pattern
+* not yet measured (tier m / l / x at any input, tier s at 640, the seg builds
+* of those tiers): f32 costs latency, f16 risks a detector that silently finds
+* nothing. INT8 IRs and every YOLOv9 IR are correct at the device default.
+*/
+var OPENVINO_GPU_F32_MODEL_IDS = new Set([
+	"yolo26s",
+	"yolo26m",
+	"yolo26m-320",
+	"yolo26m-256",
+	"yolo26l",
+	"yolo26l-320",
+	"yolo26l-256",
+	"yolo26x",
+	"yolo26s-seg",
+	"yolo26m-seg"
+]);
+/** Stamp `gpuInferencePrecision: 'f32'` on the listed entries. Fresh objects only. */
+function withGpuF32(entries, ids) {
+	return entries.map((entry) => ids.has(entry.id) ? {
+		...entry,
+		gpuInferencePrecision: "f32"
+	} : entry);
+}
+[...OPENVINO_GPU_F32_MODEL_IDS];
+var OBJECT_DETECTION_MODELS = withSuppliedLabelFloors(withGpuF32(withDefaultClassFloors(OBJECT_DETECTION_MODEL_ENTRIES, OBJECT_DETECTION_CLASS_FLOORS), OPENVINO_GPU_F32_MODEL_IDS), ROOT_SUPPLIED_LABEL_FLOORS);
+var FACE_DETECTION_MODELS = [{
+	id: "yunet-2023mar",
+	license: YUNET_MIT,
+	name: "YuNet 2023mar",
+	description: "YuNet (OpenCV Zoo, 2023mar) — tiny face detector with 5 keypoints, MIT weights (WIDER FACE AP 0.884/0.866/0.750). ~0.2 MB. Trained on WIDER FACE (CC BY-NC-ND images).",
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [{
+		id: "face",
+		name: "Face"
+	}],
+	preprocessMode: "letterbox",
+	postprocessor: "yunet",
+	defaultConfidence: .7,
+	formats: {
+		onnx: {
+			url: hf("faceDetection/yunet/onnx/camstack-yunet-2023mar.onnx"),
+			sizeMB: .23
+		},
+		coreml: {
+			url: hf("faceDetection/yunet/coreml/camstack-yunet-2023mar.mlpackage"),
+			sizeMB: .2,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceDetection/yunet/openvino/camstack-yunet-2023mar.xml"), .36),
+		tflite: {
+			url: hf("faceDetection/yunet/tflite/camstack-yunet-2023mar_edgetpu.tflite"),
+			sizeMB: .7,
+			runtimes: ["python"]
+		}
+	}
+}];
+var FACE_EMBEDDING_MODELS = [{
+	id: "auraface-r100",
+	license: AURAFACE_APACHE,
+	name: "AuraFace R100",
+	description: "AuraFace v1 (fal.ai) — iResNet-100 ArcFace face recognition embeddings (512-d), Apache-2.0. Benchmarks published by fal: LFW 99.65, CFP-FP 95.19, AgeDB 96.10, CALFW 94.70, CPLFW 90.93. Genuinely a ResNet-100 (65 M params) — roughly twice the depth of the former `arcface-r100` entry, which was a ResNet34.",
+	inputSize: {
+		width: 112,
+		height: 112
+	},
+	labels: [{
+		id: "embedding",
+		name: "Face Embedding"
+	}],
+	preprocessMode: "resize",
+	faceAlignment: true,
+	formats: {
+		onnx: {
+			url: hf("faceRecognition/auraface/onnx/camstack-auraface-r100.onnx"),
+			sizeMB: 261
+		},
+		coreml: {
+			url: hf("faceRecognition/auraface/coreml/camstack-auraface-r100.mlpackage"),
+			sizeMB: 131,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("faceRecognition/auraface/openvino/camstack-auraface-r100.xml"), 131)
+	}
+}];
+var PLATE_DETECTION_MODELS = [{
+	id: "yolox-tiny-plate",
+	license: OPEN_LPR_YOLOX_APACHE,
+	name: "YOLOX-tiny — License Plate",
+	description: "YOLOX-tiny licence-plate detector trained by the open-lpr project (Apache-2.0)",
+	inputSize: {
+		width: 640,
+		height: 640
+	},
+	labels: [{
+		id: "plate",
+		name: "License Plate"
+	}],
+	preprocessMode: "letterbox",
+	postprocessor: "yolo",
+	formats: {
+		onnx: {
+			url: hf("plateDetection/yolox-tiny-plate/onnx/camstack-yolox-tiny-plate.onnx"),
+			sizeMB: 19.3
+		},
+		coreml: {
+			url: hf("plateDetection/yolox-tiny-plate/coreml/camstack-yolox-tiny-plate.mlpackage"),
+			sizeMB: 9.8,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateDetection/yolox-tiny-plate/openvino/camstack-yolox-tiny-plate.xml"), 10),
+		tflite: {
+			url: hf("plateDetection/yolox-tiny-plate/tflite/camstack-yolox-tiny-plate_edgetpu.tflite"),
+			sizeMB: 6.9,
+			runtimes: ["python"]
+		}
+	}
+}];
+var PACKAGE_DETECTION_MODELS = [{
+	id: "rfdetr-package",
+	license: RFDETR_APACHE,
+	name: "RF-DETR — Package",
+	description: "RF-DETR parcel detector — DETR-style decode (onnx / coreml / openvino). Separates parcel from doormat far better than the former yolov8n-package (+0.86 vs +0.21 margin on 615) at ~4× the size and ~6× the latency",
+	inputSize: {
+		width: 576,
+		height: 576
+	},
+	labels: [{
+		id: "package",
+		name: "Package"
+	}],
+	preprocessMode: "resize",
+	inputNormalization: "imagenet",
+	postprocessor: "rfdetr",
+	formats: {
+		onnx: {
+			url: hf("packageDetection/rfdetr-package/onnx/camstack-rfdetr-package.onnx"),
+			sizeMB: 115
+		},
+		coreml: {
+			url: hf("packageDetection/rfdetr-package/coreml/camstack-rfdetr-package.mlpackage"),
+			sizeMB: 58,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("packageDetection/rfdetr-package/openvino/camstack-rfdetr-package.xml"), 58)
+	}
+}];
+var PLATE_OCR_MODELS = [{
+	id: "cct-s-v2-global",
+	license: FAST_PLATE_OCR_MIT,
+	name: "CCT-S v2 Global — License Plate",
+	description: "fast-plate-ocr CCT-S v2 — a dedicated license-plate reader (66 regions incl. Germany). 19/21 exact on the cam-617 ground-truth set vs 4/21 for the generic VGG text recognizer, with zero false reads on 18 junk ROIs",
+	inputSize: {
+		width: 128,
+		height: 64
+	},
+	inputLayout: "nhwc",
+	labels: [{
+		id: "text",
+		name: "Plate Text"
+	}],
+	preprocessMode: "resize",
+	postprocessor: "plate-slots",
+	formats: {
+		onnx: {
+			url: hf("plateRecognition/cct-s-v2-global/onnx/camstack-cct-s-v2-global.onnx"),
+			sizeMB: 5.3
+		},
+		coreml: {
+			url: hf("plateRecognition/cct-s-v2-global/coreml/camstack-cct-s-v2-global.mlpackage"),
+			sizeMB: 5.1,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("plateRecognition/cct-s-v2-global/openvino/camstack-cct-s-v2-global.xml"), 5)
+	}
+}];
+var ANIMAL_CLASSIFIER_MODELS = [{
+	id: "animal-classifier",
+	license: ANIMAL_CLASSIFIER_APACHE,
+	name: "Animal Classifier (8)",
+	description: "EfficientNet-Lite0 animal classifier — bird, cat, cow, deer, dog, horse, sheep, squirrel (Open Images V7, publicly distributable). Unreliable on home cameras: it has no reject class, so it names a species for anything it is given, and calls light curly-coated dogs sheep or cat at high confidence. Prefer a root detector that names animals itself.",
+	defaultConfidence: .8,
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	inputLayout: "nchw",
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "animal-type",
+		name: "Animal Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/animal-classifier/onnx/animal-classifier.onnx"),
+			sizeMB: 13
+		},
+		coreml: {
+			url: hf("animalClassification/animal-classifier/coreml/animal-classifier.mlpackage"),
+			sizeMB: 6.5,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/animal-classifier/openvino/animal-classifier.xml"), 6.9)
+	},
+	extraFiles: [{
+		url: hf("animalClassification/animal-classifier/onnx/animal-classifier-labels.json"),
+		filename: "animal-classifier-labels.json",
+		sizeMB: .01
+	}]
+}];
+var BIRD_CLASSIFIER_MODELS = [{
+	id: "bird-classifier",
+	license: AIY_BIRDS_APACHE,
+	name: "Bird Classifier (AIY 965)",
+	description: "Google AIY Birds V1 (MobileNetV2) — 964 species + background; publicly distributable (Apache-2.0)",
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	inputLayout: "nhwc",
+	inputNormalization: "none",
+	outputProbabilities: true,
+	labels: [{
+		id: "species",
+		name: "Bird Species"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("animalClassification/bird-classifier/onnx/bird-classifier.onnx"),
+			sizeMB: 14
+		},
+		coreml: {
+			url: hf("animalClassification/bird-classifier/coreml/bird-classifier.mlpackage"),
+			sizeMB: 6.8,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("animalClassification/bird-classifier/openvino/bird-classifier.xml"), 14),
+		tflite: {
+			url: hf("animalClassification/bird-classifier/tflite/bird-classifier_edgetpu.tflite"),
+			sizeMB: 3.9,
+			runtimes: ["python"]
+		}
+	},
+	extraFiles: [{
+		url: hf("animalClassification/bird-classifier/onnx/bird-classifier-labels.json"),
+		filename: "bird-classifier-labels.json",
+		sizeMB: .03
+	}]
+}];
+var VEHICLE_CLASSIFIER_MODELS = [{
+	id: "vehicle-type-v1",
+	license: VEHICLE_TYPE_V1_NC,
+	name: "Vehicle Type (8)",
+	description: "MobileNetV3-Large vehicle type classifier — Ambulance, Bicycle, Bus, Car, Motorcycle, Taxi, Truck, Van (val 89.4%)",
+	defaultConfidence: .6,
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	inputLayout: "nchw",
+	inputNormalization: "imagenet",
+	labels: [{
+		id: "vehicle-type",
+		name: "Vehicle Type"
+	}],
+	preprocessMode: "resize",
+	formats: {
+		onnx: {
+			url: hf("vehicleClassification/vehicle-type-v1/onnx/vehicle-type-v1.onnx"),
+			sizeMB: 17
+		},
+		coreml: {
+			url: hf("vehicleClassification/vehicle-type-v1/coreml/vehicle-type-v1.mlpackage"),
+			sizeMB: 8.1,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		},
+		openvino: ovFormat(hf("vehicleClassification/vehicle-type-v1/openvino/vehicle-type-v1.xml"), 8.7)
+	},
+	extraFiles: [{
+		url: hf("vehicleClassification/vehicle-type-v1/onnx/vehicle-type-v1-labels.json"),
+		filename: "vehicle-type-v1-labels.json",
+		sizeMB: .01
+	}]
+}];
+var SEGMENTATION_REFINER_MODELS = [{
+	id: "u2netp",
+	license: U2NET_APACHE,
+	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)
+	}
+}];
+/**
+* The dormant `instance-segmentation` step's catalog: the YOLO26-seg entries of
+* {@link OBJECT_DETECTION_MODELS}, by reference. One entry per model (D703) —
+* the artifact lives once, in the root's catalog, where it can be selected as
+* the camera root and supply the `segmentation` step's masks (D737).
+*/
+var INSTANCE_SEGMENTATION_MODELS = OBJECT_DETECTION_MODELS.filter((m) => m.group?.family === YOLO26_SEG_FAMILY);
+var CLIP_EMBEDDING_MODELS = [{
+	id: "siglip2-b16-224",
+	license: SIGLIP2_APACHE,
+	name: "SigLIP2 B/16",
+	description: "Google SigLIP2 base, patch 16, 224×224 — Apache-2.0 CLIP vision encoder, 768-dim (fp16 OpenVINO/CoreML)",
+	inputSize: {
+		width: 224,
+		height: 224
+	},
+	labels: [{
+		id: "embedding",
+		name: "CLIP Embedding"
+	}],
+	preprocessMode: "resize",
+	inputNormalization: "none",
+	formats: {
+		openvino: ovFormat(hf("clip/siglip2/openvino/camstack-siglip2-b16-224-vision.xml"), 186),
+		coreml: {
+			url: hf("clip/siglip2/coreml/camstack-siglip2-b16-224-vision.mlpackage"),
+			sizeMB: 185,
+			isDirectory: true,
+			files: [...MLPACKAGE_FILES],
+			runtimes: ["python"]
+		}
+	}
+}];
+var AUDIO_CLASSIFIER_MODELS = [{
+	id: "yamnet-onnx",
+	license: YAMNET_APACHE,
+	name: "YAMNet",
+	description: "Google YAMNet — 521-class audio event classifier (16 MB ONNX, runs on any platform)",
+	inputSize: {
+		width: 1,
+		height: 16e3
+	},
+	labels: [],
+	preprocessMode: "resize",
+	extraFiles: [{
+		url: hf("audioClassification/yamnet/camstack-yamnet-labels.json"),
+		filename: "camstack-yamnet-labels.json",
+		sizeMB: .01
+	}],
+	formats: {
+		onnx: {
+			url: hf("audioClassification/yamnet/onnx/camstack-yamnet.onnx"),
+			sizeMB: 16.1
+		},
+		openvino: ovFormat(hf("audioClassification/yamnet/openvino/camstack-yamnet.xml"), 8.2)
+	}
+}, {
+	id: "apple-soundanalysis",
+	license: 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
+export { FACE_DETECTION_MODELS as a, OBJECT_DETECTION_MODELS as c, PLATE_OCR_MODELS as d, SEGMENTATION_REFINER_MODELS as f, CLIP_EMBEDDING_MODELS as i, PACKAGE_DETECTION_MODELS as l, AUDIO_CLASSIFIER_MODELS as n, FACE_EMBEDDING_MODELS as o, VEHICLE_CLASSIFIER_MODELS as p, BIRD_CLASSIFIER_MODELS as r, INSTANCE_SEGMENTATION_MODELS as s, ANIMAL_CLASSIFIER_MODELS as t, PLATE_DETECTION_MODELS as u };