@camstack/addon-vision 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -1,282 +1,2730 @@
 import {
-  BirdGlobalClassifierAddon
-} from "./chunk-ZWYXXCXP.mjs";
+  require_animal_classification_models
+} from "./chunk-XD7WGXHZ.mjs";
 import {
-  BirdNABirdsClassifierAddon
-} from "./chunk-DRYFGARD.mjs";
+  require_vehicle_classification_models
+} from "./chunk-K36R6HWY.mjs";
 import {
-  AnimalClassifierAddon
-} from "./chunk-YUCD2TFH.mjs";
+  require_segmentation_refiner_models
+} from "./chunk-BS4DKYGN.mjs";
 import {
-  ANIMAL_TYPE_MODELS,
-  BIRD_NABIRDS_MODELS,
-  BIRD_SPECIES_MODELS
-} from "./chunk-DUN6XU3N.mjs";
+  require_frame_diff
+} from "./chunk-YYDM6V2F.mjs";
 import {
-  VEHICLE_TYPE_MODELS
-} from "./chunk-XZ6ZMXXU.mjs";
+  require_segmentation_models,
+  require_yolo_seg
+} from "./chunk-ZK7P3TZN.mjs";
 import {
-  SEGMENTATION_REFINER_MODELS
-} from "./chunk-7DYHXUPZ.mjs";
+  require_face_detection_models,
+  require_scrfd
+} from "./chunk-2YMA6QOV.mjs";
 import {
-  detectMotion
-} from "./chunk-BR2FPGOX.mjs";
+  require_arcface,
+  require_face_recognition_models
+} from "./chunk-F6D2OZ36.mjs";
 import {
-  ObjectDetectionAddon,
-  SEGMENTATION_MODELS
-} from "./chunk-R5J3WAUI.mjs";
+  require_plate_detection_models
+} from "./chunk-GAOIFQDX.mjs";
 import {
-  FACE_DETECTION_MODELS,
-  FaceDetectionAddon,
-  scrfdPostprocess
-} from "./chunk-ESLHNWWE.mjs";
+  require_yolo
+} from "./chunk-DE7I3VHO.mjs";
 import {
-  FACE_RECOGNITION_MODELS,
-  FaceRecognitionAddon,
-  cosineSimilarity,
-  l2Normalize
-} from "./chunk-JUQEW6ON.mjs";
+  require_object_detection_models
+} from "./chunk-MGT6RUVX.mjs";
 import {
-  PLATE_DETECTION_MODELS,
-  PlateDetectionAddon
-} from "./chunk-YPU4WTXZ.mjs";
+  require_paddleocr,
+  require_plate_recognition_models
+} from "./chunk-HUIX2XVR.mjs";
 import {
-  iou,
-  nms,
-  yoloPostprocess
-} from "./chunk-KUO2BVFY.mjs";
+  require_image_utils
+} from "./chunk-WG66JYYW.mjs";
 import {
-  MLPACKAGE_FILES,
-  OBJECT_DETECTION_MODELS
-} from "./chunk-BP7H4NFS.mjs";
+  require_audio_classification_models,
+  require_yamnet
+} from "./chunk-MBTAI3WE.mjs";
 import {
-  PLATE_RECOGNITION_MODELS,
-  PlateRecognitionAddon,
-  ctcDecode
-} from "./chunk-ZTJENCFC.mjs";
+  require_engine_resolver,
+  require_node_engine,
+  require_python_engine
+} from "./chunk-PIFS7AIT.mjs";
 import {
-  cropRegion,
-  jpegToRgb,
-  letterbox,
-  resizeAndNormalize,
-  rgbToGrayscale
-} from "./chunk-22BHCDT5.mjs";
-import {
-  AUDIO_CLASSIFICATION_MODELS,
-  AudioClassificationAddon,
-  yamnetPostprocess
-} from "./chunk-D6WEHN33.mjs";
-import {
-  NodeInferenceEngine,
-  PythonInferenceEngine,
-  probeOnnxBackends,
-  resolveEngine
-} from "./chunk-2IOKI4ES.mjs";
-import "./chunk-BJTO5JO5.mjs";
+  __commonJS,
+  __export,
+  __reExport,
+  __require,
+  __toESM
+} from "./chunk-3IIFBJCD.mjs";
 
