docs: notices, licences and source/ after the plate detector swap (D718)

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.

LICENSES/AGPL-3.0.txt

@@ -1,6 +1,6 @@
 Source: https://www.gnu.org/licenses/agpl-3.0.txt
 Fetched: 2026-09-26 (verbatim below the line; nothing edited)
-Applies to: Ultralytics weights: objectDetection/yolo26, objectDetection/yolov9, segmentation/yolo26-seg, plateDetection/yolov8-plate
+Applies to: Ultralytics weights: objectDetection/yolo26, objectDetection/yolov9, segmentation/yolo26-seg
 Note: byte-identical to https://raw.githubusercontent.com/ultralytics/ultralytics/main/LICENSE, fetched the same day.
 --------------------------------------------------------------------------------
                     GNU AFFERO GENERAL PUBLIC LICENSE

LICENSES/Apache-2.0.txt

@@ -1,7 +1,7 @@
 Source: https://www.apache.org/licenses/LICENSE-2.0.txt
 Fetched: 2026-09-26 (verbatim below the line; nothing edited)
-Applies to: RF-DETR (Roboflow), AuraFace v1 (fal.ai), U-2-Net (Xuebin Qin et al.), YAMNet (tensorflow/models), AIY Vision Birds V1 and the Coral Edge TPU models (google-coral/test_data), timm EfficientNet-Lite0, Qwen2.5 / Qwen3-VL / Qwen3.6
-Note: none of those upstream repositories carries a NOTICE file (checked 2026-09-26 via the GitHub contents API and the HF file list), so Apache-2.0 section 4(d) adds nothing to reproduce.
+Applies to: RF-DETR (Roboflow), AuraFace v1 (fal.ai), U-2-Net (Xuebin Qin et al.), YAMNet (tensorflow/models), AIY Vision Birds V1 and the Coral Edge TPU models (google-coral/test_data), timm EfficientNet-Lite0, Qwen2.5 / Qwen3-VL / Qwen3.6, open-lpr YOLOX-tiny plate detector (faisalthaheem/open-lpr-models, added 2026-10-06)
+Note: none of those upstream repositories carries a NOTICE file (checked 2026-09-26 via the GitHub contents API and the HF file list), so Apache-2.0 section 4(d) adds nothing to reproduce, except open-lpr models, whose NOTICE is reproduced in NOTICE-open-lpr.txt. Its LICENSE is this text (checked 2026-10-06).
 --------------------------------------------------------------------------------
 
                                  Apache License

LICENSES/NOTICE-open-lpr.txt

