@camstack/addon-vision 0.1.0 → 0.1.1

package/dist/addons/animal-classifier/index.js

@@ -35,9 +35,418 @@ __export(animal_classifier_exports, {
 module.exports = __toCommonJS(animal_classifier_exports);
 
 // src/catalogs/animal-classification-models.ts
+var import_types2 = require("@camstack/types");
+
+// src/catalogs/object-detection-models.ts
 var import_types = require("@camstack/types");
 var HF_REPO = "camstack/camstack-models";
-var hf = (path3) => (0, import_types.hfModelUrl)(HF_REPO, path3);
+var MLPACKAGE_FILES = [
+  "Manifest.json",
+  "Data/com.apple.CoreML/model.mlmodel",
+  "Data/com.apple.CoreML/weights/weight.bin"
+];
+var OBJECT_DETECTION_MODELS = [
+  // ── YOLOv8 ──────────────────────────────────────────────────────
+  {
+    id: "yolov8n",
+    name: "YOLOv8 Nano",
+    description: "YOLOv8 Nano \u2014 fastest, smallest object detection model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8n.onnx"),
+        sizeMB: 12
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8n.mlpackage"),
+        sizeMB: 6,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8n.xml"),
+        sizeMB: 7,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8n_float32.tflite"),
+        sizeMB: 12,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8s",
+    name: "YOLOv8 Small",
+    description: "YOLOv8 Small \u2014 balanced speed and accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s.onnx"),
+        sizeMB: 43
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8s.mlpackage"),
+        sizeMB: 21,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8s.xml"),
+        sizeMB: 22,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8s_float32.tflite"),
+        sizeMB: 43,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8s-relu",
+    name: "YOLOv8 Small ReLU",
+    description: "YOLOv8 Small with ReLU activation \u2014 better hardware compatibility",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s-relu.onnx"),
+        sizeMB: 43
+      }
+    }
+  },
+  {
+    id: "yolov8m",
+    name: "YOLOv8 Medium",
+    description: "YOLOv8 Medium \u2014 higher accuracy, moderate size",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8m.onnx"),
+        sizeMB: 99
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8m.mlpackage"),
+        sizeMB: 49,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8m.xml"),
+        sizeMB: 50,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8m_float32.tflite"),
+        sizeMB: 99,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8l",
+    name: "YOLOv8 Large",
+    description: "YOLOv8 Large \u2014 high-accuracy large model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8l.onnx"),
+        sizeMB: 167
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8l.mlpackage"),
+        sizeMB: 83,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8l.xml"),
+        sizeMB: 84,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8x",
+    name: "YOLOv8 Extra-Large",
+    description: "YOLOv8 Extra-Large \u2014 maximum accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8x.onnx"),
+        sizeMB: 260
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8x.mlpackage"),
+        sizeMB: 130,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8x.xml"),
+        sizeMB: 131,
+        runtimes: ["python"]
+      }
+    }
+  },
+  // ── YOLOv9 ──────────────────────────────────────────────────────
+  {
+    id: "yolov9t",
+    name: "YOLOv9 Tiny",
+    description: "YOLOv9 Tiny \u2014 ultra-lightweight next-gen detector",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+        sizeMB: 8
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+        sizeMB: 4,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
+        sizeMB: 6,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9t_float32.tflite"),
+        sizeMB: 8,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov9s",
+    name: "YOLOv9 Small",
+    description: "YOLOv9 Small \u2014 improved efficiency over YOLOv8s",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+        sizeMB: 28
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+        sizeMB: 14,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
+        sizeMB: 16,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9s_float32.tflite"),
+        sizeMB: 28,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov9c",
+    name: "YOLOv9 C",
+    description: "YOLOv9 C \u2014 high-accuracy compact model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+        sizeMB: 97
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+        sizeMB: 48,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
+        sizeMB: 49,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9c_float32.tflite"),
+        sizeMB: 97,
+        runtimes: ["python"]
+      }
+    }
+  },
+  // ── YOLO11 ────────────────────────────────────────────────────
+  {
+    id: "yolo11n",
+    name: "YOLO11 Nano",
+    description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 detection model (mAP 39.5)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11n.onnx"),
+        sizeMB: 10
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11n.mlpackage"),
+        sizeMB: 5,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11n.xml"),
+        sizeMB: 5,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11n_float32.tflite"),
+        sizeMB: 10,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11s",
+    name: "YOLO11 Small",
+    description: "YOLO11 Small \u2014 balanced speed and accuracy (mAP 47.0)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11s.onnx"),
+        sizeMB: 36
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11s.mlpackage"),
+        sizeMB: 18,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11s.xml"),
+        sizeMB: 18,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11s_float32.tflite"),
+        sizeMB: 36,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11m",
+    name: "YOLO11 Medium",
+    description: "YOLO11 Medium \u2014 higher accuracy, moderate size (mAP 51.5)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11m.onnx"),
+        sizeMB: 77
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11m.mlpackage"),
+        sizeMB: 39,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11m.xml"),
+        sizeMB: 39,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11m_float32.tflite"),
+        sizeMB: 77,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11l",
+    name: "YOLO11 Large",
+    description: "YOLO11 Large \u2014 high-accuracy large model (mAP 53.4)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11l.onnx"),
+        sizeMB: 97
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11l.mlpackage"),
+        sizeMB: 49,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11l.xml"),
+        sizeMB: 49,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11l_float32.tflite"),
+        sizeMB: 97,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11x",
+    name: "YOLO11 Extra-Large",
+    description: "YOLO11 Extra-Large \u2014 maximum accuracy (mAP 54.7)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11x.onnx"),
+        sizeMB: 218
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11x.mlpackage"),
+        sizeMB: 109,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11x.xml"),
+        sizeMB: 109,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11x_float32.tflite"),
+        sizeMB: 218,
+        runtimes: ["python"]
+      }
+    }
+  }
+];
+
+// src/catalogs/animal-classification-models.ts
+var HF_REPO2 = "camstack/camstack-models";
+var hf = (path3) => (0, import_types2.hfModelUrl)(HF_REPO2, path3);
 var BIRD_LABEL = { id: "species", name: "Bird Species" };
 var ANIMAL_TYPE_LABEL = { id: "animal-type", name: "Animal Type" };
 var BIRD_SPECIES_MODELS = [
@@ -50,7 +459,14 @@ var BIRD_SPECIES_MODELS = [
     labels: [BIRD_LABEL],
     formats: {
       onnx: { url: hf("animalClassification/bird-species/onnx/camstack-bird-species-525.onnx"), sizeMB: 32 }
-    }
+    },
+    extraFiles: [
+      {
+        url: hf("animalClassification/bird-species/onnx/camstack-bird-species-525-labels.json"),
+        filename: "camstack-bird-species-525-labels.json",
+        sizeMB: 0.02
+      }
+    ]
   }
 ];
 var BIRD_NABIRDS_MODELS = [
@@ -63,9 +479,16 @@ var BIRD_NABIRDS_MODELS = [
     labels: [{ id: "species", name: "Bird Species" }],
     formats: {
       onnx: { url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404.onnx"), sizeMB: 93 },
-      coreml: { url: hf("animalClassification/bird-nabirds/coreml/camstack-bird-nabirds-404.mlpackage"), sizeMB: 47 },
-      openvino: { url: hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"), sizeMB: 47 }
-    }
+      coreml: { url: hf("animalClassification/bird-nabirds/coreml/camstack-bird-nabirds-404.mlpackage"), sizeMB: 47, isDirectory: true, files: MLPACKAGE_FILES, runtimes: ["python"] },
+      openvino: { url: hf("animalClassification/bird-nabirds/openvino/camstack-bird-nabirds-404.xml"), sizeMB: 47, runtimes: ["python"] }
+    },
+    extraFiles: [
+      {
+        url: hf("animalClassification/bird-nabirds/onnx/camstack-bird-nabirds-404-labels.json"),
+        filename: "camstack-bird-nabirds-404-labels.json",
+        sizeMB: 0.02
+      }
+    ]
   }
 ];
 var ANIMAL_TYPE_MODELS = [
@@ -93,7 +516,7 @@ async function cropRegion(jpeg, roi) {
   }).jpeg().toBuffer();
 }
 async function resizeAndNormalize(jpeg, targetWidth, targetHeight, normalization, layout) {
-  const { data } = await (0, import_sharp.default)(jpeg).resize(targetWidth, targetHeight).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const { data } = await (0, import_sharp.default)(jpeg).resize(targetWidth, targetHeight, { fit: "fill" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
   const numPixels = targetWidth * targetHeight;
   const float32 = new Float32Array(3 * numPixels);
   const mean = [0.485, 0.456, 0.406];
@@ -208,6 +631,7 @@ var NodeInferenceEngine = class {
 
 // src/shared/python-engine.ts
 var import_node_child_process = require("child_process");
+var import_core = require("@camstack/core");
 var PythonInferenceEngine = class {
   constructor(pythonPath, scriptPath, runtime, modelPath, extraArgs = []) {
     this.pythonPath = pythonPath;
@@ -328,7 +752,7 @@ var PythonInferenceEngine = class {
 var AUTO_BACKEND_PRIORITY = ["coreml", "cuda", "tensorrt", "cpu"];
 var BACKEND_TO_FORMAT = {
   cpu: "onnx",
-  coreml: "coreml",
+  coreml: "onnx",
   cuda: "onnx",
   tensorrt: "onnx"
 };
@@ -356,7 +780,7 @@ function modelExists(filePath) {
   }
 }
 async function resolveEngine(options) {
-  const { runtime, backend, modelEntry, modelsDir, downloadModel } = options;
+  const { runtime, backend, modelEntry, modelsDir, models } = options;
   let selectedFormat;
   let selectedBackend;
   if (runtime === "auto") {
@@ -390,18 +814,18 @@ async function resolveEngine(options) {
     selectedFormat = fmt;
     selectedBackend = runtime === "onnx" ? backend || "cpu" : runtime;
   }
-  let modelPath = modelFilePath(modelsDir, modelEntry, selectedFormat);
-  if (!modelExists(modelPath)) {
-    if (downloadModel) {
-      const formatEntry = modelEntry.formats[selectedFormat];
-      modelPath = await downloadModel(formatEntry.url, modelsDir);
-    } else {
+  let modelPath;
+  if (models) {
+    modelPath = await models.ensure(modelEntry.id, selectedFormat);
+  } else {
+    modelPath = modelFilePath(modelsDir, modelEntry, selectedFormat);
+    if (!modelExists(modelPath)) {
       throw new Error(
-        `resolveEngine: model file not found at ${modelPath} and no downloadModel function provided`
+        `resolveEngine: model file not found at ${modelPath} and no model service provided`
       );
     }
   }
-  if (selectedFormat === "onnx" || selectedFormat === "coreml") {
+  if (selectedFormat === "onnx") {
     const engine = new NodeInferenceEngine(modelPath, selectedBackend);
     await engine.initialize();
     return { engine, format: selectedFormat, modelPath };
@@ -415,7 +839,18 @@ async function resolveEngine(options) {
   const effectiveRuntime = runtime === "auto" ? selectedBackend : runtime;
   const scriptName = PYTHON_SCRIPT_MAP[effectiveRuntime];
   if (scriptName && pythonPath) {
-    const scriptPath = path2.join(__dirname, "../../python", scriptName);
+    const candidates = [
+      path2.join(__dirname, "../../python", scriptName),
+      path2.join(__dirname, "../python", scriptName),
+      path2.join(__dirname, "../../../python", scriptName)
+    ];
+    const scriptPath = candidates.find((p) => fs.existsSync(p));
+    if (!scriptPath) {
+      throw new Error(
+        `resolveEngine: Python script "${scriptName}" not found. Searched:
+${candidates.join("\n")}`
+      );
+    }
     const inputSize = Math.max(modelEntry.inputSize.width, modelEntry.inputSize.height);
     const engine = new PythonInferenceEngine(pythonPath, scriptPath, effectiveRuntime, modelPath, [
       `--input-size=${inputSize}`,
@@ -487,42 +922,49 @@ var AnimalClassifierAddon = class {
     name: "Animal Classifier",
     version: "0.1.0",
     description: "ViT-based animal type classifier \u2014 10 common species",
-    packageName: "@camstack/addon-vision",
     slot: "classifier",
+    labelOutputType: "classification",
     inputClasses: ["animal"],
     outputClasses: ["animal-type:*"],
     supportsCustomModels: false,
     mayRequirePython: false,
     defaultConfig: {
       modelId: "animals-10",
-      runtime: "auto",
+      runtime: "node",
       backend: "cpu",
       minConfidence: 0.3
     }
   };
-  engine;
+  engine = null;
   modelEntry;
   minConfidence = 0.3;
+  resolvedConfig = null;
+  ctx = null;
+  getModelRequirements() {
+    return 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"] ?? "animals-10";
-    const runtime = cfg["runtime"] ?? "auto";
-    const backend = cfg["backend"] ?? "cpu";
+    const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "animals-10";
     this.minConfidence = cfg["minConfidence"] ?? 0.3;
     const entry = ANIMAL_TYPE_MODELS.find((m) => m.id === modelId);
     if (!entry) {
       throw new Error(`AnimalClassifierAddon: unknown modelId "${modelId}"`);
     }
     this.modelEntry = entry;
-    const resolved = await resolveEngine({
-      runtime,
-      backend,
-      modelEntry: entry,
-      modelsDir: ctx.locationPaths.models
-    });
-    this.engine = resolved.engine;
   }
   async classify(input) {
+    if (!this.engine) await this.ensureEngine();
     const start = Date.now();
     const { width: inputW, height: inputH } = this.modelEntry.inputSize;
     const animalCrop = await cropRegion(input.frame.data, input.roi);
@@ -557,6 +999,27 @@ var AnimalClassifierAddon = class {
       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_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 resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir,
+      models: this.ctx.models
+    });
+    this.engine = resolved.engine;
+  }
   async shutdown() {
     await this.engine?.dispose();
   }
@@ -581,22 +1044,6 @@ var AnimalClassifierAddon = class {
             }
           ]
         },
-        {
-          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: "runtime",
           title: "Runtime",
@@ -607,23 +1054,41 @@ var AnimalClassifierAddon = class {
               label: "Runtime",
               type: "select",
               options: [
-                { value: "auto", label: "Auto (recommended)" },
+                { value: "auto", label: "Auto" },
                 { value: "onnx", label: "ONNX Runtime" },
-                { value: "coreml", label: "CoreML (Apple)" }
+                { value: "coreml", label: "CoreML (Apple)" },
+                { value: "openvino", label: "OpenVINO (Intel)" }
               ]
             },
             {
               key: "backend",
               label: "Backend",
               type: "select",
-              dependsOn: { runtime: "onnx" },
+              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
+            }
+          ]
         }
       ]
     };