source: one rebuild recipe per hosted AGPL file; yolov8n-plate provenance

Licence files, notices, model cards and the source/ folder (AGPL Corresponding Source scripts) from the CamStack repository. Only files that differ from the Hub are included. No weight file is touched.

README.md

@@ -77,7 +77,7 @@ marks an entry kept resolvable for a saved selection but no longer offered.
 | `packageDetection/rfdetr-package` | `rfdetr-package` (default) | Roboflow RF-DETR | Apache-2.0 | [`Apache-2.0.txt`](LICENSES/Apache-2.0.txt) | RF-DETR-M fine-tuned to 2 classes at 576; exported to ONNX, OpenVINO IR and CoreML; training checkpoint .pth also published |
 | `faceDetection/yunet` | `yunet-2023mar` (default) | OpenCV Zoo YuNet | MIT | [`MIT-yunet-reference.txt`](LICENSES/MIT-yunet-reference.txt), [`BSD-3-Clause.txt`](LICENSES/BSD-3-Clause.txt) | 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) |
 | `faceRecognition/auraface` | `auraface-r100` (default) | fal.ai AuraFace v1 (glintr100.onnx only) | Apache-2.0 | [`Apache-2.0.txt`](LICENSES/Apache-2.0.txt) | input scaling y = 2x - 1 baked ahead of the first Conv (scripts/build-auraface-model.py); converted to OpenVINO IR and CoreML FP16 |
-| `plateDetection/yolov8-plate` | `yolov8n-plate` (default) | Ultralytics | AGPL-3.0 | [`AGPL-3.0.txt`](LICENSES/AGPL-3.0.txt) | converted to OpenVINO IR and CoreML |
+| `plateDetection/yolov8-plate` | `yolov8n-plate` (default) | ml-debi/yolov8-license-plate-detection (ONNX, OpenVINO) and Koushim/yolov8-license-plate-detection (CoreML), YOLOv8n fine-tunes | AGPL-3.0 | [`AGPL-3.0.txt`](LICENSES/AGPL-3.0.txt) | ONNX redistributed unmodified; converted to OpenVINO IR from the ONNX, and exported to CoreML and TFLite from the checkpoint (scripts/build-camstack-models.py) |
 | `plateRecognition/cct-s-v2-global` | `cct-s-v2-global` (default) | ankandrew/fast-plate-ocr | MIT | [`MIT-fast-plate-ocr.txt`](LICENSES/MIT-fast-plate-ocr.txt) | input head removed (recorded in the ONNX doc_string); converted to OpenVINO IR and CoreML |
 | `animalClassification/animal-classifier` | `animal-classifier` (default) | timm EfficientNet-Lite0, fine-tuned by CamStack | Apache-2.0 | [`Apache-2.0.txt`](LICENSES/Apache-2.0.txt) | fine-tuned by CamStack on the Open Images V7 animal subset (8 classes); exported to ONNX, OpenVINO IR and CoreML |
 | `animalClassification/bird-classifier` | `bird-classifier` (default) | Google AIY Vision birds_V1 | Apache-2.0 | [`Apache-2.0.txt`](LICENSES/Apache-2.0.txt) | converted from TensorFlow with tf2onnx; OpenVINO IR and CoreML derived from it |

THIRD_PARTY_MODELS.md