@@ -0,0 +1,44 @@
+Source: https://huggingface.co/faisalthaheem/open-lpr-models/resolve/aed0df35ec2891c5a90437041ebeadb592cc516b/NOTICE
+Fetched: 2026-10-06 (verbatim below the line; nothing edited)
+Applies to: plateDetection/yolox-tiny-plate (open-lpr YOLOX-tiny plate detector, Apache-2.0; licence text: Apache-2.0.txt). Apache-2.0 section 4(d) requires this NOTICE to accompany redistribution.
+--------------------------------------------------------------------------------
+open-lpr models
+Copyright the open-lpr contributors
+
+This product includes software developed by third parties. The artifacts in
+this repository are NOT all ours; per-artifact provenance is recorded in
+manifest.json and summarised below.
+
+--------------------------------------------------------------------------------
+plate_yolox_tiny_640.onnx  and  best_ckpt.pth
+--------------------------------------------------------------------------------
+Produced by this project. Architecture from YOLOX (Megvii-BaseDetection/YOLOX),
+which is licensed Apache-2.0 for both its code and its same-repository release
+weights. Pretrained from COCO (yolox_tiny.pth), then fine-tuned on an annotated
+licence-plate corpus plus community-contributed images pseudo-labelled by a
+teacher model.
+
+The training imagery is not published. It consists of user-contributed
+photographs containing real licence plates, faces and vehicles, uploaded without
+consent obtained. Publishing it would create a searchable index of real vehicle
+registration numbers.
+
+Ultralytics YOLO weights are licensed AGPL-3.0 and are deliberately NOT used,
+redistributed, or derived from anywhere in this project.
+
+--------------------------------------------------------------------------------
+plate_ocr_ppocrv5_mobile.onnx  and  plate_ocr_dict.json
+--------------------------------------------------------------------------------
+NOT produced by this project. These are conversions of an upstream recognition
+model from PaddleOCR (https://github.com/PaddlePaddle/PaddleOCR), which is
+licensed under Apache-2.0.
+
+The specific upstream release was never recorded and cannot be recovered from
+the artifacts: the ONNX graph carries no producer, producer_version or
+doc_string, and no PaddlePaddle installation, wheel or shell history survives on
+the build host. The Apache-2.0 licence is therefore asserted at project level
+and is NOT pinned to a verified release.
+
+These two files are a MATCHED PAIR and must be used together. Decoding assumes
+len(dictionary) + 2 output classes; substituting either without the other
+produces silently incorrect text rather than an error.

README.md

@@ -18,7 +18,7 @@ library_name: onnx
 
 This repository is a **mirror of third-party models** converted by
 [CamStack](https://camstack-docs.zentik.app) into the formats its inference
-engines run (ONNX, OpenVINO IR, CoreML, TFLite). **Nothing here is relicensed.**
+engines run (ONNX, OpenVINO IR, CoreML). **Nothing here is relicensed.**
 Each folder stays under the licence of the model it was made from, stated in the
 folder's `README.md` and in the table below, with the full text in
 [`LICENSES/`](LICENSES). The repository as a whole has no single licence; see
@@ -35,9 +35,8 @@ fetched from other repositories, with the attributions each licence requires.
 
 ## AGPL-3.0 models (Ultralytics)
 
-`objectDetection/yolo26`, `objectDetection/yolov9`, `segmentation/yolo26-seg`,
-and `plateDetection/yolov8-plate` hold
-Ultralytics weights under **AGPL-3.0** ([`LICENSES/AGPL-3.0.txt`](LICENSES/AGPL-3.0.txt)).
+`objectDetection/yolo26`, `objectDetection/yolov9` and `segmentation/yolo26-seg`
+hold Ultralytics weights under **AGPL-3.0** ([`LICENSES/AGPL-3.0.txt`](LICENSES/AGPL-3.0.txt)).
 Their Corresponding Source is set out in
 [Source offer for the AGPL-3.0 weights](THIRD_PARTY_MODELS.md#source-offer-for-the-agpl-30-weights).
 
@@ -50,8 +49,12 @@ This **may not be used commercially**. See the folder's card.
 
 ## Required attributions
 
-- **Ultralytics YOLO26, YOLOv9, YOLOv8**: © Ultralytics, AGPL-3.0. YOLOv9
+- **Ultralytics YOLO26, YOLOv9**: © Ultralytics, AGPL-3.0. YOLOv9
   architecture: Chien-Yao Wang, I-Hau Yeh, Hong-Yuan Mark Liao, GPL-3.0.
+- **open-lpr models** (plate detector): Copyright the open-lpr contributors,
+  Apache-2.0; YOLOX architecture and COCO pretraining by Megvii, Apache-2.0.
+  The upstream `NOTICE` is in the folder and in
+  [`LICENSES/NOTICE-open-lpr.txt`](LICENSES/NOTICE-open-lpr.txt).
 - **fast-plate-ocr**: Copyright (c) 2024 ankandrew, MIT.
 - **Open Images V7** (animal-classifier training data): annotations © Google
   LLC, CC BY 4.0.
@@ -77,7 +80,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) | 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) |
+| `plateDetection/yolox-tiny-plate` | `yolox-tiny-plate` (default) | open-lpr models (faisalthaheem/open-lpr-models), YOLOX-tiny | Apache-2.0 | [`Apache-2.0.txt`](LICENSES/Apache-2.0.txt) | 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) |
 | `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 |
@@ -90,6 +93,6 @@ marks an entry kept resolvable for a saved selection but no longer offered.
 
 This mirror holds only the models CamStack offers. Models it no longer offers
 (SCRFD, ArcFace, Inception-ResNet, VGG-English, MobileCLIP S1/S2,
-YOLOv8n-package, SSDLite MobileDet, and earlier a third-party face, PaddleOCR,
+YOLOv8n-package, SSDLite MobileDet, the YOLOv8n plate detector, and earlier a third-party face, PaddleOCR,
 animals-10, NABirds and EfficientNet folders) were removed, and the repository
 history was squashed on 2026-10-06.

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 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
+- 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`). https://huggingface.co/faisalthaheem/open-lpr-models
 - 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
@@ -62,7 +62,7 @@ Training data under attribution terms:
   cards link here instead of repeating it.
 -->
 
-The folders `objectDetection/yolo26`, `objectDetection/yolov9`, `plateDetection/yolov8-plate` and `segmentation/yolo26-seg` of the model mirror hold Ultralytics weights,
+The folders `objectDetection/yolo26`, `objectDetection/yolov9` and `segmentation/yolo26-seg` of the model mirror hold Ultralytics weights,
 modified by CamStack and distributed under AGPL-3.0. Their Corresponding Source
 is published in the mirror itself, in its **`source/`** folder,
 **https://huggingface.co/camstack/camstack-models/tree/main/source**, together
@@ -70,15 +70,7 @@ with the upstream checkpoints it starts from:
 
 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.
+   https://github.com/ultralytics/assets/releases.
 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
@@ -106,11 +98,6 @@ Limits of a rebuild:
 - **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
 
@@ -159,7 +146,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) | [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` |
+| `yolox-tiny-plate` (default) | [open-lpr models (faisalthaheem/open-lpr-models), YOLOX-tiny](https://huggingface.co/faisalthaheem/open-lpr-models) | Apache-2.0 / Apache-2.0 (`Apache-2.0.txt`) | 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): UNKNOWN | 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) | mirror `plateDetection/yolox-tiny-plate` |
 
 ### Licence plate reading
 

source/README.md

@@ -4,13 +4,13 @@
 
 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`).