-// src/catalogs/general-ocr-models.ts
-import { hfModelUrl } from "@camstack/types";
-var HF_REPO = "camstack/camstack-models";
-var OCR_TEXT_LABELS = [
-  { id: "text", name: "Scene Text" }
-];
-var GENERAL_OCR_MODELS = [
-  // ── OnnxTR / docTR — lightweight general scene text recognition ──
-  {
-    id: "doctr-det-db-mobilenet",
-    name: "docTR Detection MobileNet",
-    description: "docTR DBNet MobileNet V3 \u2014 lightweight text region detection for scene text",
-    inputSize: { width: 1024, height: 1024 },
-    labels: OCR_TEXT_LABELS,
-    formats: {
-      onnx: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-det-db-mobilenet-v3.onnx"),
-        sizeMB: 15
+// src/catalogs/general-ocr-models.js
+var require_general_ocr_models = __commonJS({
+  "src/catalogs/general-ocr-models.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GENERAL_OCR_MODELS = void 0;
+    var types_1 = __require("@camstack/types");
+    var HF_REPO = "camstack/camstack-models";
+    var OCR_TEXT_LABELS = [
+      { id: "text", name: "Scene Text" }
+    ];
+    exports.GENERAL_OCR_MODELS = [
+      // ── OnnxTR / docTR — lightweight general scene text recognition ──
+      {
+        id: "doctr-det-db-mobilenet",
+        name: "docTR Detection MobileNet",
+        description: "docTR DBNet MobileNet V3 \u2014 lightweight text region detection for scene text",
+        inputSize: { width: 1024, height: 1024 },
+        labels: OCR_TEXT_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-det-db-mobilenet-v3.onnx"),
+            sizeMB: 15
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-det-db-mobilenet-v3.mlpackage"),
+            sizeMB: 8,
+            isDirectory: true,
+            files: [
+              "Manifest.json",
+              "Data/com.apple.CoreML/model.mlmodel",
+              "Data/com.apple.CoreML/weights/weight.bin"
+            ],
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-det-db-mobilenet-v3.xml"),
+            sizeMB: 8,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-det-db-mobilenet-v3.mlpackage"),
-        sizeMB: 8,
-        isDirectory: true,
-        files: [
-          "Manifest.json",
-          "Data/com.apple.CoreML/model.mlmodel",
-          "Data/com.apple.CoreML/weights/weight.bin"
-        ],
-        runtimes: ["python"]
+      {
+        id: "doctr-rec-crnn-mobilenet",
+        name: "docTR Recognition CRNN MobileNet",
+        description: "docTR CRNN MobileNet V3 \u2014 lightweight text recognition for detected regions",
+        inputSize: { width: 128, height: 32 },
+        labels: OCR_TEXT_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-rec-crnn-mobilenet-v3.onnx"),
+            sizeMB: 5
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-rec-crnn-mobilenet-v3.mlpackage"),
+            sizeMB: 3,
+            isDirectory: true,
+            files: [
+              "Manifest.json",
+              "Data/com.apple.CoreML/model.mlmodel",
+              "Data/com.apple.CoreML/weights/weight.bin"
+            ],
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-rec-crnn-mobilenet-v3.xml"),
+            sizeMB: 3,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-det-db-mobilenet-v3.xml"),
-        sizeMB: 8,
-        runtimes: ["python"]
-      }
-    }
-  },
-  {
-    id: "doctr-rec-crnn-mobilenet",
-    name: "docTR Recognition CRNN MobileNet",
-    description: "docTR CRNN MobileNet V3 \u2014 lightweight text recognition for detected regions",
-    inputSize: { width: 128, height: 32 },
-    labels: OCR_TEXT_LABELS,
-    formats: {
-      onnx: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-rec-crnn-mobilenet-v3.onnx"),
-        sizeMB: 5
+      {
+        id: "doctr-rec-parseq",
+        name: "docTR Recognition PARSeq",
+        description: "docTR PARSeq \u2014 high-accuracy scene text recognition (top ICDAR scores)",
+        inputSize: { width: 128, height: 32 },
+        labels: OCR_TEXT_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-rec-parseq.onnx"),
+            sizeMB: 25
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-rec-parseq.mlpackage"),
+            sizeMB: 13,
+            isDirectory: true,
+            files: [
+              "Manifest.json",
+              "Data/com.apple.CoreML/model.mlmodel",
+              "Data/com.apple.CoreML/weights/weight.bin"
+            ],
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-rec-parseq.xml"),
+            sizeMB: 13,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-rec-crnn-mobilenet-v3.mlpackage"),
-        sizeMB: 3,
-        isDirectory: true,
-        files: [
-          "Manifest.json",
-          "Data/com.apple.CoreML/model.mlmodel",
-          "Data/com.apple.CoreML/weights/weight.bin"
-        ],
-        runtimes: ["python"]
+      // ── PaddleOCR PP-OCRv5 Mobile — general-purpose text detection + recognition ──
+      {
+        id: "ppocr-v5-det-mobile",
+        name: "PP-OCRv5 Detection Mobile",
+        description: "PP-OCRv5 mobile text detection \u2014 optimized for edge, 100+ languages",
+        inputSize: { width: 640, height: 640 },
+        labels: OCR_TEXT_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/onnx/camstack-ppocr-v5-det-mobile.onnx"),
+            sizeMB: 6
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/coreml/camstack-ppocr-v5-det-mobile.mlpackage"),
+            sizeMB: 3,
+            isDirectory: true,
+            files: [
+              "Manifest.json",
+              "Data/com.apple.CoreML/model.mlmodel",
+              "Data/com.apple.CoreML/weights/weight.bin"
+            ],
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/openvino/camstack-ppocr-v5-det-mobile.xml"),
+            sizeMB: 3,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-rec-crnn-mobilenet-v3.xml"),
-        sizeMB: 3,
-        runtimes: ["python"]
+      {
+        id: "ppocr-v5-rec-mobile",
+        name: "PP-OCRv5 Recognition Mobile",
+        description: "PP-OCRv5 mobile text recognition \u2014 100+ languages, CTC decoding",
+        inputSize: { width: 320, height: 48 },
+        labels: OCR_TEXT_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/onnx/camstack-ppocr-v5-rec-mobile.onnx"),
+            sizeMB: 8
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/coreml/camstack-ppocr-v5-rec-mobile.mlpackage"),
+            sizeMB: 4,
+            isDirectory: true,
+            files: [
+              "Manifest.json",
+              "Data/com.apple.CoreML/model.mlmodel",
+              "Data/com.apple.CoreML/weights/weight.bin"
+            ],
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/openvino/camstack-ppocr-v5-rec-mobile.xml"),
+            sizeMB: 4,
+            runtimes: ["python"]
+          }
+        },
+        extraFiles: [
+          {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "generalOcr/ppocr-v5/camstack-ppocr-v5-keys.txt"),
+            filename: "camstack-ppocr-v5-keys.txt",
+            sizeMB: 0.1
+          }
+        ]
+      }
+    ];
+  }
+});
+
+// src/catalogs/index.js
+var require_catalogs = __commonJS({
+  "src/catalogs/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_object_detection_models(), exports);
+    __exportStar(require_face_detection_models(), exports);
+    __exportStar(require_face_recognition_models(), exports);
+    __exportStar(require_plate_detection_models(), exports);
+    __exportStar(require_plate_recognition_models(), exports);
+    __exportStar(require_general_ocr_models(), exports);
+    __exportStar(require_audio_classification_models(), exports);
+    __exportStar(require_segmentation_models(), exports);
+    __exportStar(require_animal_classification_models(), exports);
+    __exportStar(require_vehicle_classification_models(), exports);
+    __exportStar(require_segmentation_refiner_models(), exports);
+  }
+});
+
+// src/addons/object-detection/index.js
+var require_object_detection = __commonJS({
+  "src/addons/object-detection/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
       }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var object_detection_models_js_1 = require_object_detection_models();
+    var segmentation_models_js_1 = require_segmentation_models();
+    var types_1 = __require("@camstack/types");
+    var image_utils_js_1 = require_image_utils();
+    var yolo_js_1 = require_yolo();
+    var yolo_seg_js_1 = require_yolo_seg();
+    var engine_resolver_js_1 = require_engine_resolver();
+    function isSegModel(modelId) {
+      return modelId.includes("-seg");
     }
-  },
-  {
-    id: "doctr-rec-parseq",
-    name: "docTR Recognition PARSeq",
-    description: "docTR PARSeq \u2014 high-accuracy scene text recognition (top ICDAR scores)",
-    inputSize: { width: 128, height: 32 },
-    labels: OCR_TEXT_LABELS,
-    formats: {
-      onnx: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/onnx/camstack-doctr-rec-parseq.onnx"),
-        sizeMB: 25
-      },
-      coreml: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/coreml/camstack-doctr-rec-parseq.mlpackage"),
-        sizeMB: 13,
-        isDirectory: true,
-        files: [
-          "Manifest.json",
-          "Data/com.apple.CoreML/model.mlmodel",
-          "Data/com.apple.CoreML/weights/weight.bin"
-        ],
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: hfModelUrl(HF_REPO, "generalOcr/doctr/openvino/camstack-doctr-rec-parseq.xml"),
-        sizeMB: 13,
-        runtimes: ["python"]
+    var ALL_DETECTION_MODELS = [
+      ...object_detection_models_js_1.OBJECT_DETECTION_MODELS,
+      ...segmentation_models_js_1.SEGMENTATION_MODELS
+    ];
+    function applyClassMap(detections, classMap) {
+      return detections.filter((d) => classMap.mapping[d.class] !== void 0).map((d) => ({
+        ...d,
+        originalClass: d.class,
+        class: classMap.mapping[d.class]
+      }));
+    }
+    var RAM_ESTIMATES = {
+      "yolov8n": 80,
+      "yolov8s": 150,
+      "yolov8s-relu": 150,
+      "yolov8m": 300,
+      "yolov8l": 500,
+      "yolov8x": 800,
+      "yolov9t": 60,
+      "yolov9s": 120,
+      "yolov9c": 300,
+      "yolo11n": 70,
+      "yolo11s": 130,
+      "yolo11m": 280,
+      "yolo11l": 450,
+      "yolo11x": 750,
+      "yolo11n-seg": 84,
+      "yolo11s-seg": 156,
+      "yolo11m-seg": 336,
+      "yolov8n-seg": 96,
+      "yolov8s-seg": 180,
+      "yolov8m-seg": 360
+    };
+    var ACCURACY_SCORES = {
+      "yolov8n": 55,
+      "yolov8s": 70,
+      "yolov8s-relu": 68,
+      "yolov8m": 82,
+      "yolov8l": 88,
+      "yolov8x": 92,
+      "yolov9t": 58,
+      "yolov9s": 73,
+      "yolov9c": 86,
+      "yolo11n": 62,
+      "yolo11s": 78,
+      "yolo11m": 88,
+      "yolo11l": 93,
+      "yolo11x": 97,
+      "yolo11n-seg": 62,
+      "yolo11s-seg": 78,
+      "yolo11m-seg": 88,
+      "yolov8n-seg": 55,
+      "yolov8s-seg": 70,
+      "yolov8m-seg": 82
+    };
+    var ObjectDetectionAddon = class {
+      id = "object-detection";
+      slot = "detector";
+      inputClasses = null;
+      outputClasses = ["person", "vehicle", "animal"];
+      slotPriority = 0;
+      manifest = {
+        id: "object-detection",
+        name: "Object Detection",
+        version: "0.1.0",
+        description: "YOLO-based object detection \u2014 detects persons, vehicles, and animals",
+        slot: "detector",
+        inputClasses: void 0,
+        outputClasses: ["person", "vehicle", "animal"],
+        supportsCustomModels: true,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "yolo11n",
+          runtime: "node",
+          backend: "cpu",
+          confidence: 0.5,
+          iouThreshold: 0.45,
+          classMapMode: "macro"
+        }
+      };
+      engine = null;
+      modelEntry;
+      confidence = 0.5;
+      iouThreshold = 0.45;
+      classMapMode = "macro";
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return ALL_DETECTION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: RAM_ESTIMATES[m.id] ?? 100,
+          accuracyScore: ACCURACY_SCORES[m.id] ?? 60,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "yolo11n";
+        this.confidence = cfg["confidence"] ?? 0.5;
+        this.iouThreshold = cfg["iouThreshold"] ?? 0.45;
+        this.classMapMode = cfg["classMapMode"] ?? "macro";
+        const entry = ALL_DETECTION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`ObjectDetectionAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async detect(frame) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        if ("runJpeg" in this.engine && typeof this.engine.runJpeg === "function") {
+          const result = await this.engine.runJpeg(frame.data);
+          const rawDets = result.detections ?? [];
+          const detections2 = rawDets.map((d) => ({
+            class: this.classMapMode === "all" ? d.className : types_1.COCO_TO_MACRO.mapping[d.className] ?? d.className,
+            originalClass: d.className,
+            score: d.score,
+            bbox: {
+              x: d.bbox[0] * frame.width,
+              y: d.bbox[1] * frame.height,
+              w: (d.bbox[2] - d.bbox[0]) * frame.width,
+              h: (d.bbox[3] - d.bbox[1]) * frame.height
+            }
+          })).filter((d) => this.classMapMode === "all" || types_1.COCO_TO_MACRO.mapping[d.originalClass] !== void 0);
+          return {
+            detections: detections2,
+            inferenceMs: result.inferenceMs ?? Date.now() - start,
+            modelId: this.modelEntry.id
+          };
+        }
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const targetSize = Math.max(inputW, inputH);
+        const lb = await (0, image_utils_js_1.letterbox)(frame.data, targetSize);
+        const numClasses = this.modelEntry.labels.length;
+        const labels = this.modelEntry.labels.map((l) => l.id);
+        const postprocessOpts = {
+          confidence: this.confidence,
+          iouThreshold: this.iouThreshold,
+          labels,
+          scale: lb.scale,
+          padX: lb.padX,
+          padY: lb.padY,
+          originalWidth: lb.originalWidth,
+          originalHeight: lb.originalHeight
+        };
+        let rawDetections;
+        if (isSegModel(this.modelEntry.id)) {
+          const outputs = await this.engine.runMultiOutput(lb.data, [1, 3, targetSize, targetSize]);
+          const outputNames = Object.keys(outputs);
+          if (outputNames.length < 2) {
+            throw new Error(`ObjectDetectionAddon: seg model "${this.modelEntry.id}" returned ${outputNames.length} output(s); expected 2`);
+          }
+          const detectionOutput = outputs[outputNames[0]];
+          const protoOutput = outputs[outputNames[1]];
+          const numMaskCoeffs = 32;
+          const numBoxes = detectionOutput.length / (4 + numClasses + numMaskCoeffs);
+          const maskHeight = 160;
+          const maskWidth = 160;
+          rawDetections = (0, yolo_seg_js_1.yoloSegPostprocess)({
+            detectionOutput,
+            protoOutput,
+            numClasses,
+            numBoxes,
+            numMaskCoeffs,
+            maskHeight,
+            maskWidth
+          }, postprocessOpts);
+        } else {
+          const output = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+          const numBoxes = output.length / (4 + numClasses);
+          rawDetections = (0, yolo_js_1.yoloPostprocess)(output, numClasses, numBoxes, postprocessOpts);
+        }
+        const detections = this.classMapMode === "all" ? rawDetections : applyClassMap(rawDetections, types_1.COCO_TO_MACRO);
+        return {
+          detections,
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = ALL_DETECTION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        let pythonPath;
+        if (config?.runtime === "python") {
+          for (const cmd of ["python3", "python"]) {
+            try {
+              const { execSync } = await Promise.resolve().then(() => __importStar(__require("child_process")));
+              execSync(`${cmd} --version`, { timeout: 3e3, stdio: "ignore" });
+              pythonPath = cmd;
+              break;
+            } catch {
+            }
+          }
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          pythonPath,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...ALL_DETECTION_MODELS],
+                  allowCustom: true,
+                  allowConversion: true,
+                  acceptFormats: ["onnx", "coreml", "openvino", "tflite"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "yolo"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" },
+                    { value: "tensorrt", label: "TensorRT (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Detection Thresholds",
+              columns: 2,
+              fields: [
+                {
+                  key: "confidence",
+                  label: "Confidence Threshold",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.5
+                },
+                {
+                  key: "iouThreshold",
+                  label: "IoU Threshold (NMS)",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.45
+                }
+              ]
+            },
+            {
+              id: "classmap",
+              title: "Class Mapping",
+              columns: 1,
+              fields: [
+                {
+                  key: "classMapMode",
+                  label: "Output classes",
+                  type: "select",
+                  options: [
+                    { value: "macro", label: "Macro (person / vehicle / animal)" },
+                    { value: "all", label: "All COCO classes (80)" }
+                  ]
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return types_1.COCO_TO_MACRO;
+      }
+      getModelCatalog() {
+        return [...ALL_DETECTION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return this.classMapMode === "all" ? types_1.COCO_80_LABELS : types_1.MACRO_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = ObjectDetectionAddon;
+  }
+});
+
+// src/addons/face-detection/index.js
+var require_face_detection = __commonJS({
+  "src/addons/face-detection/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var face_detection_models_js_1 = require_face_detection_models();
+    var image_utils_js_1 = require_image_utils();
+    var scrfd_js_1 = require_scrfd();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var FACE_LABEL = { id: "face", name: "Face" };
+    var FACE_LABELS = [FACE_LABEL];
+    var FACE_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var RAM_ESTIMATES = {
+      "scrfd-500m": 50,
+      "scrfd-2.5g": 80,
+      "scrfd-10g": 200
+    };
+    var ACCURACY_SCORES = {
+      "scrfd-500m": 70,
+      "scrfd-2.5g": 82,
+      "scrfd-10g": 92
+    };
+    var FaceDetectionAddon = class {
+      id = "face-detection";
+      slot = "cropper";
+      inputClasses = ["person"];
+      outputClasses = ["face"];
+      slotPriority = 0;
+      manifest = {
+        id: "face-detection",
+        name: "Face Detection",
+        version: "0.1.0",
+        description: "SCRFD-based face detector \u2014 crops face regions from person detections",
+        slot: "cropper",
+        inputClasses: ["person"],
+        outputClasses: ["face"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "scrfd-500m",
+          runtime: "node",
+          backend: "cpu",
+          confidence: 0.5
+        }
+      };
+      engine = null;
+      modelEntry;
+      confidence = 0.5;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return face_detection_models_js_1.FACE_DETECTION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: RAM_ESTIMATES[m.id] ?? 50,
+          accuracyScore: ACCURACY_SCORES[m.id] ?? 70,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "scrfd-500m";
+        this.confidence = cfg["confidence"] ?? 0.5;
+        const entry = face_detection_models_js_1.FACE_DETECTION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`FaceDetectionAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async crop(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const targetSize = Math.max(inputW, inputH);
+        const personCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const lb = await (0, image_utils_js_1.letterbox)(personCrop, targetSize);
+        const engineWithMulti = this.engine;
+        let outputs;
+        if (typeof engineWithMulti.runMultiOutput === "function") {
+          outputs = await engineWithMulti.runMultiOutput(lb.data, [1, 3, targetSize, targetSize]);
+        } else {
+          const single = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+          outputs = { output0: single };
+        }
+        const crops = (0, scrfd_js_1.scrfdPostprocess)(outputs, this.confidence, targetSize, lb.originalWidth, lb.originalHeight);
+        return {
+          crops,
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = face_detection_models_js_1.FACE_DETECTION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...face_detection_models_js_1.FACE_DETECTION_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "ssd"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Detection Thresholds",
+              columns: 1,
+              fields: [
+                {
+                  key: "confidence",
+                  label: "Confidence Threshold",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.5
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return FACE_CLASS_MAP;
       }
+      getModelCatalog() {
+        return [...face_detection_models_js_1.FACE_DETECTION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return FACE_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = FaceDetectionAddon;
+  }
+});
+
+// src/addons/face-recognition/index.js
+var require_face_recognition = __commonJS({
+  "src/addons/face-recognition/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var face_recognition_models_js_1 = require_face_recognition_models();
+    var image_utils_js_1 = require_image_utils();
+    var arcface_js_1 = require_arcface();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var IDENTITY_LABEL = { id: "identity", name: "Identity" };
+    var IDENTITY_LABELS = [IDENTITY_LABEL];
+    var FACE_REC_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var REQUIRED_STEPS = [
+      { slot: "cropper", outputClasses: ["face"], description: "Requires a face detector" }
+    ];
+    var FaceRecognitionAddon = class {
+      id = "face-recognition";
+      slot = "classifier";
+      inputClasses = ["face"];
+      outputClasses = ["identity:*"];
+      slotPriority = 0;
+      requiredSteps = REQUIRED_STEPS;
+      manifest = {
+        id: "face-recognition",
+        name: "Face Recognition",
+        version: "0.1.0",
+        description: "ArcFace-based face recognition \u2014 produces 512-d identity embeddings",
+        slot: "classifier",
+        labelOutputType: "face",
+        inputClasses: ["face"],
+        outputClasses: ["identity:*"],
+        requiredSteps: REQUIRED_STEPS,
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "arcface-r100",
+          runtime: "node",
+          backend: "cpu"
+        }
+      };
+      engine = null;
+      modelEntry;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return face_recognition_models_js_1.FACE_RECOGNITION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 400,
+          accuracyScore: 90,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "arcface-r100";
+        const entry = face_recognition_models_js_1.FACE_RECOGNITION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`FaceRecognitionAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const faceCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const layout = this.modelEntry.inputLayout ?? "nhwc";
+        const normalization = this.modelEntry.inputNormalization ?? "zero-one";
+        const normalized = await (0, image_utils_js_1.resizeAndNormalize)(faceCrop, inputW, inputH, normalization, layout);
+        const rawEmbedding = await this.engine.run(normalized, [1, inputH, inputW, 3]);
+        const embedding = (0, arcface_js_1.l2Normalize)(rawEmbedding);
+        return {
+          classifications: [
+            {
+              class: "identity",
+              score: 1,
+              embedding
+            }
+          ],
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = face_recognition_models_js_1.FACE_RECOGNITION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...face_recognition_models_js_1.FACE_RECOGNITION_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "embedding"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return FACE_REC_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...face_recognition_models_js_1.FACE_RECOGNITION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return IDENTITY_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = FaceRecognitionAddon;
+  }
+});
+
+// src/addons/plate-detection/index.js
+var require_plate_detection = __commonJS({
+  "src/addons/plate-detection/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var plate_detection_models_js_1 = require_plate_detection_models();
+    var image_utils_js_1 = require_image_utils();
+    var yolo_js_1 = require_yolo();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var PLATE_LABEL = { id: "plate", name: "License Plate" };
+    var PLATE_LABELS = [PLATE_LABEL];
+    var PLATE_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var PlateDetectionAddon = class {
+      id = "plate-detection";
+      slot = "cropper";
+      inputClasses = ["vehicle"];
+      outputClasses = ["plate"];
+      slotPriority = 0;
+      manifest = {
+        id: "plate-detection",
+        name: "License Plate Detection",
+        version: "0.1.0",
+        description: "YOLO-based license plate detector \u2014 crops plate regions from vehicle detections",
+        slot: "cropper",
+        inputClasses: ["vehicle"],
+        outputClasses: ["plate"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "yolov8n-plate",
+          runtime: "node",
+          backend: "cpu",
+          confidence: 0.5,
+          iouThreshold: 0.45
+        }
+      };
+      engine = null;
+      modelEntry;
+      confidence = 0.5;
+      iouThreshold = 0.45;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return plate_detection_models_js_1.PLATE_DETECTION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 80,
+          accuracyScore: 60,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "yolov8n-plate";
+        this.confidence = cfg["confidence"] ?? 0.5;
+        this.iouThreshold = cfg["iouThreshold"] ?? 0.45;
+        const entry = plate_detection_models_js_1.PLATE_DETECTION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`PlateDetectionAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async crop(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const targetSize = Math.max(inputW, inputH);
+        const vehicleCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const lb = await (0, image_utils_js_1.letterbox)(vehicleCrop, targetSize);
+        const output = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+        const numClasses = this.modelEntry.labels.length;
+        const numBoxes = output.length / (4 + numClasses);
+        const labels = this.modelEntry.labels.map((l) => l.id);
+        const plates = (0, yolo_js_1.yoloPostprocess)(output, numClasses, numBoxes, {
+          confidence: this.confidence,
+          iouThreshold: this.iouThreshold,
+          labels,
+          scale: lb.scale,
+          padX: lb.padX,
+          padY: lb.padY,
+          originalWidth: lb.originalWidth,
+          originalHeight: lb.originalHeight
+        });
+        const crops = plates.map((p) => ({ ...p, class: "plate", originalClass: p.originalClass }));
+        return {
+          crops,
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = plate_detection_models_js_1.PLATE_DETECTION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...plate_detection_models_js_1.PLATE_DETECTION_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "yolo"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Detection Thresholds",
+              columns: 2,
+              fields: [
+                {
+                  key: "confidence",
+                  label: "Confidence Threshold",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.5
+                },
+                {
+                  key: "iouThreshold",
+                  label: "IoU Threshold (NMS)",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.45
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return PLATE_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...plate_detection_models_js_1.PLATE_DETECTION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return PLATE_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = PlateDetectionAddon;
+  }
+});
+
+// src/addons/plate-recognition/index.js
+var require_plate_recognition = __commonJS({
+  "src/addons/plate-recognition/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var plate_recognition_models_js_1 = require_plate_recognition_models();
+    var image_utils_js_1 = require_image_utils();
+    var paddleocr_js_1 = require_paddleocr();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var PLATE_TEXT_LABEL = { id: "plate-text", name: "Plate Text" };
+    var PLATE_TEXT_LABELS = [PLATE_TEXT_LABEL];
+    var PLATE_REC_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var fs = __importStar(__require("fs"));
+    var path = __importStar(__require("path"));
+    function loadCharset(modelsDir, modelId) {
+      const dictNames = [
+        `camstack-${modelId}-dict.txt`,
+        `camstack-paddleocr-latin-dict.txt`,
+        `camstack-paddleocr-en-dict.txt`,
+        `camstack-crnn-mobilenet-charset.txt`
+      ];
+      for (const name of dictNames) {
+        const dictPath = path.join(modelsDir, name);
+        if (fs.existsSync(dictPath)) {
+          const lines = fs.readFileSync(dictPath, "utf-8").split("\n").filter((l) => l.length > 0);
+          return ["", ...lines, " "];
+        }
+      }
+      throw new Error(`PlateRecognitionAddon: dict.txt not found in ${modelsDir}`);
     }
-  },
-  // ── PaddleOCR PP-OCRv5 Mobile — general-purpose text detection + recognition ──
-  {
-    id: "ppocr-v5-det-mobile",
-    name: "PP-OCRv5 Detection Mobile",
-    description: "PP-OCRv5 mobile text detection \u2014 optimized for edge, 100+ languages",
-    inputSize: { width: 640, height: 640 },
-    labels: OCR_TEXT_LABELS,
-    formats: {
-      onnx: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/onnx/camstack-ppocr-v5-det-mobile.onnx"),
-        sizeMB: 6
-      },
-      coreml: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/coreml/camstack-ppocr-v5-det-mobile.mlpackage"),
-        sizeMB: 3,
-        isDirectory: true,
-        files: [
-          "Manifest.json",
-          "Data/com.apple.CoreML/model.mlmodel",
-          "Data/com.apple.CoreML/weights/weight.bin"
-        ],
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/openvino/camstack-ppocr-v5-det-mobile.xml"),
-        sizeMB: 3,
-        runtimes: ["python"]
+    var REQUIRED_STEPS = [
+      { slot: "cropper", outputClasses: ["plate"], description: "Requires a plate detector" }
+    ];
+    var PlateRecognitionAddon = class {
+      id = "plate-recognition";
+      slot = "classifier";
+      inputClasses = ["plate"];
+      outputClasses = ["plate-text:*"];
+      slotPriority = 0;
+      requiredSteps = REQUIRED_STEPS;
+      manifest = {
+        id: "plate-recognition",
+        name: "License Plate Recognition (OCR)",
+        version: "0.1.0",
+        description: "PaddleOCR-based license plate text recognition",
+        slot: "classifier",
+        labelOutputType: "plate",
+        inputClasses: ["plate"],
+        outputClasses: ["plate-text:*"],
+        requiredSteps: REQUIRED_STEPS,
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "paddleocr-latin",
+          runtime: "node",
+          backend: "cpu",
+          minConfidence: 0.5
+        }
+      };
+      engine = null;
+      modelEntry;
+      minConfidence = 0.5;
+      charset = [];
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        const scores = {
+          "paddleocr-latin": { ram: 100, accuracy: 80 },
+          "paddleocr-en": { ram: 100, accuracy: 80 }
+        };
+        return plate_recognition_models_js_1.PLATE_RECOGNITION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: scores[m.id]?.ram ?? 100,
+          accuracyScore: scores[m.id]?.accuracy ?? 75,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
       }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "paddleocr-latin";
+        this.minConfidence = cfg["minConfidence"] ?? 0.5;
+        const entry = plate_recognition_models_js_1.PLATE_RECOGNITION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`PlateRecognitionAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        console.log(`[plate-recognition] ROI: x=${input.roi?.x}, y=${input.roi?.y}, w=${input.roi?.w}, h=${input.roi?.h}, frameSize=${input.frame?.data?.length}`);
+        const plateCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        console.log(`[plate-recognition] Crop size: ${plateCrop.length} bytes`);
+        try {
+          __require("fs").writeFileSync("/tmp/plate-recognition-crop.jpg", plateCrop);
+        } catch {
+        }
+        const normalized = await (0, image_utils_js_1.resizeAndNormalize)(plateCrop, inputW, inputH, "zero-one", "nchw");
+        const output = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+        const numChars = this.charset.length;
+        const seqLen = output.length / numChars;
+        const { text, confidence } = (0, paddleocr_js_1.ctcDecode)(output, seqLen, numChars, this.charset);
+        return {
+          classifications: [
+            {
+              class: "plate-text",
+              score: confidence,
+              text: text.trim() || "(unreadable)"
+            }
+          ],
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = plate_recognition_models_js_1.PLATE_RECOGNITION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        this.charset = loadCharset(modelsDir, modelId);
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...plate_recognition_models_js_1.PLATE_RECOGNITION_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "openvino"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "ocr"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Recognition Settings",
+              columns: 1,
+              fields: [
+                {
+                  key: "minConfidence",
+                  label: "Minimum Confidence",
+                  type: "slider",
+                  min: 0.1,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.5
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return PLATE_REC_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...plate_recognition_models_js_1.PLATE_RECOGNITION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return PLATE_TEXT_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = PlateRecognitionAddon;
+  }
+});
+
+// src/addons/audio-classification/index.js
+var require_audio_classification = __commonJS({
+  "src/addons/audio-classification/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var audio_classification_models_js_1 = require_audio_classification_models();
+    var yamnet_js_1 = require_yamnet();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var YAMNET_NUM_CLASSES = 521;
+    var AUDIO_EVENT_LABEL = { id: "audio-event", name: "Audio Event" };
+    var AUDIO_LABELS = [AUDIO_EVENT_LABEL];
+    var AUDIO_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var AudioClassificationAddon = class {
+      id = "audio-classification";
+      slot = "classifier";
+      inputClasses = null;
+      outputClasses = ["audio-event:*"];
+      slotPriority = 0;
+      manifest = {
+        id: "audio-classification",
+        name: "Audio Classification",
+        version: "0.1.0",
+        description: "YAMNet-based audio event classification from audio waveform",
+        slot: "classifier",
+        labelOutputType: "classification",
+        inputClasses: void 0,
+        outputClasses: ["audio-event:*"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "yamnet",
+          runtime: "node",
+          backend: "cpu",
+          minScore: 0.3
+        }
+      };
+      engine = null;
+      modelEntry;
+      minScore = 0.3;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return audio_classification_models_js_1.AUDIO_CLASSIFICATION_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 100,
+          accuracyScore: 80,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "yamnet";
+        this.minScore = cfg["minScore"] ?? 0.3;
+        const entry = audio_classification_models_js_1.AUDIO_CLASSIFICATION_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`AudioClassificationAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      /**
+       * classify() receives a CropInput but internally treats input.frame.data as raw audio context.
+       * For audio, the actual audio chunk data should be stored in frame.data as a Float32Array
+       * serialized into a Buffer (little-endian float32 samples at 16 kHz).
+       *
+       * The CropInput.roi is not used for audio — it is ignored.
+       */
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const buf = input.frame.data;
+        const numSamples = Math.floor(buf.length / 4);
+        const audioData = new Float32Array(numSamples);
+        for (let i = 0; i < numSamples; i++) {
+          audioData[i] = buf.readFloatLE(i * 4);
+        }
+        const output = await this.engine.run(audioData, [numSamples]);
+        const numFrames = output.length / YAMNET_NUM_CLASSES;
+        const classNames = this.modelEntry.labels.map((l) => l.id);
+        while (classNames.length < YAMNET_NUM_CLASSES) {
+          classNames.push(`class_${classNames.length}`);
+        }
+        const results = (0, yamnet_js_1.yamnetPostprocess)(output, Math.round(numFrames), YAMNET_NUM_CLASSES, classNames, this.minScore);
+        const classifications = results.map((r) => ({
+          class: `audio-event:${r.className}`,
+          score: r.score
+        }));
+        return {
+          classifications,
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = audio_classification_models_js_1.AUDIO_CLASSIFICATION_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...audio_classification_models_js_1.AUDIO_CLASSIFICATION_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "openvino"],
+                  requiredMetadata: ["inputSize", "labels", "outputFormat"],
+                  outputFormatHint: "classification"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Classification Settings",
+              columns: 1,
+              fields: [
+                {
+                  key: "minScore",
+                  label: "Minimum Score",
+                  type: "slider",
+                  min: 0.05,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.3
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return AUDIO_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...audio_classification_models_js_1.AUDIO_CLASSIFICATION_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return AUDIO_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = AudioClassificationAddon;
+  }
+});
+
+// src/addons/bird-global-classifier/index.js
+var require_bird_global_classifier = __commonJS({
+  "src/addons/bird-global-classifier/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var animal_classification_models_js_1 = require_animal_classification_models();
+    var image_utils_js_1 = require_image_utils();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var fs = __importStar(__require("fs"));
+    var path = __importStar(__require("path"));
+    var SPECIES_LABEL = { id: "species", name: "Bird Species" };
+    var SPECIES_LABELS = [SPECIES_LABEL];
+    var BIRD_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    function loadLabels(modelsDir, modelId) {
+      const labelNames = [
+        `camstack-${modelId}-labels.json`,
+        `camstack-bird-species-525-labels.json`
+      ];
+      for (const name of labelNames) {
+        const labelPath = path.join(modelsDir, name);
+        if (fs.existsSync(labelPath)) {
+          const raw = fs.readFileSync(labelPath, "utf-8");
+          return JSON.parse(raw);
+        }
+      }
+      throw new Error(`BirdGlobalClassifierAddon: labels JSON not found in ${modelsDir}`);
     }
-  },
-  {
-    id: "ppocr-v5-rec-mobile",
-    name: "PP-OCRv5 Recognition Mobile",
-    description: "PP-OCRv5 mobile text recognition \u2014 100+ languages, CTC decoding",
-    inputSize: { width: 320, height: 48 },
-    labels: OCR_TEXT_LABELS,
-    formats: {
-      onnx: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/onnx/camstack-ppocr-v5-rec-mobile.onnx"),
-        sizeMB: 8
-      },
-      coreml: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/coreml/camstack-ppocr-v5-rec-mobile.mlpackage"),
-        sizeMB: 4,
-        isDirectory: true,
-        files: [
-          "Manifest.json",
-          "Data/com.apple.CoreML/model.mlmodel",
-          "Data/com.apple.CoreML/weights/weight.bin"
-        ],
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/openvino/camstack-ppocr-v5-rec-mobile.xml"),
-        sizeMB: 4,
-        runtimes: ["python"]
+    function softmax(logits) {
+      const max = logits.reduce((a, b) => Math.max(a, b), -Infinity);
+      const exps = logits.map((v) => Math.exp(v - max));
+      const sum = exps.reduce((a, b) => a + b, 0);
+      return exps.map((v) => v / sum);
+    }
+    var BirdGlobalClassifierAddon = class {
+      id = "bird-global-classifier";
+      slot = "classifier";
+      inputClasses = ["animal"];
+      outputClasses = ["species:*"];
+      slotPriority = 0;
+      requiredSteps = [];
+      manifest = {
+        id: "bird-global-classifier",
+        name: "Bird Classifier (Global, 525 species)",
+        version: "0.1.0",
+        description: "EfficientNet \u2014 525 worldwide bird species (MIT license, ONNX only)",
+        slot: "classifier",
+        labelOutputType: "classification",
+        inputClasses: ["animal"],
+        outputClasses: ["species:*"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "bird-species-525",
+          runtime: "node",
+          backend: "cpu",
+          minConfidence: 0.3
+        }
+      };
+      engine = null;
+      modelEntry;
+      labels = [];
+      minConfidence = 0.3;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return animal_classification_models_js_1.BIRD_SPECIES_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 120,
+          accuracyScore: 80,
+          formats: Object.keys(m.formats)
+        }));
       }
-    },
-    extraFiles: [
-      {
-        url: hfModelUrl(HF_REPO, "generalOcr/ppocr-v5/camstack-ppocr-v5-keys.txt"),
-        filename: "camstack-ppocr-v5-keys.txt",
-        sizeMB: 0.1
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "bird-species-525";
+        this.minConfidence = cfg["minConfidence"] ?? 0.3;
+        const entry = animal_classification_models_js_1.BIRD_SPECIES_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`BirdGlobalClassifierAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const animalCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const normalized = await (0, image_utils_js_1.resizeAndNormalize)(animalCrop, inputW, inputH, "imagenet", "nchw");
+        const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+        const probs = softmax(rawOutput);
+        let maxIdx = 0;
+        let maxScore = probs[0] ?? 0;
+        for (let i = 1; i < probs.length; i++) {
+          const score = probs[i] ?? 0;
+          if (score > maxScore) {
+            maxScore = score;
+            maxIdx = i;
+          }
+        }
+        if (maxScore < this.minConfidence) {
+          return {
+            classifications: [],
+            inferenceMs: Date.now() - start,
+            modelId: this.modelEntry.id
+          };
+        }
+        const label = this.labels[maxIdx] ?? `species_${maxIdx}`;
+        return {
+          classifications: [
+            {
+              class: label,
+              score: maxScore
+            }
+          ],
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = animal_classification_models_js_1.BIRD_SPECIES_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        this.labels = loadLabels(modelsDir, modelId);
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...animal_classification_models_js_1.BIRD_SPECIES_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels"],
+                  outputFormatHint: "classification"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Classification Settings",
+              columns: 1,
+              fields: [
+                {
+                  key: "minConfidence",
+                  label: "Minimum Confidence",
+                  type: "slider",
+                  min: 0.05,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.3
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return BIRD_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...animal_classification_models_js_1.BIRD_SPECIES_MODELS];
       }
-    ]
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return SPECIES_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = BirdGlobalClassifierAddon;
+  }
+});
+
+// src/addons/bird-nabirds-classifier/index.js
+var require_bird_nabirds_classifier = __commonJS({
+  "src/addons/bird-nabirds-classifier/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var animal_classification_models_js_1 = require_animal_classification_models();
+    var image_utils_js_1 = require_image_utils();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var fs = __importStar(__require("fs"));
+    var path = __importStar(__require("path"));
+    var SPECIES_LABEL = { id: "species", name: "Bird Species" };
+    var SPECIES_LABELS = [SPECIES_LABEL];
+    var BIRD_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    function loadLabels(modelsDir, modelId) {
+      const labelNames = [
+        `camstack-${modelId}-labels.json`,
+        `camstack-bird-nabirds-404-labels.json`
+      ];
+      for (const name of labelNames) {
+        const labelPath = path.join(modelsDir, name);
+        if (fs.existsSync(labelPath)) {
+          const raw = fs.readFileSync(labelPath, "utf-8");
+          return JSON.parse(raw);
+        }
+      }
+      throw new Error(`BirdNABirdsClassifierAddon: labels JSON not found in ${modelsDir}`);
+    }
+    function softmax(logits) {
+      const max = logits.reduce((a, b) => Math.max(a, b), -Infinity);
+      const exps = logits.map((v) => Math.exp(v - max));
+      const sum = exps.reduce((a, b) => a + b, 0);
+      return exps.map((v) => v / sum);
+    }
+    var BirdNABirdsClassifierAddon = class {
+      id = "bird-nabirds-classifier";
+      slot = "classifier";
+      inputClasses = ["animal"];
+      outputClasses = ["species:*"];
+      slotPriority = 0;
+      requiredSteps = [];
+      manifest = {
+        id: "bird-nabirds-classifier",
+        name: "Bird Classifier (NABirds, 404 species)",
+        version: "0.1.0",
+        description: "ResNet50 \u2014 404 North American bird species (NABirds dataset, ONNX + CoreML + OpenVINO)",
+        slot: "classifier",
+        labelOutputType: "classification",
+        inputClasses: ["animal"],
+        outputClasses: ["species:*"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "bird-nabirds-404",
+          runtime: "node",
+          backend: "cpu",
+          minConfidence: 0.3
+        }
+      };
+      engine = null;
+      modelEntry;
+      labels = [];
+      minConfidence = 0.3;
+      allowedSpecies;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return animal_classification_models_js_1.BIRD_NABIRDS_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 300,
+          accuracyScore: 80,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "bird-nabirds-404";
+        this.minConfidence = cfg["minConfidence"] ?? 0.3;
+        this.allowedSpecies = cfg["allowedSpecies"];
+        const entry = animal_classification_models_js_1.BIRD_NABIRDS_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`BirdNABirdsClassifierAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      applyRegionFilter(scores, labels) {
+        if (!this.allowedSpecies || this.allowedSpecies.length === 0)
+          return;
+        const allowedSet = new Set(this.allowedSpecies.map((s) => s.toLowerCase()));
+        for (let i = 0; i < scores.length; i++) {
+          if (!allowedSet.has(labels[i].toLowerCase())) {
+            scores[i] = 0;
+          }
+        }
+      }
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const animalCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const normalized = await (0, image_utils_js_1.resizeAndNormalize)(animalCrop, inputW, inputH, "imagenet", "nchw");
+        const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+        const probs = softmax(rawOutput);
+        this.applyRegionFilter(probs, this.labels);
+        const filteredSum = probs.reduce((a, b) => a + b, 0);
+        if (filteredSum > 0) {
+          for (let i = 0; i < probs.length; i++) {
+            probs[i] = (probs[i] ?? 0) / filteredSum;
+          }
+        }
+        let maxIdx = 0;
+        let maxScore = probs[0] ?? 0;
+        for (let i = 1; i < probs.length; i++) {
+          const score = probs[i] ?? 0;
+          if (score > maxScore) {
+            maxScore = score;
+            maxIdx = i;
+          }
+        }
+        if (maxScore < this.minConfidence) {
+          return {
+            classifications: [],
+            inferenceMs: Date.now() - start,
+            modelId: this.modelEntry.id
+          };
+        }
+        const label = this.labels[maxIdx] ?? `species_${maxIdx}`;
+        return {
+          classifications: [
+            {
+              class: label,
+              score: maxScore
+            }
+          ],
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = animal_classification_models_js_1.BIRD_NABIRDS_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        this.labels = loadLabels(modelsDir, modelId);
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...animal_classification_models_js_1.BIRD_NABIRDS_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels"],
+                  outputFormatHint: "classification"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Classification Settings",
+              columns: 1,
+              fields: [
+                {
+                  key: "minConfidence",
+                  label: "Minimum Confidence",
+                  type: "slider",
+                  min: 0.05,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.3
+                }
+              ]
+            },
+            {
+              id: "region",
+              title: "Regional Filter",
+              columns: 1,
+              fields: [
+                {
+                  key: "regionFilter",
+                  label: "Region Preset",
+                  type: "select",
+                  options: [
+                    { value: "", label: "None (all 404 species)" },
+                    { value: "north-america-east", label: "North America \u2014 Eastern" },
+                    { value: "north-america-west", label: "North America \u2014 Western" },
+                    { value: "north-america-south", label: "North America \u2014 Southern" }
+                  ]
+                },
+                {
+                  key: "allowedSpecies",
+                  label: "Custom Allowed Species (comma-separated)",
+                  type: "text"
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return BIRD_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...animal_classification_models_js_1.BIRD_NABIRDS_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return SPECIES_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = BirdNABirdsClassifierAddon;
   }
-];
+});
+
+// src/addons/animal-classifier/index.js
+var require_animal_classifier = __commonJS({
+  "src/addons/animal-classifier/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var animal_classification_models_js_1 = require_animal_classification_models();
+    var image_utils_js_1 = require_image_utils();
+    var engine_resolver_js_1 = require_engine_resolver();
+    var ANIMAL_TYPE_LABEL = { id: "animal-type", name: "Animal Type" };
+    var ANIMAL_TYPE_LABELS = [ANIMAL_TYPE_LABEL];
+    var ANIMAL_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+    var ANIMAL_10_CLASSES = [
+      "cat",
+      "cow",
+      "dog",
+      "dolphin",
+      "eagle",
+      "giant panda",
+      "horse",
+      "monkey",
+      "sheep",
+      "spider"
+    ];
+    function softmax(logits) {
+      const max = logits.reduce((a, b) => Math.max(a, b), -Infinity);
+      const exps = logits.map((v) => Math.exp(v - max));
+      const sum = exps.reduce((a, b) => a + b, 0);
+      return exps.map((v) => v / sum);
+    }
+    var AnimalClassifierAddon = class {
+      id = "animal-classifier";
+      slot = "classifier";
+      inputClasses = ["animal"];
+      outputClasses = ["animal-type:*"];
+      slotPriority = 0;
+      requiredSteps = [];
+      manifest = {
+        id: "animal-classifier",
+        name: "Animal Classifier",
+        version: "0.1.0",
+        description: "ViT-based animal type classifier \u2014 10 common species",
+        slot: "classifier",
+        labelOutputType: "classification",
+        inputClasses: ["animal"],
+        outputClasses: ["animal-type:*"],
+        supportsCustomModels: false,
+        mayRequirePython: false,
+        defaultConfig: {
+          modelId: "animals-10",
+          runtime: "node",
+          backend: "cpu",
+          minConfidence: 0.3
+        }
+      };
+      engine = null;
+      modelEntry;
+      minConfidence = 0.3;
+      resolvedConfig = null;
+      ctx = null;
+      getModelRequirements() {
+        return animal_classification_models_js_1.ANIMAL_TYPE_MODELS.map((m) => ({
+          modelId: m.id,
+          name: m.name,
+          minRAM_MB: 800,
+          accuracyScore: 75,
+          formats: Object.keys(m.formats)
+        }));
+      }
+      configure(config) {
+        this.resolvedConfig = config;
+      }
+      async initialize(ctx) {
+        this.ctx = ctx;
+        const cfg = ctx.addonConfig;
+        const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "animals-10";
+        this.minConfidence = cfg["minConfidence"] ?? 0.3;
+        const entry = animal_classification_models_js_1.ANIMAL_TYPE_MODELS.find((m) => m.id === modelId);
+        if (!entry) {
+          throw new Error(`AnimalClassifierAddon: unknown modelId "${modelId}"`);
+        }
+        this.modelEntry = entry;
+      }
+      async classify(input) {
+        if (!this.engine)
+          await this.ensureEngine();
+        const start = Date.now();
+        const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+        const animalCrop = await (0, image_utils_js_1.cropRegion)(input.frame.data, input.roi);
+        const normalized = await (0, image_utils_js_1.resizeAndNormalize)(animalCrop, inputW, inputH, "imagenet", "nchw");
+        const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+        const probs = softmax(rawOutput);
+        let maxIdx = 0;
+        let maxScore = probs[0] ?? 0;
+        for (let i = 1; i < probs.length; i++) {
+          const score = probs[i] ?? 0;
+          if (score > maxScore) {
+            maxScore = score;
+            maxIdx = i;
+          }
+        }
+        if (maxScore < this.minConfidence) {
+          return {
+            classifications: [],
+            inferenceMs: Date.now() - start,
+            modelId: this.modelEntry.id
+          };
+        }
+        const label = ANIMAL_10_CLASSES[maxIdx] ?? `animal_${maxIdx}`;
+        return {
+          classifications: [
+            {
+              class: label,
+              score: maxScore
+            }
+          ],
+          inferenceMs: Date.now() - start,
+          modelId: this.modelEntry.id
+        };
+      }
+      async ensureEngine() {
+        const config = this.resolvedConfig;
+        const modelId = config?.modelId ?? this.modelEntry.id;
+        const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+        const backend = config?.backend ?? "cpu";
+        const format = config?.format ?? "onnx";
+        const entry = animal_classification_models_js_1.ANIMAL_TYPE_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+        this.modelEntry = entry;
+        const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+        if (this.ctx.models) {
+          await this.ctx.models.ensure(modelId, format);
+        }
+        const resolved = await (0, engine_resolver_js_1.resolveEngine)({
+          runtime,
+          backend,
+          modelEntry: entry,
+          modelsDir,
+          models: this.ctx.models
+        });
+        this.engine = resolved.engine;
+      }
+      async shutdown() {
+        await this.engine?.dispose();
+      }
+      getConfigSchema() {
+        return {
+          sections: [
+            {
+              id: "model",
+              title: "Model",
+              columns: 1,
+              fields: [
+                {
+                  key: "modelId",
+                  label: "Model",
+                  type: "model-selector",
+                  catalog: [...animal_classification_models_js_1.ANIMAL_TYPE_MODELS],
+                  allowCustom: false,
+                  allowConversion: false,
+                  acceptFormats: ["onnx", "coreml", "openvino"],
+                  requiredMetadata: ["inputSize", "labels"],
+                  outputFormatHint: "classification"
+                }
+              ]
+            },
+            {
+              id: "runtime",
+              title: "Runtime",
+              columns: 2,
+              fields: [
+                {
+                  key: "runtime",
+                  label: "Runtime",
+                  type: "select",
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "onnx", label: "ONNX Runtime" },
+                    { value: "coreml", label: "CoreML (Apple)" },
+                    { value: "openvino", label: "OpenVINO (Intel)" }
+                  ]
+                },
+                {
+                  key: "backend",
+                  label: "Backend",
+                  type: "select",
+                  showWhen: { field: "runtime", equals: "onnx" },
+                  options: [
+                    { value: "auto", label: "Auto" },
+                    { value: "cpu", label: "CPU" },
+                    { value: "coreml", label: "CoreML" },
+                    { value: "cuda", label: "CUDA (NVIDIA)" }
+                  ]
+                }
+              ]
+            },
+            {
+              id: "thresholds",
+              title: "Classification Settings",
+              columns: 1,
+              fields: [
+                {
+                  key: "minConfidence",
+                  label: "Minimum Confidence",
+                  type: "slider",
+                  min: 0.05,
+                  max: 1,
+                  step: 0.05,
+                  default: 0.3
+                }
+              ]
+            }
+          ]
+        };
+      }
+      getClassMap() {
+        return ANIMAL_CLASS_MAP;
+      }
+      getModelCatalog() {
+        return [...animal_classification_models_js_1.ANIMAL_TYPE_MODELS];
+      }
+      getAvailableModels() {
+        return [];
+      }
+      getActiveLabels() {
+        return ANIMAL_TYPE_LABELS;
+      }
+      async probe() {
+        return {
+          available: true,
+          runtime: this.engine?.runtime ?? "onnx",
+          device: this.engine?.device ?? "cpu",
+          capabilities: ["fp32"]
+        };
+      }
+    };
+    exports.default = AnimalClassifierAddon;
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnimalClassifierAddon: () => import_animal_classifier.default,
+  AudioClassificationAddon: () => import_audio_classification.default,
+  BirdGlobalClassifierAddon: () => import_bird_global_classifier.default,
+  BirdNABirdsClassifierAddon: () => import_bird_nabirds_classifier.default,
+  FaceDetectionAddon: () => import_face_detection.default,
+  FaceRecognitionAddon: () => import_face_recognition.default,
+  NodeInferenceEngine: () => import_node_engine.NodeInferenceEngine,
+  ObjectDetectionAddon: () => import_object_detection.default,
+  PlateDetectionAddon: () => import_plate_detection.default,
+  PlateRecognitionAddon: () => import_plate_recognition.default,
+  PythonInferenceEngine: () => import_python_engine.PythonInferenceEngine,
+  cosineSimilarity: () => import_arcface.cosineSimilarity,
+  cropRegion: () => import_image_utils.cropRegion,
+  ctcDecode: () => import_paddleocr.ctcDecode,
+  detectMotion: () => import_frame_diff.detectMotion,
+  iou: () => import_yolo.iou,
+  jpegToRgb: () => import_image_utils.jpegToRgb,
+  l2Normalize: () => import_arcface.l2Normalize,
+  letterbox: () => import_image_utils.letterbox,
+  nms: () => import_yolo.nms,
+  probeOnnxBackends: () => import_engine_resolver.probeOnnxBackends,
+  resizeAndNormalize: () => import_image_utils.resizeAndNormalize,
+  resolveEngine: () => import_engine_resolver.resolveEngine,
+  rgbToGrayscale: () => import_image_utils.rgbToGrayscale,
+  scrfdPostprocess: () => import_scrfd.scrfdPostprocess,
+  yamnetPostprocess: () => import_yamnet.yamnetPostprocess,
+  yoloPostprocess: () => import_yolo.yoloPostprocess
+});
+var import_image_utils = __toESM(require_image_utils());
+var import_yolo = __toESM(require_yolo());
+var import_scrfd = __toESM(require_scrfd());
+var import_arcface = __toESM(require_arcface());
+var import_paddleocr = __toESM(require_paddleocr());
+var import_yamnet = __toESM(require_yamnet());
+var import_node_engine = __toESM(require_node_engine());
+var import_python_engine = __toESM(require_python_engine());
+var import_engine_resolver = __toESM(require_engine_resolver());
+var import_frame_diff = __toESM(require_frame_diff());
+__reExport(src_exports, __toESM(require_catalogs()));
+var import_object_detection = __toESM(require_object_detection());
+var import_face_detection = __toESM(require_face_detection());
+var import_face_recognition = __toESM(require_face_recognition());
+var import_plate_detection = __toESM(require_plate_detection());
+var import_plate_recognition = __toESM(require_plate_recognition());
+var import_audio_classification = __toESM(require_audio_classification());
+var import_bird_global_classifier = __toESM(require_bird_global_classifier());
+var import_bird_nabirds_classifier = __toESM(require_bird_nabirds_classifier());
+var import_animal_classifier = __toESM(require_animal_classifier());
+var export_AnimalClassifierAddon = import_animal_classifier.default;
+var export_AudioClassificationAddon = import_audio_classification.default;
+var export_BirdGlobalClassifierAddon = import_bird_global_classifier.default;
+var export_BirdNABirdsClassifierAddon = import_bird_nabirds_classifier.default;
+var export_FaceDetectionAddon = import_face_detection.default;
+var export_FaceRecognitionAddon = import_face_recognition.default;
+var export_NodeInferenceEngine = import_node_engine.NodeInferenceEngine;
+var export_ObjectDetectionAddon = import_object_detection.default;
+var export_PlateDetectionAddon = import_plate_detection.default;
+var export_PlateRecognitionAddon = import_plate_recognition.default;
+var export_PythonInferenceEngine = import_python_engine.PythonInferenceEngine;
+var export_cosineSimilarity = import_arcface.cosineSimilarity;
+var export_cropRegion = import_image_utils.cropRegion;
+var export_ctcDecode = import_paddleocr.ctcDecode;
+var export_detectMotion = import_frame_diff.detectMotion;
+var export_iou = import_yolo.iou;
+var export_jpegToRgb = import_image_utils.jpegToRgb;
+var export_l2Normalize = import_arcface.l2Normalize;
+var export_letterbox = import_image_utils.letterbox;
+var export_nms = import_yolo.nms;
+var export_probeOnnxBackends = import_engine_resolver.probeOnnxBackends;
+var export_resizeAndNormalize = import_image_utils.resizeAndNormalize;
+var export_resolveEngine = import_engine_resolver.resolveEngine;
+var export_rgbToGrayscale = import_image_utils.rgbToGrayscale;
+var export_scrfdPostprocess = import_scrfd.scrfdPostprocess;
+var export_yamnetPostprocess = import_yamnet.yamnetPostprocess;
+var export_yoloPostprocess = import_yolo.yoloPostprocess;
 export {
-  ANIMAL_TYPE_MODELS,
-  AUDIO_CLASSIFICATION_MODELS,
-  AnimalClassifierAddon,
-  AudioClassificationAddon,
-  BIRD_NABIRDS_MODELS,
-  BIRD_SPECIES_MODELS,
-  BirdGlobalClassifierAddon,
-  BirdNABirdsClassifierAddon,
-  FACE_DETECTION_MODELS,
-  FACE_RECOGNITION_MODELS,
-  FaceDetectionAddon,
-  FaceRecognitionAddon,
-  GENERAL_OCR_MODELS,
-  MLPACKAGE_FILES,
-  NodeInferenceEngine,
-  OBJECT_DETECTION_MODELS,
-  ObjectDetectionAddon,
-  PLATE_DETECTION_MODELS,
-  PLATE_RECOGNITION_MODELS,
-  PlateDetectionAddon,
-  PlateRecognitionAddon,
-  PythonInferenceEngine,
-  SEGMENTATION_MODELS,
-  SEGMENTATION_REFINER_MODELS,
-  VEHICLE_TYPE_MODELS,
-  cosineSimilarity,
-  cropRegion,
-  ctcDecode,
-  detectMotion,
-  iou,
-  jpegToRgb,
-  l2Normalize,
-  letterbox,
-  nms,
-  probeOnnxBackends,
-  resizeAndNormalize,
-  resolveEngine,
-  rgbToGrayscale,
-  scrfdPostprocess,
-  yamnetPostprocess,
-  yoloPostprocess
+  export_AnimalClassifierAddon as AnimalClassifierAddon,
+  export_AudioClassificationAddon as AudioClassificationAddon,
+  export_BirdGlobalClassifierAddon as BirdGlobalClassifierAddon,
+  export_BirdNABirdsClassifierAddon as BirdNABirdsClassifierAddon,
+  export_FaceDetectionAddon as FaceDetectionAddon,
+  export_FaceRecognitionAddon as FaceRecognitionAddon,
+  export_NodeInferenceEngine as NodeInferenceEngine,
+  export_ObjectDetectionAddon as ObjectDetectionAddon,
+  export_PlateDetectionAddon as PlateDetectionAddon,
+  export_PlateRecognitionAddon as PlateRecognitionAddon,
+  export_PythonInferenceEngine as PythonInferenceEngine,
+  export_cosineSimilarity as cosineSimilarity,
+  export_cropRegion as cropRegion,
+  export_ctcDecode as ctcDecode,
+  export_detectMotion as detectMotion,
+  export_iou as iou,
+  export_jpegToRgb as jpegToRgb,
+  export_l2Normalize as l2Normalize,
+  export_letterbox as letterbox,
+  export_nms as nms,
+  export_probeOnnxBackends as probeOnnxBackends,
+  export_resizeAndNormalize as resizeAndNormalize,
+  export_resolveEngine as resolveEngine,
+  export_rgbToGrayscale as rgbToGrayscale,
+  export_scrfdPostprocess as scrfdPostprocess,
+  export_yamnetPostprocess as yamnetPostprocess,
+  export_yoloPostprocess as yoloPostprocess
 };
 //# sourceMappingURL=index.mjs.map