@@ -36,7 +36,7 @@ under [Non-commercial models](#non-commercial-models).
 - RF-DETR © Roboflow, Apache-2.0. https://github.com/roboflow/rf-detr
 - YuNet weights Copyright (c) 2020 Shiqi Yu, MIT. Training code: ShiqiYu/libfacedetection.train, BSD-3-Clause. https://github.com/opencv/opencv_zoo/tree/main/models/face_detection_yunet
 - AuraFace v1 by fal.ai, Apache-2.0. https://huggingface.co/fal/AuraFace-v1
-- © Ultralytics, AGPL-3.0 (YOLOv8n base, fine-tuned for plates by an unidentified third party). CamStack holds no training checkpoint; the ONNX file is the only form it has. https://github.com/ultralytics/ultralytics
+- © Ultralytics, AGPL-3.0 (YOLOv8n base). Fine-tuned for licence plates by third parties: the ONNX file is best.onnx of https://huggingface.co/ml-debi/yolov8-license-plate-detection, redistributed unmodified (its author published no checkpoint); the CoreML and TFLite files are exported from best.pt of https://huggingface.co/Koushim/yolov8-license-plate-detection. Both cards say MIT; the Ultralytics base keeps them AGPL-3.0. Corresponding source: build-camstack-models.py at https://huggingface.co/camstack/camstack-models/tree/main/source. https://huggingface.co/ml-debi/yolov8-license-plate-detection
 - fast-plate-ocr, MIT License, copyright (c) 2024 ankandrew (full notice: licenses/models/MIT-fast-plate-ocr.txt). https://github.com/ankandrew/fast-plate-ocr
 - 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. https://github.com/huggingface/pytorch-image-models
 - 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. https://github.com/pytorch/vision
@@ -68,28 +68,49 @@ is published in the mirror itself, in its **`source/`** folder,
 **https://huggingface.co/camstack/camstack-models/tree/main/source**, together
 with the upstream checkpoints it starts from:
 
-1. **The upstream checkpoints**, published by Ultralytics at
-   https://github.com/ultralytics/assets/releases: `yolo26{n,s,m,l,x}.pt`,
-   `yolov9{t,s,m,c}.pt`, `yolo26{n,s,m}-seg.pt`.
-2. **The export scripts** in `source/`: `build-camstack-models.py` (ONNX
-   with a dynamic batch axis, CoreML FP16, OpenVINO IR, OpenVINO NNCF INT8),
-   `convert_lib.py` (the ONNX to OpenVINO / INT8 / CoreML converter it imports,
-   the same one CamStack's Model Studio runs), `requirements.txt` and
-   `export-models.py`. The build instructions (Python environment,
-   invocation, calibration images for INT8) are in `source/README.md` and in
-   each script's header. These scripts are CamStack's own code and are offered
-   under the MIT licence; the weights they produce keep their upstream licence.
-
-What the published scripts do **not** cover yet:
-
-- **Some hosted sizes and input resolutions.** The export scripts do not list
-  every variant in the mirror (for example the `-320`/`-256` YOLO26 exports,
-  `yolov9m`/`yolov9c`, and the `yolo26*-seg` models). Each one is the same
-  Ultralytics `export()` with a different model id or `imgsz`, but no
-  published script reproduces it as-is.
-- **`yolov8n-plate` has no training checkpoint.** It is a third-party model
-  (trained 2023-12-05 according to its own metadata, origin not identified).
-  The ONNX file is the only form CamStack has.
+1. **The upstream checkpoints.** Ultralytics publishes
+   `yolo26{n,s,m,l,x}.pt`, `yolov9{t,s,m,c}.pt` and `yolo26{n,s,m}-seg.pt` at
+   https://github.com/ultralytics/assets/releases. `yolov8n-plate` is two
+   third-party YOLOv8n licence-plate fine-tunes, neither trained by CamStack:
+   its ONNX file is `best.onnx` of
+   https://huggingface.co/ml-debi/yolov8-license-plate-detection (SHA-256
+   `85d23628…15bd50`, hosted unmodified), and its CoreML and TFLite files are
+   exported from `best.pt` of
+   https://huggingface.co/Koushim/yolov8-license-plate-detection. Both cards
+   say MIT; the Ultralytics base weights keep both AGPL-3.0, as their own
+   metadata states.
+2. **The build script** in `source/`: `build-camstack-models.py`, with
+   `convert_lib.py` (the ONNX to OpenVINO / INT8 converter it calls, the same
+   file CamStack's Model Studio runs) and `requirements.txt`. It holds one
+   recipe per hosted file: the upstream checkpoint, the input size, the
+   Ultralytics `export()` arguments, the OpenVINO precision and the INT8
+   calibration count that file records about itself. Every hosted
+   Ultralytics-derived file is rebuilt by one invocation:
+   `build-camstack-models.py --variant <file stem>` (for example
+   `camstack-yolo26n-320` or `camstack-yolov9m-640`), `--family <folder>`
+   or `--all`; `--list` prints the recipes and `--check-hosted` confirms
+   against the mirror that every hosted file is a recipe output. The INT8
+   builds are NNCF post-training quantisation calibrated on COCO images: 128
+   for YOLO26, 300 for YOLOv9, as each IR records; the documented set is the
+   first N of COCO val2017 in file-name order. The Python
+   environment, the recorded tool versions and the calibration set are in
+   `source/README.md` and the script's header. These scripts are CamStack's
+   own code and are offered under the MIT licence; the weights they produce
+   keep their upstream licence.
+
+Limits of a rebuild:
+
+- **Tool versions.** With the Ultralytics, PyTorch, coremltools and OpenVINO
+  versions each recipe names, a rebuild reproduces the hosted weights. Other
+  versions give the same weights in a possibly different graph.
+- **INT8 calibration.** An IR records how many images calibrated it, not
+  which ones. Calibrating on the same COCO images gives the documented build;
+  a different set gives an equivalent, not bit-identical, INT8 model.
+- **`yolov8n-plate` ONNX has no checkpoint.** Its author published only the
+  ONNX file, so that file is the preferred form of the work that exists, and
+  CamStack redistributes it unmodified. CamStack's modification is the
+  OpenVINO conversion of it, which the script reproduces. The training data of
+  both plate fine-tunes is not published.
 
 ## Non-commercial models
 
@@ -138,7 +159,7 @@ entry kept resolvable for a saved selection but no longer offered.
 
 | Catalog ids | Upstream | Code / weights | Training data | CamStack changes | Downloaded from |
 | --- | --- | --- | --- | --- | --- |
-| `yolov8n-plate` (default) | [Ultralytics](https://github.com/ultralytics/ultralytics) | AGPL-3.0 / AGPL-3.0 (`AGPL-3.0.txt`) | unidentified plate dataset (third-party model, trained 2023-12-05 per its ONNX metadata): UNKNOWN | converted to OpenVINO IR and CoreML | mirror `plateDetection/yolov8-plate` |
+| `yolov8n-plate` (default) | [ml-debi/yolov8-license-plate-detection (ONNX, OpenVINO) and Koushim/yolov8-license-plate-detection (CoreML), YOLOv8n fine-tunes](https://huggingface.co/ml-debi/yolov8-license-plate-detection) | AGPL-3.0 / AGPL-3.0 (`AGPL-3.0.txt`) | undisclosed licence-plate datasets of the two third-party fine-tunes (ml-debi, trained 2023-12-05; Koushim, trained 2025-05-25): UNKNOWN | ONNX redistributed unmodified; converted to OpenVINO IR from the ONNX, and exported to CoreML and TFLite from the checkpoint (scripts/build-camstack-models.py) | mirror `plateDetection/yolov8-plate` |
 
 ### Licence plate reading
 

plateDetection/yolov8-plate/README.md

@@ -1,17 +1,17 @@
-<!-- Hand-written 2026-09-26 (plan docs/superpowers/plans/2026-09-26-model-license-compliance.md, Task 2) in camstack/server hf/camstack-models/. Edit it there, not on the Hub. -->
+<!-- Hand-written 2026-09-26 (plan docs/superpowers/plans/2026-09-26-model-license-compliance.md, Task 2), provenance identified 2026-10-06, in camstack/server hf/camstack-models/. Edit it there, not on the Hub. -->
 
 # plateDetection/yolov8-plate: YOLOv8n licence-plate detector
 
 | | |
 | --- | --- |
 | Catalog id | `yolov8n-plate` |
-| Upstream | Ultralytics YOLOv8n fine-tuned for licence plates by a third party (trained 2023-12-05, Ultralytics 8.0.222, per the ONNX metadata); author not identified |
-| Obtained from | an ONNX file of unidentified origin |
+| Upstream | Ultralytics YOLOv8n, fine-tuned for licence plates by two third parties: [ml-debi/yolov8-license-plate-detection](https://huggingface.co/ml-debi/yolov8-license-plate-detection) (ONNX, OpenVINO; trained 2023-12-05, Ultralytics 8.0.222) and [Koushim/yolov8-license-plate-detection](https://huggingface.co/Koushim/yolov8-license-plate-detection) (CoreML, TFLite; trained 2025-05-25, Ultralytics 8.3.144) |
+| Obtained from | `onnx/`: ml-debi's `best.onnx`, byte-identical (SHA-256 `85d236280a1301ad98907947d284951dd2b20c23a6786ff50f7e6a8ec515bd50`). `coreml/`, `tflite/`: exported from Koushim's `best.pt` (SHA-256 `2d95861825bb4184404344c9cf809f40fd31dba785fe54e8ba5b9a3583789822`) |
 | Code licence | AGPL-3.0 |
-| **Weights licence** | **AGPL-3.0** (declared in the ONNX metadata; [`LICENSES/AGPL-3.0.txt`](../../LICENSES/AGPL-3.0.txt)) |
-| Training data | **unknown** |
-| CamStack modifications | converted to OpenVINO IR, CoreML and TFLite (float32) |
-| Corresponding source | [Source offer for the AGPL-3.0 weights](../../THIRD_PARTY_MODELS.md#source-offer-for-the-agpl-30-weights). CamStack holds no training checkpoint: the ONNX file is the only form available to it |
-| Commercial use | AGPL-3.0 obligations apply; training data unknown |
+| **Weights licence** | **AGPL-3.0** (the Ultralytics base; declared in both models' metadata; [`LICENSES/AGPL-3.0.txt`](../../LICENSES/AGPL-3.0.txt)). Both upstream cards say MIT, which cannot lift the base's AGPL-3.0 |
+| Training data | **not published** by either upstream |
+| CamStack modifications | ONNX redistributed unmodified; OpenVINO IR converted from it; CoreML and TFLite (float32) exported from the checkpoint |
+| Corresponding source | [`source/build-camstack-models.py`](../../source/build-camstack-models.py) `--variant camstack-yolov8n-plate` downloads both upstream files, verifies their hashes and rebuilds every file here. ml-debi published no checkpoint, so its ONNX is the only form of that model that exists. See the [source offer](../../THIRD_PARTY_MODELS.md#source-offer-for-the-agpl-30-weights) |
+| Commercial use | AGPL-3.0 obligations apply; training data not published |
 
 CamStack redistributes the files in this folder; every change from the upstream is stated above. Converting a model does not change its licence. The collection statement is [`LICENSE`](../../LICENSE); every model's attribution is in [`THIRD_PARTY_MODELS.md`](../../THIRD_PARTY_MODELS.md).

source/README.md

@@ -5,32 +5,92 @@
 This folder is the **Corresponding Source** under the GNU AGPL-3.0 for the
 Ultralytics-derived weights in this mirror (`objectDetection/yolo26`,
 `objectDetection/yolov9`, `segmentation/yolo26-seg`, `plateDetection/yolov8-plate`).
-The full source offer, including what these scripts do not reproduce yet, is in
+The full source offer is in
 [`THIRD_PARTY_MODELS.md`](../THIRD_PARTY_MODELS.md#source-offer-for-the-agpl-30-weights).
 
 | File | What it is |
 | --- | --- |
-| `build-camstack-models.py` | Builds the `camstack-*` YOLO set from the upstream Ultralytics checkpoints: ONNX with a dynamic batch axis, CoreML (FP16, flexible batch 1..16), OpenVINO IR FP32 and FP16, and OpenVINO NNCF INT8 when calibration images are present. |
-| `convert_lib.py` | The converter `build-camstack-models.py` imports: ONNX to OpenVINO IR (`ov.convert_model`), NNCF INT8 post-training quantisation, ONNX to CoreML, and validation of every IR. It is the same file CamStack's Model Studio runs at runtime. |
-| `requirements.txt` | Python dependencies of `convert_lib.py`, with per-platform markers (OpenVINO/NNCF off macOS, coremltools/torch on macOS). |
-| `export-models.py` | The older bulk exporter (Ultralytics `export()` to ONNX, CoreML, OpenVINO, TFLite) for the YOLOv8, YOLOv9 and YOLO11 ids. Self-contained. |
+| `build-camstack-models.py` | Rebuilds every file in the four folders above. One recipe per hosted file stem: upstream checkpoint, input size, the Ultralytics `export()` arguments, the OpenVINO precisions and the INT8 calibration count. Each value is what the hosted file records about itself in its metadata. |
+| `convert_lib.py` | The converter `build-camstack-models.py` calls for OpenVINO: ONNX to IR (`ov.convert_model`, FP32 or FP16-compressed), NNCF INT8 post-training quantisation, and validation of every IR. It is the same file CamStack's Model Studio runs. |
+| `requirements.txt` | Python dependencies of `convert_lib.py`, with per-platform markers. |
+| `export-models.py` | An older bulk exporter for YOLOv8 / YOLOv9 / YOLO11 ids. No file in this mirror needs it. |
 
 ## Rebuilding
 
 ```bash
 python3 -m venv .venv && . .venv/bin/activate
-pip install -r requirements.txt ultralytics
-# optional, for the INT8 builds: a folder of calibration images (e.g. a COCO val subset)
-export CAMSTACK_CALIB_DIR=./calibration-images
-python build-camstack-models.py
+pip install -r requirements.txt ultralytics openvino nncf
+python build-camstack-models.py --list            # the recipes: one per hosted file stem
+python build-camstack-models.py --check-hosted    # every hosted file is a recipe output?
+
+python build-camstack-models.py --variant camstack-yolo26n-320   # one hosted model, every format
+python build-camstack-models.py --family yolov9                  # one mirror folder
+python build-camstack-models.py --all                            # the whole set
+python build-camstack-models.py --all --formats onnx,openvino    # some formats only
+```
+
+Results go to `./exported-models/<mirror path>`, for example
+`exported-models/objectDetection/yolo26/openvino/camstack-yolo26n-320-int8.xml`.
+Each build step runs in its own Python process: on macOS, CoreML, OpenVINO and
+TensorFlow crash one another when they share one. CoreML needs macOS. TFLite
+needs `tensorflow` and `onnx2tf`.
+
+What the recipes encode (the hosted files record each of these):
+
+| Folder | Files | ONNX | CoreML | OpenVINO IR |
+| --- | --- | --- | --- | --- |
+| `objectDetection/yolo26` | `camstack-yolo26{n,s,m,l,x}` @640 | static, opset 17 | static, batch 1 | FP16 as `<stem>.xml` and `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (128 images) |
+| `objectDetection/yolo26` | `camstack-yolo26{n,s,m,l}-{320,256}` | dynamic axes, opset 17 | flexible batch 1..16, FP16 | FP32 `<stem>.xml`; INT8 `<stem>-int8.xml` (128 images) |
+| `objectDetection/yolov9` | `camstack-yolov9{t,s,m,c}-{320,640}` | static, opset 13 | static, batch 1 | FP16 `<stem>-fp16.xml`; INT8 `<stem>-int8.xml` (300 images) |
+| `segmentation/yolo26-seg` | `camstack-yolo26{n,s,m}-seg` @640 | static, opset 17 | static, batch 1 | FP16 `<stem>.xml` |
+| `plateDetection/yolov8-plate` | `camstack-yolov8n-plate` @640 | third-party file, unmodified | static, batch 1 | FP16 `<stem>.xml` (from the ONNX); also TFLite float32 |
+
+Recorded tool versions (Ultralytics / PyTorch / coremltools / OpenVINO):
+YOLO26 @640 and YOLO26-seg 8.4.24 / 2.10.0 / 9.0 / 2026.2.1; YOLO26 @320 and
+@256 8.4.92 / 2.13.0 for ONNX, 2.5.1 for CoreML / 8.3.0 / 2026.2.1; YOLOv9
+8.4.98 / 2.13.0 / 9.0 / 2026.2.1; plate CoreML 8.4.24 / 2.10.0 / 9.0, plate IR
+OpenVINO 2026.0.0. The script warns when the installed Ultralytics differs.
+With these versions a rebuild gives the hosted weights. Other versions give the
+same weights in a possibly different graph. The flexible-batch CoreML exports
+need coremltools 8.3 with PyTorch 2.5.1, the macOS pins in `requirements.txt`;
+coremltools 9 aborts on them.
+
+### INT8 calibration
+
+The INT8 IRs are NNCF post-training quantisation of the ONNX
+(`convert_lib.quantize_openvino_int8`), calibrated on COCO images. The
+documented calibration set is COCO val2017:
+
+```bash
+curl -LO http://images.cocodataset.org/zips/val2017.zip && unzip -q val2017.zip
+python build-camstack-models.py --family yolo26 --calib-dir ./val2017
 ```
 
-The script downloads each upstream checkpoint (`yolo26n.pt`, `yolov9t.pt`, ...)
-from Ultralytics on first use, finds `convert_lib.py` next to itself, and writes
-the results to `./exported-models/`. The model list and input sizes are the
-`MODELS` table at the top of the script; the other hosted sizes are the same
-calls with a different model id or `imgsz`. CoreML export needs macOS; the
-OpenVINO steps need Linux or Windows on x86.
+The recipe takes the first N images in file-name order: 128 for YOLO26, 300
+for YOLOv9, as recorded in each IR's `rt_info`. Each image is letterboxed to
+the model's input size with grey (114) padding and scaled to [0, 1], the way
+CamStack feeds the model at runtime. `--calib-samples` overrides N. An IR does
+not record WHICH images calibrated it, so a different set gives an equivalent
+INT8 model, not a bit-identical one. Without calibration images the INT8 files
+are skipped and the run says so.
+
+### `yolov8n-plate`
+
+Two third-party YOLOv8n licence-plate fine-tunes, neither trained by CamStack:
+
+- `onnx/camstack-yolov8n-plate.onnx` is `best.onnx` of
+  [ml-debi/yolov8-license-plate-detection](https://huggingface.co/ml-debi/yolov8-license-plate-detection)
+  (revision `8062e8e8`, SHA-256 `85d236280a1301ad98907947d284951dd2b20c23a6786ff50f7e6a8ec515bd50`),
+  hosted unmodified. Its author published no checkpoint, so the ONNX is the
+  only form of that model that exists. CamStack's modification is the OpenVINO
+  conversion, which the script reproduces from it.
+- `coreml/` and `tflite/` are Ultralytics exports of `best.pt` of
+  [Koushim/yolov8-license-plate-detection](https://huggingface.co/Koushim/yolov8-license-plate-detection)
+  (revision `9aaa5cd4`, SHA-256 `2d95861825bb4184404344c9cf809f40fd31dba785fe54e8ba5b9a3583789822`).
+  The script downloads and verifies both files.
+
+Both model cards say MIT. The Ultralytics YOLOv8n base weights keep both
+AGPL-3.0, as their own metadata states. Neither publishes its training data.
 
 ## Licences
 

source/build-camstack-models.py

@@ -1,265 +1,670 @@
 #!/usr/bin/env python3
 """
-Build the camstack-* model set with batch-flexible CoreML packages.
-
-The pipeline's Python pool currently does N predicts iterated internally
-on a list-of-dicts (saves session setup, but each frame still costs ~9ms
-warm). A CoreML model exported with a flexible batch dim accepts a single
-stacked tensor of shape `(N, 3, H, W)` — one ANE dispatch per batch,
-amortising every fixed cost.
-
-This script produces (per model in MODELS):
-  exported-models/camstack-<id>.onnx     — ONNX with dynamic batch axis
-  exported-models/camstack-<id>.mlpackage — CoreML with RangeDim batch (1..16)
-  exported-models/camstack-<id>_openvino_model/  — OpenVINO IR with dynamic batch
-
-The dynamic axis is SAFE to export and must not be pinned here: the same
-artifact is loaded on CPU, iGPU, NPU and ANE nodes, so an export cannot know
-which target it will meet. The loader does — `_static_batch_required` /
-`_pin_batch_for_device` in `packages/addon-pipeline/python/inference_pool.py`
-reshape the graph to a static batch of 1 for the one target that refuses dynamic
-dims (the Intel NPU) and hand it over untouched everywhere else (D202). Pinning
-it here would instead delete the flexible axis the CoreML batched-ANE dispatch
-path depends on.
+Rebuild every Ultralytics-derived (AGPL-3.0) model the CamStack mirror hosts.
 
-Usage:
-  python scripts/build-camstack-models.py      # from the CamStack repository
-  python build-camstack-models.py              # from the mirror's source/ folder
+This is the Corresponding Source for the AGPL-3.0 weights of
+https://huggingface.co/camstack/camstack-models in
+
+  objectDetection/yolo26      yolo26{n,s,m,l,x} @640, yolo26{n,s,m,l} @320 and @256
+  objectDetection/yolov9      yolov9{t,s,m,c} @320 and @640
+  segmentation/yolo26-seg     yolo26{n,s,m}-seg @640
+  plateDetection/yolov8-plate yolov8n-plate (third-party fine-tune, see below)
 
-Environment: the packages in convert_lib's requirements.txt plus `ultralytics`
-(which also fetches the upstream `.pt` checkpoints). INT8 needs calibration
-images in CAMSTACK_CALIB_DIR (default ./calibration-images).
+Every hosted file is one output of ONE recipe in `RECIPES` below, and the recipe
+holds exactly the settings that file records about itself: the Ultralytics
+`export()` arguments (stored in each ONNX / CoreML file's metadata), the OpenVINO
+weight compression and the NNCF calibration subset size (stored in each IR's
+`rt_info`). `--check-hosted` proves the mapping is complete against the live
+mirror: every hosted weight file must be an output of some recipe.
+
+Usage:
+  python build-camstack-models.py --list                       # every recipe
+  python build-camstack-models.py --check-hosted               # recipes == mirror?
+  python build-camstack-models.py --variant camstack-yolo26n-320
+  python build-camstack-models.py --family yolov9              # one mirror folder
+  python build-camstack-models.py --all                        # the whole mirror
+  python build-camstack-models.py --all --formats onnx,openvino --dry-run
+
+  # Something not in the mirror (same pipeline, your own settings):
+  python build-camstack-models.py --model yolo26n --imgsz 416 \
+      --openvino fp16,int8 --calib-samples 128
+
+Outputs land in `--out` (default ./exported-models) under the MIRROR's paths,
+e.g. exported-models/objectDetection/yolo26/openvino/camstack-yolo26n-320-int8.xml.
+
+Formats:
+  onnx      Ultralytics export(format="onnx") from the upstream .pt
+  coreml    Ultralytics export(format="coreml") from the upstream .pt (macOS only)
+  openvino  convert_lib.export_openvino: ov.convert_model(ONNX) + ov.save_model
+            (compress_to_fp16 per precision) — never the Ultralytics OV exporter
+  int8      convert_lib.quantize_openvino_int8: NNCF post-training quantisation
+            of the ONNX, calibrated on the first N images (sorted by file name)
+            of --calib-dir (default $CAMSTACK_CALIB_DIR or ./calibration-images)
+  tflite    Ultralytics export(format="tflite") (needs tensorflow + onnx2tf)
+
+INT8 calibration: the hosted INT8 IRs record subset_size 128 (YOLO26) and 300
+(YOLOv9), drawn from COCO; an IR does not record WHICH images. The documented
+set is COCO val2017: unpack http://images.cocodataset.org/zips/val2017.zip and
+point --calib-dir at it — the recipe's N is taken in file-name order. Images are letterboxed to
+the recipe's input size with grey (114) padding and scaled to [0, 1], exactly
+as the CamStack runtime feeds the model. A different calibration set yields an
+equivalent but not bit-identical IR (NNCF picks ranges from the data).
+
+Toolchain: each recipe names the Ultralytics / torch / coremltools / OpenVINO
+versions its hosted files record. Other versions produce the same model with a
+possibly different graph layout; the script warns when they differ.
+
+Environment: `pip install -r requirements.txt ultralytics` (requirements.txt is
+convert_lib's). convert_lib.py is found next to this script (the mirror's
+`source/` folder) or in packages/addon-model-studio/python/ (the repository).
 """
 
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
 import os
 import shutil
+import subprocess
 import sys
+import urllib.request
+from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Callable, Optional
 
-# convert_lib.py is the converter Model Studio runs at runtime. In the CamStack
-# repository it lives in packages/addon-model-studio/python/; the published copy
-# of this script (the `source/` folder of the camstack/camstack-models mirror)
-# ships it as a sibling file. A sibling wins, so the SAME file runs in both places.
 _HERE = Path(__file__).resolve().parent
-_CONVERT_LIB_DIRS = (
-    _HERE,
-    _HERE.parent / 'packages' / 'addon-model-studio' / 'python',
-)
-_CONVERT_LIB_DIR = next(
-    (d for d in _CONVERT_LIB_DIRS if (d / 'convert_lib.py').is_file()), None
-)
+_CONVERT_LIB_DIRS = (_HERE, _HERE.parent / 'packages' / 'addon-model-studio' / 'python')
+_CONVERT_LIB_DIR = next((d for d in _CONVERT_LIB_DIRS if (d / 'convert_lib.py').is_file()), None)
 if _CONVERT_LIB_DIR is None:
-    sys.exit(
-        'convert_lib.py not found next to this script or in '
-        'packages/addon-model-studio/python/'
-    )
+    sys.exit('convert_lib.py not found next to this script or in packages/addon-model-studio/python/')
 sys.path.insert(0, str(_CONVERT_LIB_DIR))
-from convert_lib import export_openvino, quantize_openvino_int8, validate_openvino_ir
-
-# --- Config ------------------------------------------------------------
 
-OUTPUT_DIR = Path("exported-models")
+HF_REPO = 'camstack/camstack-models'
+DEFAULT_CALIB_DIR = Path(os.environ.get('CAMSTACK_CALIB_DIR', 'calibration-images'))
 
-MODELS = [
-    # (ultralytics-id, exported-name, image-size)
-    ("yolov9t", "camstack-yolov9t", 640),
-    ("yolov9s", "camstack-yolov9s", 640),
-    ("yolo26n", "camstack-yolo26n", 640),
-]
+# --- Recipe model ------------------------------------------------------------
 
-# Directory of calibration images (e.g. a COCO val subset) for INT8. INT8 is
-# only produced when this dir exists + has images; otherwise it's skipped with
-# a note. Override via CAMSTACK_CALIB_DIR.
-CALIB_DIR = Path(os.environ.get("CAMSTACK_CALIB_DIR", "calibration-images"))
 
-BATCH_RANGE_LOWER = 1
-BATCH_RANGE_UPPER = 16
-BATCH_DEFAULT = 1
+@dataclass(frozen=True)
+class Download:
+    """A third-party file fetched by URL and verified by SHA-256."""
 
+    url: str
+    sha256: str
+    filename: str
 
-# --- Helpers -----------------------------------------------------------
 
+@dataclass(frozen=True)
+class OnnxExport:
+    """Ultralytics export(format="onnx") arguments, as the hosted ONNX records them."""
 
-def get_size_mb(path: Path) -> float:
-    if path.is_file():
-        return path.stat().st_size / (1024 * 1024)
-    return sum(f.stat().st_size for f in path.rglob("*") if f.is_file()) / (1024 * 1024)
+    dynamic: bool
+    opset: int
 
 
-def ensure_dir(p: Path) -> Path:
-    p.mkdir(parents=True, exist_ok=True)
-    return p
+@dataclass(frozen=True)
+class CoremlExport:
+    """Ultralytics export(format="coreml") arguments, as the hosted package records them."""
 
+    dynamic: bool
+    batch: int
+    half: bool
 
-# --- Step 1: YOLO -> ONNX (dynamic batch) ------------------------------
 
+@dataclass(frozen=True)
+class OpenvinoOutput:
+    """One hosted IR: file suffix after the model name, and how it is produced.
 
-def export_onnx(ultra_id: str, out_path: Path, imgsz: int) -> Path:
-    """Export the Ultralytics .pt as ONNX with `dynamic=True`.
+    `precision` is `fp32` (compress_to_fp16=False), `fp16` (compress_to_fp16=True)
+    or `int8` (NNCF on the ONNX, `calib_samples` images).
+    """
 
-    `dynamic=True` produces an ONNX with `images` axis 0 marked dynamic
-    (batch) so coremltools.convert can set RangeDim on it.
+    suffix: str
+    precision: str
+
+
+@dataclass(frozen=True)
+class Toolchain:
+    ultralytics: str
+    torch: str
+    coremltools: str
+    openvino: str
+
+
+@dataclass(frozen=True)
+class Recipe:
+    name: str  # hosted file stem, e.g. camstack-yolo26n-320
+    folder: str  # mirror folder, e.g. objectDetection/yolo26
+    imgsz: int
+    toolchain: Toolchain
+    # The PyTorch checkpoint: an Ultralytics asset id (`yolo26n` -> yolo26n.pt,
+    # auto-downloaded by Ultralytics) or a third-party Download.
+    checkpoint: str | Download
+    onnx: Optional[OnnxExport]  # None: the ONNX is `onnx_verbatim`, not exported
+    coreml: Optional[CoremlExport]
+    openvino: tuple[OpenvinoOutput, ...] = ()
+    calib_samples: int = 0
+    tflite: bool = False
+    onnx_verbatim: Optional[Download] = None  # a third-party ONNX hosted unmodified
+    note: str = ''
+
+    def outputs(self) -> list[str]:
+        """Mirror paths this recipe produces (an .mlpackage is a directory)."""
+        out: list[str] = []
+        if self.onnx is not None or self.onnx_verbatim is not None:
+            out.append(f'{self.folder}/onnx/{self.name}.onnx')
+        if self.coreml is not None:
+            out.append(f'{self.folder}/coreml/{self.name}.mlpackage/')
+        for ov in self.openvino:
+            stem = f'{self.folder}/openvino/{self.name}{ov.suffix}'
+            out.extend([f'{stem}.xml', f'{stem}.bin'])
+        if self.tflite:
+            out.append(f'{self.folder}/tflite/{self.name}_float32.tflite')
+        return out
+
+
+# --- The hosted set ------------------------------------------------------------
+# Toolchains as recorded by the hosted files themselves (ONNX/CoreML metadata
+# `version`, CoreML `com.github.apple.coremltools.*` and `torch==`, IR rt_info
+# `Runtime_version`).
+TC_2604 = Toolchain('8.4.24', '2.10.0', '9.0', '2026.2.1')
+TC_2607_REDUCED = Toolchain('8.4.92', 'onnx 2.13.0, coreml 2.5.1', '8.3.0', '2026.2.1')
+TC_2607_YOLOV9 = Toolchain('8.4.98', '2.13.0', '9.0', '2026.2.1')
+TC_PLATE = Toolchain('8.4.24 (CoreML, TFLite)', '2.10.0', '9.0', '2026.0.0')
+
+FP16_IR = OpenvinoOutput('', 'fp16')
+
+
+def _yolo26_full(tier: str) -> Recipe:
+    """yolo26<tier> @640: static ONNX, static fp32-compute CoreML, IR fp16 twice + INT8.
+
+    The unsuffixed IR and `-fp16` IR are the same compressed-to-FP16 weights;
+    the catalog addresses both names.
     """
-    from ultralytics import YOLO
-
-    print(f"  → loading {ultra_id}.pt (auto-download if missing)")
-    model = YOLO(f"{ultra_id}.pt")
-    print(f"  → exporting ONNX (imgsz={imgsz}, dynamic batch)")
-    onnx_src = model.export(
-        format="onnx",
-        imgsz=imgsz,
-        dynamic=True,
-        simplify=True,
-        opset=17,
+    return Recipe(
+        name=f'camstack-yolo26{tier}', folder='objectDetection/yolo26', imgsz=640,
+        toolchain=TC_2604, checkpoint=f'yolo26{tier}',
+        onnx=OnnxExport(dynamic=False, opset=17),
+        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        openvino=(FP16_IR, OpenvinoOutput('-fp16', 'fp16'), OpenvinoOutput('-int8', 'int8')),
+        calib_samples=128,
     )
-    if not onnx_src:
-        raise RuntimeError(f"ONNX export returned no path for {ultra_id}")
-    onnx_src = Path(onnx_src)
-    if onnx_src != out_path:
-        shutil.copy2(onnx_src, out_path)
-    print(f"    ✓ {out_path.name} ({get_size_mb(out_path):.1f} MB)")
-    return out_path
 
 
-# --- Step 2: ONNX -> CoreML (RangeDim batch) ---------------------------
+def _yolo26_reduced(tier: str, res: int) -> Recipe:
+    """yolo26<tier>-<res>: dynamic-axes ONNX, batch-flexible (1..16) FP16 CoreML, IR fp32 + INT8."""
+    return Recipe(
+        name=f'camstack-yolo26{tier}-{res}', folder='objectDetection/yolo26', imgsz=res,
+        toolchain=TC_2607_REDUCED, checkpoint=f'yolo26{tier}',
+        onnx=OnnxExport(dynamic=True, opset=17),
+        coreml=CoremlExport(dynamic=True, batch=16, half=True),
+        openvino=(OpenvinoOutput('', 'fp32'), OpenvinoOutput('-int8', 'int8')),
+        calib_samples=128,
+    )
 
 
-def export_coreml(ultra_id: str, out_path: Path, imgsz: int) -> Path:
-    """Export the Ultralytics .pt as a CoreML mlpackage with flexible batch.
+def _yolov9(tier: str, res: int) -> Recipe:
+    """yolov9<tier>-<res>: static opset-13 ONNX, static CoreML, IR fp16 + INT8."""
+    return Recipe(
+        name=f'camstack-yolov9{tier}-{res}', folder='objectDetection/yolov9', imgsz=res,
+        toolchain=TC_2607_YOLOV9, checkpoint=f'yolov9{tier}',
+        onnx=OnnxExport(dynamic=False, opset=13),
+        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        openvino=(OpenvinoOutput('-fp16', 'fp16'), OpenvinoOutput('-int8', 'int8')),
+        calib_samples=300,
+    )
 
-    Ultralytics' CoreML exporter handles the torch.jit.trace + coremltools
-    pipeline internally. With `dynamic=True` + `batch=N`, it produces a
-    model that accepts shape `(B, 3, imgsz, imgsz)` with B ∈ [1..N].
-    `half=True` sets compute precision to FLOAT16 — required for ANE.
-    """
-    from ultralytics import YOLO
 
-    print(f"  → loading {ultra_id}.pt for CoreML export")
-    model = YOLO(f"{ultra_id}.pt")
-    print(
-        f"  → exporting CoreML mlpackage (imgsz={imgsz}, dynamic batch up to {BATCH_RANGE_UPPER}, half=FP16)"
+def _yolo26_seg(tier: str) -> Recipe:
+    return Recipe(
+        name=f'camstack-yolo26{tier}-seg', folder='segmentation/yolo26-seg', imgsz=640,
+        toolchain=TC_2604, checkpoint=f'yolo26{tier}-seg',
+        onnx=OnnxExport(dynamic=False, opset=17),
+        coreml=CoremlExport(dynamic=False, batch=1, half=False),
+        openvino=(FP16_IR,),
+    )
+
+
+# yolov8n-plate is TWO third-party YOLOv8n licence-plate fine-tunes, neither
+# trained by CamStack (both declare MIT on their model cards; the Ultralytics
+# base weights make them AGPL-3.0, and their own metadata says so):
+#   - the ONNX (and the OpenVINO IR converted from it) is ml-debi's `best.onnx`,
+#     hosted byte-identical. Its author published no .pt; the ONNX is the only
+#     form that exists. CamStack's modification is the IR conversion below.
+#   - the CoreML package and the TFLite file are Ultralytics exports of
+#     Koushim's `best.pt`, saved as `yolov8n-plate.pt` (the file stem is what
+#     the export metadata calls the model). The .pt is public.
+_PLATE_ONNX = Download(
+    url='https://huggingface.co/ml-debi/yolov8-license-plate-detection/resolve/'
+        '8062e8e86734e272c60fa9a819433327ebdb66d7/best.onnx',
+    sha256='85d236280a1301ad98907947d284951dd2b20c23a6786ff50f7e6a8ec515bd50',
+    filename='camstack-yolov8n-plate.onnx',
+)
+_PLATE_PT = Download(
+    url='https://huggingface.co/Koushim/yolov8-license-plate-detection/resolve/'
+        '9aaa5cd490abe0c165882ba87f4f62658ab54d01/best.pt',
+    sha256='2d95861825bb4184404344c9cf809f40fd31dba785fe54e8ba5b9a3583789822',
+    filename='yolov8n-plate.pt',
+)
+
+PLATE = Recipe(
+    name='camstack-yolov8n-plate', folder='plateDetection/yolov8-plate', imgsz=640,
+    toolchain=TC_PLATE, checkpoint=_PLATE_PT,
+    onnx=None, onnx_verbatim=_PLATE_ONNX,
+    coreml=CoremlExport(dynamic=False, batch=1, half=False),
+    openvino=(FP16_IR,), tflite=True,
+    note='ONNX + IR: ml-debi/yolov8-license-plate-detection; CoreML + TFLite: '
+         'Koushim/yolov8-license-plate-detection (different fine-tunes)',
+)
+
+RECIPES: tuple[Recipe, ...] = (
+    *(_yolo26_full(t) for t in 'nsmlx'),
+    *(_yolo26_reduced(t, r) for t in 'nsml' for r in (320, 256)),
+    *(_yolov9(t, r) for t in ('t', 's', 'm', 'c') for r in (320, 640)),
+    *(_yolo26_seg(t) for t in 'nsm'),
+    PLATE,
+)
+
+FAMILIES = {
+    'yolo26': 'objectDetection/yolo26',
+    'yolov9': 'objectDetection/yolov9',
+    'yolo26-seg': 'segmentation/yolo26-seg',
+    'yolov8-plate': 'plateDetection/yolov8-plate',
+}
+ALL_FORMATS = ('onnx', 'coreml', 'openvino', 'tflite')
+
+# --- Helpers ----------------------------------------------------------------
+
+
+def size_mb(path: Path) -> float:
+    if path.is_file():
+        return path.stat().st_size / 1_048_576
+    return sum(f.stat().st_size for f in path.rglob('*') if f.is_file()) / 1_048_576
+
+
+def sha256_of(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open('rb') as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b''):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def fetch(dl: Download, cache: Path) -> Path:
+    """Download a third-party file once and refuse it if the SHA-256 differs."""
+    cache.mkdir(parents=True, exist_ok=True)
+    dest = cache / dl.filename
+    if not dest.is_file():
+        print(f'  → downloading {dl.url}')
+        urllib.request.urlretrieve(dl.url, dest)
+    got = sha256_of(dest)
+    if got != dl.sha256:
+        raise RuntimeError(f'{dest} has sha256 {got}, expected {dl.sha256}')
+    return dest
+
+
+def warn_toolchain(recipe: Recipe) -> None:
+    try:
+        import ultralytics
+    except ImportError:
+        return
+    want = recipe.toolchain.ultralytics.split(' ')[0]
+    if ultralytics.__version__ != want:
+        print(f'  ! the hosted {recipe.name} files were made with ultralytics {want}; '
+              f'this is {ultralytics.__version__} (same weights, the graph may differ)')
+
+
+def place(src: Path, dest: Path) -> Path:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    if dest.exists():
+        shutil.rmtree(dest) if dest.is_dir() else dest.unlink()
+    (shutil.copytree if src.is_dir() else shutil.copy2)(src, dest)
+    print(f'    ✓ {dest} ({size_mb(dest):.1f} MB)')
+    return dest
+
+
+def checkpoint_path(recipe: Recipe, cache: Path) -> str:
+    if isinstance(recipe.checkpoint, Download):
+        return str(fetch(recipe.checkpoint, cache))
+    return f'{recipe.checkpoint}.pt'  # Ultralytics downloads its own assets
+
+
+# --- Child processes ----------------------------------------------------------
+# Every backend runs in its OWN interpreter. On macOS two of them in one process
+# abort it: an ONNX export followed by a CoreML export ("libc++abi: mutex lock
+# failed"), and OpenVINO beside torch / onnx / tensorflow (each initialises its
+# own protobuf). A child per step keeps a crash to that step, reported as a
+# failure, and the parent imports none of them.
+
+_CHILD_MARKER = '@@CAMSTACK_CHILD@@'
+
+_ULTRALYTICS_CHILD = f"""
+import json, sys
+from ultralytics import YOLO
+args = json.loads(sys.argv[1])
+path = YOLO(args.pop('checkpoint')).export(**args)
+print('\\n{_CHILD_MARKER}' + str(path), flush=True)
+"""
+
+# Only openvino (and, for INT8, nncf + cv2) is imported here: no torch, no onnx,
+# no tensorflow. The conversion is convert_lib's, the same code Model Studio runs.
+_OPENVINO_CHILD = f"""
+import json, sys
+args = json.loads(sys.argv[1])
+sys.path.insert(0, args['convert_lib_dir'])
+from convert_lib import export_openvino, quantize_openvino_int8, validate_openvino_ir
+if args['precision'] == 'int8':
+    quantize_openvino_int8(args['onnx'], args['xml'], args['calib_dir'], args['imgsz'],
+                           max_samples=args['calib_samples'])
+else:
+    export_openvino(args['onnx'], args['xml'], fp16=args['precision'] == 'fp16')
+validate_openvino_ir(args['xml'])
+print('\\n{_CHILD_MARKER}' + args['xml'], flush=True)
+"""
+
+_COREML_CHECK_CHILD = f"""
+import json, sys
+import coremltools as ct
+import numpy as np
+args = json.loads(sys.argv[1])
+model = ct.models.MLModel(args['package'])
+name = model.get_spec().description.input[0].name
+for batch in (1, 4):
+    out = model.predict({{name: np.random.rand(batch, 3, args['imgsz'], args['imgsz']).astype(np.float32)}})
+    print(f'    batch={{batch}} -> {{getattr(next(iter(out.values())), "shape", "?")}}')
+print('\\n{_CHILD_MARKER}ok', flush=True)
+"""
+
+
+def run_child(code: str, payload: dict[str, object], what: str) -> str:
+    """Run one backend step in a fresh interpreter; return what it reported.
+
+    The step counts as done only when the child printed its marker line; a
+    child that crashes (a signal, an abort) before that is a failed step and is
+    never retried.
+    """
+    proc = subprocess.run(
+        [sys.executable, '-c', code, json.dumps(payload)],
+        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
     )
-    src = model.export(
-        format="coreml",
-        imgsz=imgsz,
-        dynamic=True,
-        batch=BATCH_RANGE_UPPER,
-        half=True,
-        nms=False,
+    marked = [ln[len(_CHILD_MARKER):] for ln in proc.stdout.splitlines() if ln.startswith(_CHILD_MARKER)]
+    if not marked:
+        sys.stdout.write('\n'.join(proc.stdout.splitlines()[-25:]) + '\n')
+        raise RuntimeError(f'{what} failed (child exit {proc.returncode})')
+    if proc.returncode != 0:
+        print(f'  ! {what}: the child exited {proc.returncode} after finishing')
+    return marked[-1]
+
+
+def ultralytics_export(checkpoint: str, **kwargs: object) -> Path:
+    path = Path(run_child(_ULTRALYTICS_CHILD, {'checkpoint': checkpoint, **kwargs},
+                          f'ultralytics export {kwargs} of {checkpoint}'))
+    if not path.exists():
+        raise RuntimeError(f'ultralytics export reported {path}, which does not exist')
+    return path
+
+
+# --- Format steps -------------------------------------------------------------
+
+
+def build_onnx(recipe: Recipe, out: Path, cache: Path) -> Path:
+    dest = out / recipe.folder / 'onnx' / f'{recipe.name}.onnx'
+    if recipe.onnx_verbatim is not None:
+        print('  → ONNX: third-party file, hosted unmodified')
+        return place(fetch(recipe.onnx_verbatim, cache), dest)
+    assert recipe.onnx is not None
+    print(f'  → ONNX (imgsz={recipe.imgsz}, dynamic={recipe.onnx.dynamic}, opset={recipe.onnx.opset})')
+    src = ultralytics_export(
+        checkpoint_path(recipe, cache), format='onnx', imgsz=recipe.imgsz,
+        dynamic=recipe.onnx.dynamic, simplify=True, opset=recipe.onnx.opset,
+        nms=False, batch=1, half=False,
     )
-    if not src:
-        raise RuntimeError(f"CoreML export returned no path for {ultra_id}")
-    src = Path(src)
-    if out_path.exists():
-        shutil.rmtree(out_path)
-    if src.is_dir():
-        shutil.copytree(src, out_path)
-    else:
-        out_path.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(src, out_path / src.name)
-    print(f"    ✓ {out_path.name} ({get_size_mb(out_path):.1f} MB)")
-    return out_path
-
-
-# --- Step 3: ONNX -> OpenVINO (dynamic batch IR) -----------------------
-# export_openvino, quantize_openvino_int8, validate_openvino_ir are imported
-# from convert_lib.py (shared with the runtime; located above).
-
-# --- Step 4: Verification ---------------------------------------------
-
-
-def verify_coreml_batch(mlpackage_path: Path, imgsz: int) -> None:
-    """Predict with N=1 then N=4 to confirm batch flexibility works."""
-    import coremltools as ct
-    import numpy as np
-
-    print(f"  → loading {mlpackage_path.name} for verification")
-    model = ct.models.MLModel(str(mlpackage_path))
-    # Find input name
-    spec = model.get_spec()
-    input_name = spec.description.input[0].name
-
-    for batch in (1, 4):
-        x = np.random.rand(batch, 3, imgsz, imgsz).astype(np.float32)
-        out = model.predict({input_name: x})
-        out_keys = list(out.keys())
-        out_shape = out[out_keys[0]].shape if hasattr(out[out_keys[0]], "shape") else "?"
-        print(f"    ✓ batch={batch} → output[{out_keys[0]}].shape={out_shape}")
-
-
-# --- Main --------------------------------------------------------------
-
-
-def main() -> None:
-    output = ensure_dir(OUTPUT_DIR)
-    print(f"Output: {output.resolve()}")
-
-    for ultra_id, name, imgsz in MODELS:
-        print()
-        print("=" * 70)
-        print(f"Building {name}  (source: {ultra_id}.pt, imgsz={imgsz}×{imgsz})")
-        print("=" * 70)
-
-        onnx_path = output / f"{name}.onnx"
-        coreml_path = output / f"{name}.mlpackage"
-
-        try:
-            export_onnx(ultra_id, onnx_path, imgsz)
-        except Exception as e:
-            print(f"  ✗ ONNX export failed: {e}")
-            continue
+    return place(src, dest)
+
 
-        try:
-            export_coreml(ultra_id, coreml_path, imgsz)
-        except Exception as e:
-            print(f"  ✗ CoreML conversion failed: {e}")
-
-        # OpenVINO IR variants — all converted from the ONNX via ov.convert_model
-        # (NOT the Ultralytics openvino exporter). fp32 baseline + fp16 (GPU/NPU).
-        try:
-            out_xml_fp32 = output / f"{name}.xml"
-            export_openvino(str(onnx_path), str(out_xml_fp32), fp16=False)
-            validate_openvino_ir(str(out_xml_fp32))
-            out_xml_fp16 = output / f"{name}-fp16.xml"
-            export_openvino(str(onnx_path), str(out_xml_fp16), fp16=True)
-            validate_openvino_ir(str(out_xml_fp16))
-        except Exception as e:
-            print(f"  ✗ OpenVINO conversion failed: {e}")
-
-        # INT8 — only when calibration images are present.
-        if CALIB_DIR.is_dir() and any(CALIB_DIR.iterdir()):
-            try:
-                out_xml_int8 = output / f"{name}-int8.xml"
-                quantize_openvino_int8(
-                    str(onnx_path), str(out_xml_int8), str(CALIB_DIR), imgsz
-                )
-                validate_openvino_ir(str(out_xml_int8))
-            except Exception as e:
-                print(f"  ✗ OpenVINO INT8 quantization failed: {e}")
+def build_coreml(recipe: Recipe, out: Path, cache: Path, verify: bool) -> Path:
+    assert recipe.coreml is not None
+    c = recipe.coreml
+    print(f'  → CoreML (imgsz={recipe.imgsz}, dynamic={c.dynamic}, batch={c.batch}, half={c.half})')
+    src = ultralytics_export(
+        checkpoint_path(recipe, cache), format='coreml', imgsz=recipe.imgsz,
+        dynamic=c.dynamic, batch=c.batch, half=c.half, nms=False,
+    )
+    dest = place(src, out / recipe.folder / 'coreml' / f'{recipe.name}.mlpackage')
+    if verify and c.dynamic:
+        verify_coreml_batch(dest, recipe.imgsz)
+    return dest
+
+
+def build_openvino(recipe: Recipe, onnx_path: Path, out: Path, calib_dir: Path,
+                   calib_samples: int) -> list[str]:
+    """Every IR of the recipe, each in its own child. Returns the outputs it skipped."""
+    skipped: list[str] = []
+    for ov in recipe.openvino:
+        xml = out / recipe.folder / 'openvino' / f'{recipe.name}{ov.suffix}.xml'
+        if ov.precision == 'int8' and not (calib_dir.is_dir() and any(calib_dir.iterdir())):
+            print(f'  ⊘ {xml.name}: no calibration images in {calib_dir} (--calib-dir)')
+            skipped.append(str(xml))
+            continue
+        detail = f'NNCF, {calib_samples} images from {calib_dir}' if ov.precision == 'int8' else 'ov.convert_model'
+        print(f'  → OpenVINO {ov.precision.upper()} {xml.name} ({detail})')
+        xml.parent.mkdir(parents=True, exist_ok=True)
+        run_child(_OPENVINO_CHILD, {
+            'convert_lib_dir': str(_CONVERT_LIB_DIR), 'onnx': str(onnx_path.resolve()),
+            'xml': str(xml.resolve()), 'precision': ov.precision, 'imgsz': recipe.imgsz,
+            'calib_dir': str(calib_dir.resolve()), 'calib_samples': calib_samples,
+        }, f'OpenVINO {ov.precision} {xml.name}')
+        print(f'    ✓ {xml} ({size_mb(xml.with_suffix(".bin")):.1f} MB)')
+    return skipped
+
+
+def build_tflite(recipe: Recipe, out: Path, cache: Path) -> Path:
+    print(f'  → TFLite float32 (imgsz={recipe.imgsz})')
+    saved = ultralytics_export(checkpoint_path(recipe, cache), format='tflite', imgsz=recipe.imgsz)
+    stem = Path(checkpoint_path(recipe, cache)).stem
+    src = next(saved.rglob(f'{stem}_float32.tflite'), None) if saved.is_dir() else saved
+    if src is None:
+        raise RuntimeError(f'no {stem}_float32.tflite under {saved}')
+    return place(src, out / recipe.folder / 'tflite' / f'{recipe.name}_float32.tflite')
+
+
+def verify_coreml_batch(mlpackage: Path, imgsz: int) -> None:
+    """Predict with N=1 then N=4 on a flexible-batch package, in a throwaway child.
+
+    Opt-in (--verify-coreml): CoreML's runtime has aborted the whole process on
+    one of these packages (Espresso gather_nd shape computation) on a Mac whose
+    toolchain differs from the recorded one. A crash here is a failed CHECK, not
+    a failed build — the package on disk is the export's output either way.
+    """
+    try:
+        run_child(_COREML_CHECK_CHILD, {'package': str(mlpackage.resolve()), 'imgsz': imgsz},
+                  f'CoreML batch check of {mlpackage.name}')
+        print('    ✓ flexible batch predicts at N=1 and N=4')
+    except RuntimeError as exc:
+        print(f'  ! {exc}; the package is kept, check it on the target device')
+
+
+# --- Orchestration ------------------------------------------------------------
+
+
+@dataclass
+class Report:
+    failed: list[str] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+
+
+def run_step(report: Report, label: str, step: Callable[[], object]) -> object:
+    try:
+        return step()
+    except Exception as exc:  # one failed format must not stop the others
+        print(f'  ✗ {label} failed: {exc}')
+        report.failed.append(label)
+        return None
+
+
+def build(recipe: Recipe, formats: set[str], out: Path, cache: Path, calib_dir: Path,
+          calib_samples: Optional[int], verify_coreml: bool, report: Report) -> None:
+    print('\n' + '=' * 70 + f'\n{recipe.name}  ({recipe.folder}, {recipe.imgsz}×{recipe.imgsz})\n' + '=' * 70)
+    if recipe.note:
+        print(f'  {recipe.note}')
+    warn_toolchain(recipe)
+    onnx_path: Optional[Path] = None
+    if formats & {'onnx', 'openvino'} and (recipe.onnx or recipe.onnx_verbatim):
+        result = run_step(report, f'{recipe.name} onnx', lambda: build_onnx(recipe, out, cache))
+        onnx_path = result if isinstance(result, Path) else None
+    if 'coreml' in formats and recipe.coreml is not None:
+        if sys.platform != 'darwin':
+            print('  ⊘ CoreML needs macOS')
+            report.skipped.append(f'{recipe.name} coreml')
         else:
-            print(f"  ⊘ INT8 skipped — no calibration images in {CALIB_DIR} (set CAMSTACK_CALIB_DIR)")
-
-        if coreml_path.exists():
-            try:
-                verify_coreml_batch(coreml_path, imgsz)
-            except Exception as e:
-                print(f"  ✗ CoreML verification failed: {e}")
-
-    # --- Summary ---
-    print()
-    print("=" * 70)
-    print("Build complete. Files:")
-    print("=" * 70)
-    total = 0.0
-    for f in sorted(output.iterdir()):
-        size = get_size_mb(f)
-        total += size
-        print(f"  {f.name:50s} {size:8.1f} MB")
-    print("  " + "─" * 60)
-    print(f"  {'Total':50s} {total:8.1f} MB")
-    print()
-    print("Upload to HF camstack/camstack-models when ready.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())
+            run_step(report, f'{recipe.name} coreml', lambda: build_coreml(recipe, out, cache, verify_coreml))
+    if 'openvino' in formats and recipe.openvino and onnx_path is not None:
+        samples = calib_samples or recipe.calib_samples or 300
+        skipped = run_step(report, f'{recipe.name} openvino',
+                           lambda: build_openvino(recipe, onnx_path, out, calib_dir, samples))
+        report.skipped.extend(skipped if isinstance(skipped, list) else [])
+    if 'tflite' in formats and recipe.tflite:
+        run_step(report, f'{recipe.name} tflite', lambda: build_tflite(recipe, out, cache))
+
+
+def adhoc_recipe(args: argparse.Namespace) -> Recipe:
+    """A recipe from the command line, for a size/resolution the mirror does not host."""
+    precisions = [p for p in (args.openvino or 'fp16,int8').split(',') if p]
+    bad = [p for p in precisions if p not in ('fp32', 'fp16', 'int8')]
+    if bad:
+        sys.exit(f'--openvino accepts fp32, fp16, int8; got {bad}')
+    name = args.name or f'camstack-{args.model}-{args.imgsz}'
+    return Recipe(
+        name=name, folder=args.folder, imgsz=args.imgsz,
+        toolchain=Toolchain('any', 'any', 'any', 'any'), checkpoint=args.model,
+        onnx=OnnxExport(dynamic=args.dynamic, opset=args.opset),
+        coreml=CoremlExport(dynamic=args.dynamic, batch=16 if args.dynamic else 1, half=args.half),
+        openvino=tuple(OpenvinoOutput(f'-{p}', p) for p in precisions),
+        calib_samples=args.calib_samples or 300,
+    )
+
+
+def hosted_weight_paths() -> list[str]:
+    url = f'https://huggingface.co/api/models/{HF_REPO}/tree/main?recursive=true'
+    with urllib.request.urlopen(url, timeout=60) as resp:
+        tree = json.load(resp)
+    prefixes = tuple(f'{f}/' for f in FAMILIES.values())
+    return sorted(
+        e['path'] for e in tree
+        if e['type'] == 'file' and e['path'].startswith(prefixes) and not e['path'].endswith('README.md')
+    )
+
+
+def check_hosted() -> int:
+    """Every hosted AGPL weight file is an output of a recipe, and vice versa."""
+    hosted = hosted_weight_paths()
+    outputs = [o for r in RECIPES for o in r.outputs()]
+
+    def covered(path: str) -> bool:
+        return any(path == o or (o.endswith('/') and path.startswith(o)) for o in outputs)
+
+    def present(output: str) -> bool:
+        return any(h == output or (output.endswith('/') and h.startswith(output)) for h in hosted)
+
+    orphans = [h for h in hosted if not covered(h)]
+    unhosted = [o for o in outputs if not present(o)]
+    print(f'{len(hosted)} hosted files under {", ".join(FAMILIES.values())}; '
+          f'{len(RECIPES)} recipes, {len(outputs)} outputs')
+    for h in orphans:
+        print(f'  NOT REPRODUCED by any recipe: {h}')
+    for o in unhosted:
+        print(f'  recipe output not hosted: {o}')
+    if orphans or unhosted:
+        return 1
+    print('OK: every hosted file is a recipe output, and every recipe output is hosted.')
+    return 0
+
+
+def list_recipes() -> None:
+    for r in RECIPES:
+        ov = ','.join(f'{o.precision}{"→" + o.suffix if o.suffix else ""}' for o in r.openvino)
+        src = r.checkpoint if isinstance(r.checkpoint, str) else r.checkpoint.url
+        onnx = 'verbatim' if r.onnx_verbatim else (
+            f'{"dynamic" if r.onnx and r.onnx.dynamic else "static"} opset{r.onnx.opset if r.onnx else ""}')
+        cm = (f'{"flex≤" + str(r.coreml.batch) if r.coreml.dynamic else "static"}'
+              f'{" fp16" if r.coreml.half else ""}') if r.coreml else '-'
+        int8 = f' int8 N={r.calib_samples}' if any(o.precision == 'int8' for o in r.openvino) else ''
+        print(f'{r.name:30s} {r.folder:28s} {r.imgsz:4d}  onnx[{onnx}] coreml[{cm}] '
+              f'openvino[{ov}]{int8}{" tflite" if r.tflite else ""}  '
+              f'ultralytics {r.toolchain.ultralytics}  from {src}')
+
+
+def parse_args(argv: list[str]) -> argparse.Namespace:
+    p = argparse.ArgumentParser(description=__doc__.split('\n\n')[0],
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    sel = p.add_argument_group('what to build')
+    sel.add_argument('--all', action='store_true', help='every hosted recipe')
+    sel.add_argument('--family', action='append', choices=sorted(FAMILIES), help='one mirror folder')
+    sel.add_argument('--variant', action='append', help='a hosted file stem, e.g. camstack-yolov9m-320')
+    sel.add_argument('--list', action='store_true', help='print the recipes and exit')
+    sel.add_argument('--check-hosted', action='store_true',
+                     help='compare the recipes with the live mirror and exit (non-zero on a gap)')
+    sel.add_argument('--dry-run', action='store_true', help='print the files that would be built')
+    p.add_argument('--formats', default=','.join(ALL_FORMATS), help='subset of onnx,coreml,openvino,tflite')
+    p.add_argument('--out', type=Path, default=Path('exported-models'))
+    p.add_argument('--cache', type=Path, default=Path('exported-models/.downloads'),
+                   help='where third-party checkpoints are downloaded')
+    p.add_argument('--calib-dir', type=Path, default=DEFAULT_CALIB_DIR)
+    p.add_argument('--verify-coreml', action='store_true',
+                   help='predict N=1 and N=4 on each flexible-batch CoreML package (in a child process)')
+    p.add_argument('--calib-samples', type=int, help="override the recipe's INT8 calibration image count")
+    adhoc = p.add_argument_group('ad-hoc build (not a hosted file)')
+    adhoc.add_argument('--model', help='Ultralytics id, e.g. yolo26n, yolov9m, yolo26s-seg')
+    adhoc.add_argument('--imgsz', type=int, default=640)
+    adhoc.add_argument('--name', help='output stem (default camstack-<model>-<imgsz>)')
+    adhoc.add_argument('--folder', default='custom')
+    adhoc.add_argument('--dynamic', action='store_true', help='dynamic axes (ONNX) / flexible batch (CoreML)')
+    adhoc.add_argument('--opset', type=int, default=17)
+    adhoc.add_argument('--half', action='store_true', help='FP16 CoreML')
+    adhoc.add_argument('--openvino', help='IR precisions, comma-separated: fp32,fp16,int8')
+    return p.parse_args(argv)
+
+
+def select(args: argparse.Namespace) -> list[Recipe]:
+    if args.model:
+        return [adhoc_recipe(args)]
+    by_name = {r.name: r for r in RECIPES}
+    unknown = [v for v in (args.variant or []) if v not in by_name]
+    if unknown:
+        sys.exit(f'unknown --variant {unknown}; see --list')
+    folders = {FAMILIES[f] for f in (args.family or [])}
+    return [r for r in RECIPES
+            if args.all or r.folder in folders or r.name in (args.variant or [])]
+
+
+def main(argv: list[str]) -> int:
+    args = parse_args(argv)
+    if args.list:
+        list_recipes()
+        return 0
+    if args.check_hosted:
+        return check_hosted()
+    recipes = select(args)
+    if not recipes:
+        print('Nothing selected: pass --all, --family, --variant or --model (see --help).')
+        return 2
+    formats = {f for f in args.formats.split(',') if f}
+    if formats - set(ALL_FORMATS):
+        sys.exit(f'--formats accepts {",".join(ALL_FORMATS)}')
+    if args.dry_run:
+        for r in recipes:
+            for o in r.outputs():
+                print(args.out / o)
+        return 0
+    report = Report()
+    for r in recipes:
+        build(r, formats, args.out, args.cache, args.calib_dir, args.calib_samples,
+              args.verify_coreml, report)
+    print('\nDone.' + (f' Failed: {report.failed}.' if report.failed else '')
+          + (f' Skipped: {report.skipped}.' if report.skipped else ''))
+    return 1 if report.failed else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))