+`objectDetection/yolov9`, `segmentation/yolo26-seg`).
 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` | 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. |
+| `build-camstack-models.py` | Rebuilds every file in the three 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. |
@@ -32,8 +32,7 @@ python build-camstack-models.py --all --formats onnx,openvino    # some formats
 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`.
+TensorFlow crash one another when they share one. CoreML needs macOS.
 
 What the recipes encode (the hosted files record each of these):
 
@@ -43,13 +42,11 @@ What the recipes encode (the hosted files record each of these):
 | `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.
+8.4.98 / 2.13.0 / 9.0 / 2026.2.1. 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`;
@@ -74,24 +71,6 @@ 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
 
 - **These scripts** (`build-camstack-models.py`, `convert_lib.py`,

source/build-camstack-models.py

@@ -8,7 +8,6 @@ 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)
 
 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
@@ -40,7 +39,6 @@ Formats:
   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
@@ -62,7 +60,6 @@ convert_lib's). convert_lib.py is found next to this script (the mirror's
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import os
 import shutil
@@ -86,15 +83,6 @@ DEFAULT_CALIB_DIR = Path(os.environ.get('CAMSTACK_CALIB_DIR', 'calibration-image
 # --- Recipe model ------------------------------------------------------------
 
 
-@dataclass(frozen=True)
-class Download:
-    """A third-party file fetched by URL and verified by SHA-256."""
-
-    url: str
-    sha256: str
-    filename: str
-
-
 @dataclass(frozen=True)
 class OnnxExport:
     """Ultralytics export(format="onnx") arguments, as the hosted ONNX records them."""
@@ -139,28 +127,24 @@ class Recipe:
     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
+    # auto-downloaded by Ultralytics).
+    checkpoint: str
+    onnx: Optional[OnnxExport]
     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:
+        if self.onnx 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
 
 
@@ -171,7 +155,6 @@ class Recipe:
 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')
 
@@ -226,53 +209,19 @@ def _yolo26_seg(tier: str) -> Recipe:
     )
 
 
-# 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')
+ALL_FORMATS = ('onnx', 'coreml', 'openvino')
 
 # --- Helpers ----------------------------------------------------------------
 
@@ -283,27 +232,6 @@ def size_mb(path: Path) -> float:
     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
@@ -324,9 +252,7 @@ def place(src: Path, dest: Path) -> Path:
     return dest
 
 
-def checkpoint_path(recipe: Recipe, cache: Path) -> str:
-    if isinstance(recipe.checkpoint, Download):
-        return str(fetch(recipe.checkpoint, cache))
+def checkpoint_path(recipe: Recipe) -> str:
     return f'{recipe.checkpoint}.pt'  # Ultralytics downloads its own assets
 
 
@@ -408,27 +334,24 @@ def ultralytics_export(checkpoint: str, **kwargs: object) -> Path:
 # --- Format steps -------------------------------------------------------------
 
 
-def build_onnx(recipe: Recipe, out: Path, cache: Path) -> Path:
+def build_onnx(recipe: Recipe, out: 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,
+        checkpoint_path(recipe), format='onnx', imgsz=recipe.imgsz,
         dynamic=recipe.onnx.dynamic, simplify=True, opset=recipe.onnx.opset,
         nms=False, batch=1, half=False,
     )
     return place(src, dest)
 
 
-def build_coreml(recipe: Recipe, out: Path, cache: Path, verify: bool) -> Path:
+def build_coreml(recipe: Recipe, out: 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,
+        checkpoint_path(recipe), 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')
@@ -459,16 +382,6 @@ def build_openvino(recipe: Recipe, onnx_path: Path, out: Path, calib_dir: Path,
     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.
 
@@ -503,29 +416,27 @@ def run_step(report: Report, label: str, step: Callable[[], object]) -> object:
         return None
 
 
-def build(recipe: Recipe, formats: set[str], out: Path, cache: Path, calib_dir: Path,
+def build(recipe: Recipe, formats: set[str], out: 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))
+    if formats & {'onnx', 'openvino'} and recipe.onnx:
+        result = run_step(report, f'{recipe.name} onnx', lambda: build_onnx(recipe, out))
         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:
-            run_step(report, f'{recipe.name} coreml', lambda: build_coreml(recipe, out, cache, verify_coreml))
+            run_step(report, f'{recipe.name} coreml', lambda: build_coreml(recipe, out, 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:
@@ -584,15 +495,13 @@ def check_hosted() -> int:
 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 ""}')
+        onnx = 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}')
+              f'openvino[{ov}]{int8}  '
+              f'ultralytics {r.toolchain.ultralytics}  from {r.checkpoint}.pt')
 
 
 def parse_args(argv: list[str]) -> argparse.Namespace:
@@ -606,10 +515,8 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     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('--formats', default=','.join(ALL_FORMATS), help='subset of onnx,coreml,openvino')
     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)')
@@ -659,7 +566,7 @@ def main(argv: list[str]) -> int:
         return 0
     report = Report()
     for r in recipes:
-        build(r, formats, args.out, args.cache, args.calib_dir, args.calib_samples,
+        build(r, formats, args.out, 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 ''))