@camstack/addon-vision 0.1.1 → 0.1.3

package/dist/addons/object-detection/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,1148 +30,1349 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/addons/object-detection/index.ts
-var object_detection_exports = {};
-__export(object_detection_exports, {
-  default: () => ObjectDetectionAddon
-});
-module.exports = __toCommonJS(object_detection_exports);
-
-// src/catalogs/object-detection-models.ts
-var import_types = require("@camstack/types");
-var HF_REPO = "camstack/camstack-models";
-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
+// src/catalogs/object-detection-models.js
+var require_object_detection_models = __commonJS({
+  "src/catalogs/object-detection-models.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OBJECT_DETECTION_MODELS = exports2.MLPACKAGE_FILES = void 0;
+    var types_1 = require("@camstack/types");
+    var HF_REPO = "camstack/camstack-models";
+    exports2.MLPACKAGE_FILES = [
+      "Manifest.json",
+      "Data/com.apple.CoreML/model.mlmodel",
+      "Data/com.apple.CoreML/weights/weight.bin"
+    ];
+    exports2.OBJECT_DETECTION_MODELS = [
+      // ── YOLOv8 ──────────────────────────────────────────────────────
+      {
+        id: "yolov8n",
+        name: "YOLOv8 Nano",
+        description: "YOLOv8 Nano \u2014 fastest, smallest object detection model",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8n.onnx"),
+            sizeMB: 12
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8n.mlpackage"),
+            sizeMB: 6,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8n.xml"),
+            sizeMB: 7,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8n_float32.tflite"),
+            sizeMB: 12,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8m.mlpackage"),
-        sizeMB: 49,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      {
+        id: "yolov8s",
+        name: "YOLOv8 Small",
+        description: "YOLOv8 Small \u2014 balanced speed and accuracy",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s.onnx"),
+            sizeMB: 43
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8s.mlpackage"),
+            sizeMB: 21,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8s.xml"),
+            sizeMB: 22,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8s_float32.tflite"),
+            sizeMB: 43,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8m.xml"),
-        sizeMB: 50,
-        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: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s-relu.onnx"),
+            sizeMB: 43
+          }
+        }
       },
-      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
+      {
+        id: "yolov8m",
+        name: "YOLOv8 Medium",
+        description: "YOLOv8 Medium \u2014 higher accuracy, moderate size",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8m.onnx"),
+            sizeMB: 99
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8m.mlpackage"),
+            sizeMB: 49,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8m.xml"),
+            sizeMB: 50,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8m_float32.tflite"),
+            sizeMB: 99,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8l.mlpackage"),
-        sizeMB: 83,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      {
+        id: "yolov8l",
+        name: "YOLOv8 Large",
+        description: "YOLOv8 Large \u2014 high-accuracy large model",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8l.onnx"),
+            sizeMB: 167
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8l.mlpackage"),
+            sizeMB: 83,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8l.xml"),
+            sizeMB: 84,
+            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
+      {
+        id: "yolov8x",
+        name: "YOLOv8 Extra-Large",
+        description: "YOLOv8 Extra-Large \u2014 maximum accuracy",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8x.onnx"),
+            sizeMB: 260
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8x.mlpackage"),
+            sizeMB: 130,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8x.xml"),
+            sizeMB: 131,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8x.mlpackage"),
-        sizeMB: 130,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      // ── YOLOv9 ──────────────────────────────────────────────────────
+      {
+        id: "yolov9t",
+        name: "YOLOv9 Tiny",
+        description: "YOLOv9 Tiny \u2014 ultra-lightweight next-gen detector",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+            sizeMB: 8
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+            sizeMB: 4,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
+            sizeMB: 6,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9t_float32.tflite"),
+            sizeMB: 8,
+            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
+      {
+        id: "yolov9s",
+        name: "YOLOv9 Small",
+        description: "YOLOv9 Small \u2014 improved efficiency over YOLOv8s",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+            sizeMB: 28
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+            sizeMB: 14,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
+            sizeMB: 16,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9s_float32.tflite"),
+            sizeMB: 28,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
-        sizeMB: 4,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      {
+        id: "yolov9c",
+        name: "YOLOv9 C",
+        description: "YOLOv9 C \u2014 high-accuracy compact model",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+            sizeMB: 97
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+            sizeMB: 48,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
+            sizeMB: 49,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9c_float32.tflite"),
+            sizeMB: 97,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
-        sizeMB: 6,
-        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: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11n.onnx"),
+            sizeMB: 10
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11n.mlpackage"),
+            sizeMB: 5,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11n.xml"),
+            sizeMB: 5,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11n_float32.tflite"),
+            sizeMB: 10,
+            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
+      {
+        id: "yolo11s",
+        name: "YOLO11 Small",
+        description: "YOLO11 Small \u2014 balanced speed and accuracy (mAP 47.0)",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11s.onnx"),
+            sizeMB: 36
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11s.mlpackage"),
+            sizeMB: 18,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11s.xml"),
+            sizeMB: 18,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11s_float32.tflite"),
+            sizeMB: 36,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
-        sizeMB: 14,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      {
+        id: "yolo11m",
+        name: "YOLO11 Medium",
+        description: "YOLO11 Medium \u2014 higher accuracy, moderate size (mAP 51.5)",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11m.onnx"),
+            sizeMB: 77
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11m.mlpackage"),
+            sizeMB: 39,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11m.xml"),
+            sizeMB: 39,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11m_float32.tflite"),
+            sizeMB: 77,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
-        sizeMB: 16,
-        runtimes: ["python"]
+      {
+        id: "yolo11l",
+        name: "YOLO11 Large",
+        description: "YOLO11 Large \u2014 high-accuracy large model (mAP 53.4)",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11l.onnx"),
+            sizeMB: 97
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11l.mlpackage"),
+            sizeMB: 49,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11l.xml"),
+            sizeMB: 49,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11l_float32.tflite"),
+            sizeMB: 97,
+            runtimes: ["python"]
+          }
+        }
       },
-      tflite: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9s_float32.tflite"),
-        sizeMB: 28,
-        runtimes: ["python"]
+      {
+        id: "yolo11x",
+        name: "YOLO11 Extra-Large",
+        description: "YOLO11 Extra-Large \u2014 maximum accuracy (mAP 54.7)",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11x.onnx"),
+            sizeMB: 218
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11x.mlpackage"),
+            sizeMB: 109,
+            isDirectory: true,
+            files: exports2.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11x.xml"),
+            sizeMB: 109,
+            runtimes: ["python"]
+          },
+          tflite: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11x_float32.tflite"),
+            sizeMB: 218,
+            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"]
+    ];
+  }
+});
+
+// src/catalogs/segmentation-models.js
+var require_segmentation_models = __commonJS({
+  "src/catalogs/segmentation-models.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SEGMENTATION_MODELS = void 0;
+    var types_1 = require("@camstack/types");
+    var object_detection_models_js_1 = require_object_detection_models();
+    var HF_REPO = "camstack/camstack-models";
+    exports2.SEGMENTATION_MODELS = [
+      // ── YOLO11-seg ───────────────────────────────────────────────
+      {
+        id: "yolo11n-seg",
+        name: "YOLO11 Nano Segmentation",
+        description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 instance segmentation model",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/onnx/camstack-yolo11n-seg.onnx"),
+            sizeMB: 11
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/coreml/camstack-yolo11n-seg.mlpackage"),
+            sizeMB: 6,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/openvino/camstack-yolo11n-seg.xml"),
+            sizeMB: 6,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
-        sizeMB: 49,
-        runtimes: ["python"]
+      {
+        id: "yolo11s-seg",
+        name: "YOLO11 Small Segmentation",
+        description: "YOLO11 Small \u2014 balanced speed and accuracy for instance segmentation",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/onnx/camstack-yolo11s-seg.onnx"),
+            sizeMB: 39
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/coreml/camstack-yolo11s-seg.mlpackage"),
+            sizeMB: 20,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/openvino/camstack-yolo11s-seg.xml"),
+            sizeMB: 20,
+            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
+      {
+        id: "yolo11m-seg",
+        name: "YOLO11 Medium Segmentation",
+        description: "YOLO11 Medium \u2014 higher accuracy instance segmentation",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/onnx/camstack-yolo11m-seg.onnx"),
+            sizeMB: 86
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/coreml/camstack-yolo11m-seg.mlpackage"),
+            sizeMB: 43,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolo11-seg/openvino/camstack-yolo11m-seg.xml"),
+            sizeMB: 43,
+            runtimes: ["python"]
+          }
+        }
       },
-      coreml: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11n.mlpackage"),
-        sizeMB: 5,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
+      // ── YOLOv8-seg — CoreML supported ─────────────────────────────
+      {
+        id: "yolov8n-seg",
+        name: "YOLOv8 Nano Segmentation",
+        description: "YOLOv8 Nano \u2014 fastest, smallest YOLOv8 instance segmentation model",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/onnx/camstack-yolov8n-seg.onnx"),
+            sizeMB: 13
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/coreml/camstack-yolov8n-seg.mlpackage"),
+            sizeMB: 7,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/openvino/camstack-yolov8n-seg.xml"),
+            sizeMB: 7,
+            runtimes: ["python"]
+          }
+        }
       },
-      openvino: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11n.xml"),
-        sizeMB: 5,
-        runtimes: ["python"]
+      {
+        id: "yolov8s-seg",
+        name: "YOLOv8 Small Segmentation",
+        description: "YOLOv8 Small \u2014 balanced speed and accuracy for instance segmentation",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/onnx/camstack-yolov8s-seg.onnx"),
+            sizeMB: 45
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/coreml/camstack-yolov8s-seg.mlpackage"),
+            sizeMB: 23,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/openvino/camstack-yolov8s-seg.xml"),
+            sizeMB: 23,
+            runtimes: ["python"]
+          }
+        }
       },
-      tflite: {
-        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11n_float32.tflite"),
-        sizeMB: 10,
-        runtimes: ["python"]
+      {
+        id: "yolov8m-seg",
+        name: "YOLOv8 Medium Segmentation",
+        description: "YOLOv8 Medium \u2014 higher accuracy instance segmentation",
+        inputSize: { width: 640, height: 640 },
+        labels: types_1.COCO_80_LABELS,
+        formats: {
+          onnx: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/onnx/camstack-yolov8m-seg.onnx"),
+            sizeMB: 104
+          },
+          coreml: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/coreml/camstack-yolov8m-seg.mlpackage"),
+            sizeMB: 52,
+            isDirectory: true,
+            files: object_detection_models_js_1.MLPACKAGE_FILES,
+            runtimes: ["python"]
+          },
+          openvino: {
+            url: (0, types_1.hfModelUrl)(HF_REPO, "segmentation/yolov8-seg/openvino/camstack-yolov8m-seg.xml"),
+            sizeMB: 53,
+            runtimes: ["python"]
+          }
+        }
       }
+    ];
+  }
+});
+
+// src/shared/image-utils.js
+var require_image_utils = __commonJS({
+  "src/shared/image-utils.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.jpegToRgb = jpegToRgb;
+    exports2.cropRegion = cropRegion;
+    exports2.letterbox = letterbox2;
+    exports2.resizeAndNormalize = resizeAndNormalize;
+    exports2.rgbToGrayscale = rgbToGrayscale;
+    var sharp_1 = __importDefault(require("sharp"));
+    async function jpegToRgb(jpeg) {
+      const { data, info } = await (0, sharp_1.default)(jpeg).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+      return { data, width: info.width, height: info.height };
     }
-  },
-  {
-    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"]
-      }
+    async function cropRegion(jpeg, roi) {
+      return (0, sharp_1.default)(jpeg).extract({
+        left: Math.round(roi.x),
+        top: Math.round(roi.y),
+        width: Math.round(roi.w),
+        height: Math.round(roi.h)
+      }).jpeg().toBuffer();
     }
-  },
-  {
-    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"]
+    async function letterbox2(jpeg, targetSize) {
+      const meta = await (0, sharp_1.default)(jpeg).metadata();
+      const originalWidth = meta.width ?? 0;
+      const originalHeight = meta.height ?? 0;
+      const scale = Math.min(targetSize / originalWidth, targetSize / originalHeight);
+      const scaledWidth = Math.round(originalWidth * scale);
+      const scaledHeight = Math.round(originalHeight * scale);
+      const padX = Math.floor((targetSize - scaledWidth) / 2);
+      const padY = Math.floor((targetSize - scaledHeight) / 2);
+      const { data } = await (0, sharp_1.default)(jpeg).resize(scaledWidth, scaledHeight).extend({
+        top: padY,
+        bottom: targetSize - scaledHeight - padY,
+        left: padX,
+        right: targetSize - scaledWidth - padX,
+        background: { r: 114, g: 114, b: 114 }
+      }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+      const numPixels = targetSize * targetSize;
+      const float32 = new Float32Array(3 * numPixels);
+      for (let i = 0; i < numPixels; i++) {
+        const srcBase = i * 3;
+        float32[0 * numPixels + i] = data[srcBase] / 255;
+        float32[1 * numPixels + i] = data[srcBase + 1] / 255;
+        float32[2 * numPixels + i] = data[srcBase + 2] / 255;
       }
+      return { data: float32, scale, padX, padY, originalWidth, originalHeight };
     }
-  },
-  {
-    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"]
+    async function resizeAndNormalize(jpeg, targetWidth, targetHeight, normalization, layout) {
+      const { data } = await (0, sharp_1.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];
+      const std = [0.229, 0.224, 0.225];
+      if (layout === "nchw") {
+        for (let i = 0; i < numPixels; i++) {
+          const srcBase = i * 3;
+          for (let c = 0; c < 3; c++) {
+            const raw = data[srcBase + c] / 255;
+            let val;
+            if (normalization === "zero-one") {
+              val = raw;
+            } else if (normalization === "imagenet") {
+              val = (raw - mean[c]) / std[c];
+            } else {
+              val = data[srcBase + c];
+            }
+            float32[c * numPixels + i] = val;
+          }
+        }
+      } else {
+        for (let i = 0; i < numPixels; i++) {
+          const srcBase = i * 3;
+          for (let c = 0; c < 3; c++) {
+            const raw = data[srcBase + c] / 255;
+            let val;
+            if (normalization === "zero-one") {
+              val = raw;
+            } else if (normalization === "imagenet") {
+              val = (raw - mean[c]) / std[c];
+            } else {
+              val = data[srcBase + c];
+            }
+            float32[i * 3 + c] = val;
+          }
+        }
       }
+      return float32;
     }
-  },
-  {
-    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"]
+    function rgbToGrayscale(rgb, width, height) {
+      const numPixels = width * height;
+      const gray = new Uint8Array(numPixels);
+      for (let i = 0; i < numPixels; i++) {
+        const r = rgb[i * 3];
+        const g = rgb[i * 3 + 1];
+        const b = rgb[i * 3 + 2];
+        gray[i] = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
       }
+      return gray;
     }
   }
-];
+});
 
-// src/catalogs/segmentation-models.ts
-var import_types2 = require("@camstack/types");
-var HF_REPO2 = "camstack/camstack-models";
-var SEGMENTATION_MODELS = [
-  // ── YOLO11-seg ───────────────────────────────────────────────
-  {
-    id: "yolo11n-seg",
-    name: "YOLO11 Nano Segmentation",
-    description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 instance segmentation model",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11n-seg.onnx"),
-        sizeMB: 11
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/coreml/camstack-yolo11n-seg.mlpackage"),
-        sizeMB: 6,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11n-seg.xml"),
-        sizeMB: 6,
-        runtimes: ["python"]
-      }
+// src/shared/postprocess/yolo.js
+var require_yolo = __commonJS({
+  "src/shared/postprocess/yolo.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.iou = iou;
+    exports2.nms = nms;
+    exports2.yoloPostprocess = yoloPostprocess2;
+    function iou(a, b) {
+      const ax1 = a.x;
+      const ay1 = a.y;
+      const ax2 = a.x + a.w;
+      const ay2 = a.y + a.h;
+      const bx1 = b.x;
+      const by1 = b.y;
+      const bx2 = b.x + b.w;
+      const by2 = b.y + b.h;
+      const interX1 = Math.max(ax1, bx1);
+      const interY1 = Math.max(ay1, by1);
+      const interX2 = Math.min(ax2, bx2);
+      const interY2 = Math.min(ay2, by2);
+      const interW = Math.max(0, interX2 - interX1);
+      const interH = Math.max(0, interY2 - interY1);
+      const interArea = interW * interH;
+      if (interArea === 0)
+        return 0;
+      const areaA = a.w * a.h;
+      const areaB = b.w * b.h;
+      const unionArea = areaA + areaB - interArea;
+      return unionArea === 0 ? 0 : interArea / unionArea;
     }
-  },
-  {
-    id: "yolo11s-seg",
-    name: "YOLO11 Small Segmentation",
-    description: "YOLO11 Small \u2014 balanced speed and accuracy for instance segmentation",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11s-seg.onnx"),
-        sizeMB: 39
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/coreml/camstack-yolo11s-seg.mlpackage"),
-        sizeMB: 20,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11s-seg.xml"),
-        sizeMB: 20,
-        runtimes: ["python"]
+    function nms(boxes, iouThreshold) {
+      const indices = boxes.map((_, i) => i).sort((a, b) => boxes[b].score - boxes[a].score);
+      const kept = [];
+      const suppressed = /* @__PURE__ */ new Set();
+      for (const idx of indices) {
+        if (suppressed.has(idx))
+          continue;
+        kept.push(idx);
+        for (const other of indices) {
+          if (other === idx || suppressed.has(other))
+            continue;
+          if (iou(boxes[idx].bbox, boxes[other].bbox) > iouThreshold) {
+            suppressed.add(other);
+          }
+        }
       }
+      return kept;
     }
-  },
-  {
-    id: "yolo11m-seg",
-    name: "YOLO11 Medium Segmentation",
-    description: "YOLO11 Medium \u2014 higher accuracy instance segmentation",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11m-seg.onnx"),
-        sizeMB: 86
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/coreml/camstack-yolo11m-seg.mlpackage"),
-        sizeMB: 43,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11m-seg.xml"),
-        sizeMB: 43,
-        runtimes: ["python"]
+    function yoloPostprocess2(output, numClasses, numBoxes, options) {
+      const { confidence, iouThreshold, labels, scale, padX, padY, originalWidth, originalHeight } = options;
+      const candidates = [];
+      for (let i = 0; i < numBoxes; i++) {
+        const cx = output[0 * numBoxes + i];
+        const cy = output[1 * numBoxes + i];
+        const w = output[2 * numBoxes + i];
+        const h = output[3 * numBoxes + i];
+        let bestScore = -Infinity;
+        let bestClass = 0;
+        for (let j = 0; j < numClasses; j++) {
+          const score = output[(4 + j) * numBoxes + i];
+          if (score > bestScore) {
+            bestScore = score;
+            bestClass = j;
+          }
+        }
+        if (bestScore < confidence)
+          continue;
+        const bbox = {
+          x: cx - w / 2,
+          y: cy - h / 2,
+          w,
+          h
+        };
+        candidates.push({ bbox, score: bestScore, classIdx: bestClass });
       }
+      if (candidates.length === 0)
+        return [];
+      const keptIndices = nms(candidates, iouThreshold);
+      return keptIndices.map((idx) => {
+        const { bbox, score, classIdx } = candidates[idx];
+        const label = labels[classIdx] ?? String(classIdx);
+        const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
+        const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
+        const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
+        const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
+        const finalBbox = { x, y, w: x2 - x, h: y2 - y };
+        return {
+          class: label,
+          originalClass: label,
+          score,
+          bbox: finalBbox
+        };
+      });
     }
-  },
-  // ── YOLOv8-seg — CoreML supported ─────────────────────────────
-  {
-    id: "yolov8n-seg",
-    name: "YOLOv8 Nano Segmentation",
-    description: "YOLOv8 Nano \u2014 fastest, smallest YOLOv8 instance segmentation model",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8n-seg.onnx"),
-        sizeMB: 13
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8n-seg.mlpackage"),
-        sizeMB: 7,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8n-seg.xml"),
-        sizeMB: 7,
-        runtimes: ["python"]
-      }
+  }
+});
+
+// src/shared/postprocess/yolo-seg.js
+var require_yolo_seg = __commonJS({
+  "src/shared/postprocess/yolo-seg.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.sigmoid = sigmoid;
+    exports2.computeRawMask = computeRawMask;
+    exports2.cropAndThresholdMask = cropAndThresholdMask;
+    exports2.yoloSegPostprocess = yoloSegPostprocess2;
+    var yolo_js_1 = require_yolo();
+    function sigmoid(x) {
+      return 1 / (1 + Math.exp(-x));
     }
-  },
-  {
-    id: "yolov8s-seg",
-    name: "YOLOv8 Small Segmentation",
-    description: "YOLOv8 Small \u2014 balanced speed and accuracy for instance segmentation",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8s-seg.onnx"),
-        sizeMB: 45
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8s-seg.mlpackage"),
-        sizeMB: 23,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8s-seg.xml"),
-        sizeMB: 23,
-        runtimes: ["python"]
+    function computeRawMask(coeffs, protos, numMaskCoeffs, maskH, maskW) {
+      const maskSize = maskH * maskW;
+      const rawMask = new Float32Array(maskSize);
+      for (let px = 0; px < maskSize; px++) {
+        let val = 0;
+        for (let k = 0; k < numMaskCoeffs; k++) {
+          val += (coeffs[k] ?? 0) * (protos[k * maskSize + px] ?? 0);
+        }
+        rawMask[px] = sigmoid(val);
       }
+      return rawMask;
     }
-  },
-  {
-    id: "yolov8m-seg",
-    name: "YOLOv8 Medium Segmentation",
-    description: "YOLOv8 Medium \u2014 higher accuracy instance segmentation",
-    inputSize: { width: 640, height: 640 },
-    labels: import_types2.COCO_80_LABELS,
-    formats: {
-      onnx: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8m-seg.onnx"),
-        sizeMB: 104
-      },
-      coreml: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8m-seg.mlpackage"),
-        sizeMB: 52,
-        isDirectory: true,
-        files: MLPACKAGE_FILES,
-        runtimes: ["python"]
-      },
-      openvino: {
-        url: (0, import_types2.hfModelUrl)(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8m-seg.xml"),
-        sizeMB: 53,
-        runtimes: ["python"]
+    function cropAndThresholdMask(rawMask, maskH, maskW, bbox, maskThreshold, maskScale) {
+      const cropX1 = Math.max(0, Math.floor(bbox.x * maskScale));
+      const cropY1 = Math.max(0, Math.floor(bbox.y * maskScale));
+      const cropX2 = Math.min(maskW, Math.ceil((bbox.x + bbox.w) * maskScale));
+      const cropY2 = Math.min(maskH, Math.ceil((bbox.y + bbox.h) * maskScale));
+      const cropW = Math.max(1, cropX2 - cropX1);
+      const cropH = Math.max(1, cropY2 - cropY1);
+      const data = new Uint8Array(cropW * cropH);
+      for (let row = 0; row < cropH; row++) {
+        const srcRow = cropY1 + row;
+        for (let col = 0; col < cropW; col++) {
+          const srcCol = cropX1 + col;
+          const srcIdx = srcRow * maskW + srcCol;
+          data[row * cropW + col] = (rawMask[srcIdx] ?? 0) > maskThreshold ? 255 : 0;
+        }
       }
+      return { data, width: cropW, height: cropH };
     }
-  }
-];
-
-// src/addons/object-detection/index.ts
-var import_types3 = require("@camstack/types");
-
-// src/shared/image-utils.ts
-var import_sharp = __toESM(require("sharp"));
-async function letterbox(jpeg, targetSize) {
-  const meta = await (0, import_sharp.default)(jpeg).metadata();
-  const originalWidth = meta.width ?? 0;
-  const originalHeight = meta.height ?? 0;
-  const scale = Math.min(targetSize / originalWidth, targetSize / originalHeight);
-  const scaledWidth = Math.round(originalWidth * scale);
-  const scaledHeight = Math.round(originalHeight * scale);
-  const padX = Math.floor((targetSize - scaledWidth) / 2);
-  const padY = Math.floor((targetSize - scaledHeight) / 2);
-  const { data } = await (0, import_sharp.default)(jpeg).resize(scaledWidth, scaledHeight).extend({
-    top: padY,
-    bottom: targetSize - scaledHeight - padY,
-    left: padX,
-    right: targetSize - scaledWidth - padX,
-    background: { r: 114, g: 114, b: 114 }
-  }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
-  const numPixels = targetSize * targetSize;
-  const float32 = new Float32Array(3 * numPixels);
-  for (let i = 0; i < numPixels; i++) {
-    const srcBase = i * 3;
-    float32[0 * numPixels + i] = data[srcBase] / 255;
-    float32[1 * numPixels + i] = data[srcBase + 1] / 255;
-    float32[2 * numPixels + i] = data[srcBase + 2] / 255;
-  }
-  return { data: float32, scale, padX, padY, originalWidth, originalHeight };
-}
-
-// src/shared/postprocess/yolo.ts
-function iou(a, b) {
-  const ax1 = a.x;
-  const ay1 = a.y;
-  const ax2 = a.x + a.w;
-  const ay2 = a.y + a.h;
-  const bx1 = b.x;
-  const by1 = b.y;
-  const bx2 = b.x + b.w;
-  const by2 = b.y + b.h;
-  const interX1 = Math.max(ax1, bx1);
-  const interY1 = Math.max(ay1, by1);
-  const interX2 = Math.min(ax2, bx2);
-  const interY2 = Math.min(ay2, by2);
-  const interW = Math.max(0, interX2 - interX1);
-  const interH = Math.max(0, interY2 - interY1);
-  const interArea = interW * interH;
-  if (interArea === 0) return 0;
-  const areaA = a.w * a.h;
-  const areaB = b.w * b.h;
-  const unionArea = areaA + areaB - interArea;
-  return unionArea === 0 ? 0 : interArea / unionArea;
-}
-function nms(boxes, iouThreshold) {
-  const indices = boxes.map((_, i) => i).sort((a, b) => boxes[b].score - boxes[a].score);
-  const kept = [];
-  const suppressed = /* @__PURE__ */ new Set();
-  for (const idx of indices) {
-    if (suppressed.has(idx)) continue;
-    kept.push(idx);
-    for (const other of indices) {
-      if (other === idx || suppressed.has(other)) continue;
-      if (iou(boxes[idx].bbox, boxes[other].bbox) > iouThreshold) {
-        suppressed.add(other);
+    function yoloSegPostprocess2(segOutput, options) {
+      const { detectionOutput, protoOutput, numClasses, numBoxes, numMaskCoeffs, maskHeight, maskWidth } = segOutput;
+      const { confidence, iouThreshold, labels, scale, padX, padY, originalWidth, originalHeight, maskThreshold = 0.5 } = options;
+      const yoloInputSize = 640;
+      const maskScale = maskHeight / yoloInputSize;
+      const candidates = [];
+      for (let i = 0; i < numBoxes; i++) {
+        const cx = detectionOutput[0 * numBoxes + i] ?? 0;
+        const cy = detectionOutput[1 * numBoxes + i] ?? 0;
+        const w = detectionOutput[2 * numBoxes + i] ?? 0;
+        const h = detectionOutput[3 * numBoxes + i] ?? 0;
+        let bestScore = -Infinity;
+        let bestClass = 0;
+        for (let j = 0; j < numClasses; j++) {
+          const score = detectionOutput[(4 + j) * numBoxes + i] ?? 0;
+          if (score > bestScore) {
+            bestScore = score;
+            bestClass = j;
+          }
+        }
+        if (bestScore < confidence)
+          continue;
+        const bbox = {
+          x: cx - w / 2,
+          y: cy - h / 2,
+          w,
+          h
+        };
+        const coeffs = new Float32Array(numMaskCoeffs);
+        for (let k = 0; k < numMaskCoeffs; k++) {
+          coeffs[k] = detectionOutput[(4 + numClasses + k) * numBoxes + i] ?? 0;
+        }
+        candidates.push({ bbox, score: bestScore, classIdx: bestClass, coeffs });
       }
+      if (candidates.length === 0)
+        return [];
+      const keptIndices = (0, yolo_js_1.nms)(candidates, iouThreshold);
+      return keptIndices.map((idx) => {
+        const { bbox, score, classIdx, coeffs } = candidates[idx];
+        const label = labels[classIdx] ?? String(classIdx);
+        const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
+        const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
+        const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
+        const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
+        const finalBbox = { x, y, w: x2 - x, h: y2 - y };
+        const rawMask = computeRawMask(coeffs, protoOutput, numMaskCoeffs, maskHeight, maskWidth);
+        const { data: maskData, width: mW, height: mH } = cropAndThresholdMask(rawMask, maskHeight, maskWidth, bbox, maskThreshold, maskScale);
+        return {
+          class: label,
+          originalClass: label,
+          score,
+          bbox: finalBbox,
+          mask: maskData,
+          maskWidth: mW,
+          maskHeight: mH
+        };
+      });
     }
   }
-  return kept;
-}
-function yoloPostprocess(output, numClasses, numBoxes, options) {
-  const { confidence, iouThreshold, labels, scale, padX, padY, originalWidth, originalHeight } = options;
-  const candidates = [];
-  for (let i = 0; i < numBoxes; i++) {
-    const cx = output[0 * numBoxes + i];
-    const cy = output[1 * numBoxes + i];
-    const w = output[2 * numBoxes + i];
-    const h = output[3 * numBoxes + i];
-    let bestScore = -Infinity;
-    let bestClass = 0;
-    for (let j = 0; j < numClasses; j++) {
-      const score = output[(4 + j) * numBoxes + i];
-      if (score > bestScore) {
-        bestScore = score;
-        bestClass = j;
+});
+
+// src/shared/node-engine.js
+var require_node_engine = __commonJS({
+  "src/shared/node-engine.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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];
+        } };
       }
-    }
-    if (bestScore < confidence) continue;
-    const bbox = {
-      x: cx - w / 2,
-      y: cy - h / 2,
-      w,
-      h
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
+    exports2.NodeInferenceEngine = void 0;
+    var path = __importStar(require("path"));
+    var BACKEND_TO_PROVIDER = {
+      cpu: "cpu",
+      coreml: "coreml",
+      cuda: "cuda",
+      tensorrt: "tensorrt",
+      dml: "dml"
     };
-    candidates.push({ bbox, score: bestScore, classIdx: bestClass });
-  }
-  if (candidates.length === 0) return [];
-  const keptIndices = nms(candidates, iouThreshold);
-  return keptIndices.map((idx) => {
-    const { bbox, score, classIdx } = candidates[idx];
-    const label = labels[classIdx] ?? String(classIdx);
-    const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
-    const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
-    const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
-    const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
-    const finalBbox = { x, y, w: x2 - x, h: y2 - y };
-    return {
-      class: label,
-      originalClass: label,
-      score,
-      bbox: finalBbox
+    var BACKEND_TO_DEVICE = {
+      cpu: "cpu",
+      coreml: "gpu-mps",
+      cuda: "gpu-cuda",
+      tensorrt: "tensorrt"
     };
-  });
-}
-
-// src/shared/postprocess/yolo-seg.ts
-function sigmoid(x) {
-  return 1 / (1 + Math.exp(-x));
-}
-function computeRawMask(coeffs, protos, numMaskCoeffs, maskH, maskW) {
-  const maskSize = maskH * maskW;
-  const rawMask = new Float32Array(maskSize);
-  for (let px = 0; px < maskSize; px++) {
-    let val = 0;
-    for (let k = 0; k < numMaskCoeffs; k++) {
-      val += (coeffs[k] ?? 0) * (protos[k * maskSize + px] ?? 0);
-    }
-    rawMask[px] = sigmoid(val);
-  }
-  return rawMask;
-}
-function cropAndThresholdMask(rawMask, maskH, maskW, bbox, maskThreshold, maskScale) {
-  const cropX1 = Math.max(0, Math.floor(bbox.x * maskScale));
-  const cropY1 = Math.max(0, Math.floor(bbox.y * maskScale));
-  const cropX2 = Math.min(maskW, Math.ceil((bbox.x + bbox.w) * maskScale));
-  const cropY2 = Math.min(maskH, Math.ceil((bbox.y + bbox.h) * maskScale));
-  const cropW = Math.max(1, cropX2 - cropX1);
-  const cropH = Math.max(1, cropY2 - cropY1);
-  const data = new Uint8Array(cropW * cropH);
-  for (let row = 0; row < cropH; row++) {
-    const srcRow = cropY1 + row;
-    for (let col = 0; col < cropW; col++) {
-      const srcCol = cropX1 + col;
-      const srcIdx = srcRow * maskW + srcCol;
-      data[row * cropW + col] = (rawMask[srcIdx] ?? 0) > maskThreshold ? 255 : 0;
-    }
-  }
-  return { data, width: cropW, height: cropH };
-}
-function yoloSegPostprocess(segOutput, options) {
-  const {
-    detectionOutput,
-    protoOutput,
-    numClasses,
-    numBoxes,
-    numMaskCoeffs,
-    maskHeight,
-    maskWidth
-  } = segOutput;
-  const {
-    confidence,
-    iouThreshold,
-    labels,
-    scale,
-    padX,
-    padY,
-    originalWidth,
-    originalHeight,
-    maskThreshold = 0.5
-  } = options;
-  const yoloInputSize = 640;
-  const maskScale = maskHeight / yoloInputSize;
-  const candidates = [];
-  for (let i = 0; i < numBoxes; i++) {
-    const cx = detectionOutput[0 * numBoxes + i] ?? 0;
-    const cy = detectionOutput[1 * numBoxes + i] ?? 0;
-    const w = detectionOutput[2 * numBoxes + i] ?? 0;
-    const h = detectionOutput[3 * numBoxes + i] ?? 0;
-    let bestScore = -Infinity;
-    let bestClass = 0;
-    for (let j = 0; j < numClasses; j++) {
-      const score = detectionOutput[(4 + j) * numBoxes + i] ?? 0;
-      if (score > bestScore) {
-        bestScore = score;
-        bestClass = j;
+    var NodeInferenceEngine = class {
+      modelPath;
+      backend;
+      runtime = "onnx";
+      device;
+      session = null;
+      constructor(modelPath, backend) {
+        this.modelPath = modelPath;
+        this.backend = backend;
+        this.device = BACKEND_TO_DEVICE[backend] ?? "cpu";
+      }
+      async initialize() {
+        const ort = await Promise.resolve().then(() => __importStar(require("onnxruntime-node")));
+        const provider = BACKEND_TO_PROVIDER[this.backend] ?? "cpu";
+        const absModelPath = path.isAbsolute(this.modelPath) ? this.modelPath : path.resolve(process.cwd(), this.modelPath);
+        const sessionOptions = {
+          executionProviders: [provider]
+        };
+        this.session = await ort.InferenceSession.create(absModelPath, sessionOptions);
+      }
+      async run(input, inputShape) {
+        if (!this.session) {
+          throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
+        }
+        const ort = await Promise.resolve().then(() => __importStar(require("onnxruntime-node")));
+        const sess = this.session;
+        const inputName = sess.inputNames[0];
+        const tensor = new ort.Tensor("float32", input, [...inputShape]);
+        const feeds = { [inputName]: tensor };
+        const results = await sess.run(feeds);
+        const outputName = sess.outputNames[0];
+        const outputTensor = results[outputName];
+        return outputTensor.data;
+      }
+      async runMultiOutput(input, inputShape) {
+        if (!this.session) {
+          throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
+        }
+        const ort = await Promise.resolve().then(() => __importStar(require("onnxruntime-node")));
+        const sess = this.session;
+        const inputName = sess.inputNames[0];
+        const tensor = new ort.Tensor("float32", input, [...inputShape]);
+        const feeds = { [inputName]: tensor };
+        const results = await sess.run(feeds);
+        const out = {};
+        for (const name of sess.outputNames) {
+          out[name] = results[name].data;
+        }
+        return out;
+      }
+      async dispose() {
+        this.session = null;
       }
-    }
-    if (bestScore < confidence) continue;
-    const bbox = {
-      x: cx - w / 2,
-      y: cy - h / 2,
-      w,
-      h
     };
-    const coeffs = new Float32Array(numMaskCoeffs);
-    for (let k = 0; k < numMaskCoeffs; k++) {
-      coeffs[k] = detectionOutput[(4 + numClasses + k) * numBoxes + i] ?? 0;
-    }
-    candidates.push({ bbox, score: bestScore, classIdx: bestClass, coeffs });
+    exports2.NodeInferenceEngine = NodeInferenceEngine;
   }
-  if (candidates.length === 0) return [];
-  const keptIndices = nms(candidates, iouThreshold);
-  return keptIndices.map((idx) => {
-    const { bbox, score, classIdx, coeffs } = candidates[idx];
-    const label = labels[classIdx] ?? String(classIdx);
-    const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
-    const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
-    const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
-    const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
-    const finalBbox = { x, y, w: x2 - x, h: y2 - y };
-    const rawMask = computeRawMask(coeffs, protoOutput, numMaskCoeffs, maskHeight, maskWidth);
-    const { data: maskData, width: mW, height: mH } = cropAndThresholdMask(
-      rawMask,
-      maskHeight,
-      maskWidth,
-      bbox,
-      maskThreshold,
-      maskScale
-    );
-    return {
-      class: label,
-      originalClass: label,
-      score,
-      bbox: finalBbox,
-      mask: maskData,
-      maskWidth: mW,
-      maskHeight: mH
-    };
-  });
-}
-
-// src/shared/engine-resolver.ts
-var fs = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+});
 
-// src/shared/node-engine.ts
-var path = __toESM(require("path"));
-var BACKEND_TO_PROVIDER = {
-  cpu: "cpu",
-  coreml: "coreml",
-  cuda: "cuda",
-  tensorrt: "tensorrt",
-  dml: "dml"
-};
-var BACKEND_TO_DEVICE = {
-  cpu: "cpu",
-  coreml: "gpu-mps",
-  cuda: "gpu-cuda",
-  tensorrt: "tensorrt"
-};
-var NodeInferenceEngine = class {
-  constructor(modelPath, backend) {
-    this.modelPath = modelPath;
-    this.backend = backend;
-    this.device = BACKEND_TO_DEVICE[backend] ?? "cpu";
-  }
-  runtime = "onnx";
-  device;
-  session = null;
-  async initialize() {
-    const ort = await import("onnxruntime-node");
-    const provider = BACKEND_TO_PROVIDER[this.backend] ?? "cpu";
-    const absModelPath = path.isAbsolute(this.modelPath) ? this.modelPath : path.resolve(process.cwd(), this.modelPath);
-    const sessionOptions = {
-      executionProviders: [provider]
+// src/shared/python-engine.js
+var require_python_engine = __commonJS({
+  "src/shared/python-engine.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.PythonInferenceEngine = void 0;
+    exports2.resolvePythonBinary = resolvePythonBinary;
+    var node_child_process_1 = require("child_process");
+    var PythonInferenceEngine = class {
+      pythonPath;
+      scriptPath;
+      modelPath;
+      extraArgs;
+      runtime;
+      device;
+      process = null;
+      receiveBuffer = Buffer.alloc(0);
+      pendingResolve = null;
+      pendingReject = null;
+      constructor(pythonPath, scriptPath, runtime, modelPath, extraArgs = []) {
+        this.pythonPath = pythonPath;
+        this.scriptPath = scriptPath;
+        this.modelPath = modelPath;
+        this.extraArgs = extraArgs;
+        this.runtime = runtime;
+        const runtimeDeviceMap = {
+          onnx: "cpu",
+          coreml: "gpu-mps",
+          pytorch: "cpu",
+          openvino: "cpu",
+          tflite: "cpu"
+        };
+        this.device = runtimeDeviceMap[runtime];
+      }
+      async initialize() {
+        const args = [this.scriptPath, this.modelPath, ...this.extraArgs];
+        this.process = (0, node_child_process_1.spawn)(this.pythonPath, args, {
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        if (!this.process.stdout || !this.process.stdin) {
+          throw new Error("PythonInferenceEngine: failed to create process pipes");
+        }
+        this.process.stderr?.on("data", (chunk) => {
+          process.stderr.write(`[python-engine] ${chunk.toString()}`);
+        });
+        this.process.on("error", (err) => {
+          this.pendingReject?.(err);
+          this.pendingReject = null;
+          this.pendingResolve = null;
+        });
+        this.process.on("exit", (code) => {
+          if (code !== 0) {
+            const err = new Error(`PythonInferenceEngine: process exited with code ${code}`);
+            this.pendingReject?.(err);
+            this.pendingReject = null;
+            this.pendingResolve = null;
+          }
+        });
+        this.process.stdout.on("data", (chunk) => {
+          this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
+          this._tryReceive();
+        });
+        await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => resolve(), 2e3);
+          this.process?.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+          this.process?.on("exit", (code) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+              reject(new Error(`PythonInferenceEngine: process exited early with code ${code}`));
+            }
+          });
+        });
+      }
+      _tryReceive() {
+        if (this.receiveBuffer.length < 4)
+          return;
+        const length = this.receiveBuffer.readUInt32LE(0);
+        if (this.receiveBuffer.length < 4 + length)
+          return;
+        const jsonBytes = this.receiveBuffer.subarray(4, 4 + length);
+        this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
+        const resolve = this.pendingResolve;
+        const reject = this.pendingReject;
+        this.pendingResolve = null;
+        this.pendingReject = null;
+        if (!resolve)
+          return;
+        try {
+          const parsed = JSON.parse(jsonBytes.toString("utf8"));
+          resolve(parsed);
+        } catch (err) {
+          reject?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+      /** Send JPEG buffer, receive JSON detection results */
+      async runJpeg(jpeg) {
+        if (!this.process?.stdin) {
+          throw new Error("PythonInferenceEngine: process not initialized");
+        }
+        return new Promise((resolve, reject) => {
+          this.pendingResolve = resolve;
+          this.pendingReject = reject;
+          const lengthBuf = Buffer.allocUnsafe(4);
+          lengthBuf.writeUInt32LE(jpeg.length, 0);
+          this.process.stdin.write(Buffer.concat([lengthBuf, jpeg]));
+        });
+      }
+      /** IInferenceEngine.run — wraps runJpeg for compatibility */
+      async run(_input, _inputShape) {
+        throw new Error("PythonInferenceEngine: use runJpeg() directly \u2014 this engine operates on JPEG input");
+      }
+      /** IInferenceEngine.runMultiOutput — not supported by Python engine (operates on JPEG input) */
+      async runMultiOutput(_input, _inputShape) {
+        throw new Error("PythonInferenceEngine: runMultiOutput() is not supported \u2014 this engine operates on JPEG input");
+      }
+      async dispose() {
+        if (this.process) {
+          this.process.stdin?.end();
+          this.process.kill("SIGTERM");
+          this.process = null;
+        }
+      }
     };
-    this.session = await ort.InferenceSession.create(absModelPath, sessionOptions);
-  }
-  async run(input, inputShape) {
-    if (!this.session) {
-      throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
-    }
-    const ort = await import("onnxruntime-node");
-    const sess = this.session;
-    const inputName = sess.inputNames[0];
-    const tensor = new ort.Tensor("float32", input, [...inputShape]);
-    const feeds = { [inputName]: tensor };
-    const results = await sess.run(feeds);
-    const outputName = sess.outputNames[0];
-    const outputTensor = results[outputName];
-    return outputTensor.data;
-  }
-  async runMultiOutput(input, inputShape) {
-    if (!this.session) {
-      throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
-    }
-    const ort = await import("onnxruntime-node");
-    const sess = this.session;
-    const inputName = sess.inputNames[0];
-    const tensor = new ort.Tensor("float32", input, [...inputShape]);
-    const feeds = { [inputName]: tensor };
-    const results = await sess.run(feeds);
-    const out = {};
-    for (const name of sess.outputNames) {
-      out[name] = results[name].data;
+    exports2.PythonInferenceEngine = PythonInferenceEngine;
+    async function resolvePythonBinary(configPath, deps) {
+      if (configPath)
+        return configPath;
+      return deps.ensurePython();
     }
-    return out;
   }
-  async dispose() {
-    this.session = null;
-  }
-};
+});
 
-// 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;
-    this.scriptPath = scriptPath;
-    this.modelPath = modelPath;
-    this.extraArgs = extraArgs;
-    this.runtime = runtime;
-    const runtimeDeviceMap = {
-      onnx: "cpu",
-      coreml: "gpu-mps",
-      pytorch: "cpu",
-      openvino: "cpu",
-      tflite: "cpu"
-    };
-    this.device = runtimeDeviceMap[runtime];
-  }
-  runtime;
-  device;
-  process = null;
-  receiveBuffer = Buffer.alloc(0);
-  pendingResolve = null;
-  pendingReject = null;
-  async initialize() {
-    const args = [this.scriptPath, this.modelPath, ...this.extraArgs];
-    this.process = (0, import_node_child_process.spawn)(this.pythonPath, args, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (!this.process.stdout || !this.process.stdin) {
-      throw new Error("PythonInferenceEngine: failed to create process pipes");
-    }
-    this.process.stderr?.on("data", (chunk) => {
-      process.stderr.write(`[python-engine] ${chunk.toString()}`);
-    });
-    this.process.on("error", (err) => {
-      this.pendingReject?.(err);
-      this.pendingReject = null;
-      this.pendingResolve = null;
-    });
-    this.process.on("exit", (code) => {
-      if (code !== 0) {
-        const err = new Error(`PythonInferenceEngine: process exited with code ${code}`);
-        this.pendingReject?.(err);
-        this.pendingReject = null;
-        this.pendingResolve = null;
+// src/shared/engine-resolver.js
+var require_engine_resolver = __commonJS({
+  "src/shared/engine-resolver.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
     });
-    this.process.stdout.on("data", (chunk) => {
-      this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
-      this._tryReceive();
-    });
-    await new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => resolve2(), 2e3);
-      this.process?.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-      this.process?.on("exit", (code) => {
-        clearTimeout(timeout);
-        if (code !== 0) {
-          reject(new Error(`PythonInferenceEngine: process exited early with code ${code}`));
+    var __importStar = exports2 && exports2.__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]);
         }
-      });
-    });
-  }
-  _tryReceive() {
-    if (this.receiveBuffer.length < 4) return;
-    const length = this.receiveBuffer.readUInt32LE(0);
-    if (this.receiveBuffer.length < 4 + length) return;
-    const jsonBytes = this.receiveBuffer.subarray(4, 4 + length);
-    this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
-    const resolve2 = this.pendingResolve;
-    const reject = this.pendingReject;
-    this.pendingResolve = null;
-    this.pendingReject = null;
-    if (!resolve2) return;
-    try {
-      const parsed = JSON.parse(jsonBytes.toString("utf8"));
-      resolve2(parsed);
-    } catch (err) {
-      reject?.(err instanceof Error ? err : new Error(String(err)));
-    }
-  }
-  /** Send JPEG buffer, receive JSON detection results */
-  async runJpeg(jpeg) {
-    if (!this.process?.stdin) {
-      throw new Error("PythonInferenceEngine: process not initialized");
-    }
-    return new Promise((resolve2, reject) => {
-      this.pendingResolve = resolve2;
-      this.pendingReject = reject;
-      const lengthBuf = Buffer.allocUnsafe(4);
-      lengthBuf.writeUInt32LE(jpeg.length, 0);
-      this.process.stdin.write(Buffer.concat([lengthBuf, jpeg]));
-    });
-  }
-  /** IInferenceEngine.run — wraps runJpeg for compatibility */
-  async run(_input, _inputShape) {
-    throw new Error(
-      "PythonInferenceEngine: use runJpeg() directly \u2014 this engine operates on JPEG input"
-    );
-  }
-  /** IInferenceEngine.runMultiOutput — not supported by Python engine (operates on JPEG input) */
-  async runMultiOutput(_input, _inputShape) {
-    throw new Error(
-      "PythonInferenceEngine: runMultiOutput() is not supported \u2014 this engine operates on JPEG input"
-    );
-  }
-  async dispose() {
-    if (this.process) {
-      this.process.stdin?.end();
-      this.process.kill("SIGTERM");
-      this.process = null;
-    }
-  }
-};
-
-// src/shared/engine-resolver.ts
-var AUTO_BACKEND_PRIORITY = ["coreml", "cuda", "tensorrt", "cpu"];
-var BACKEND_TO_FORMAT = {
-  cpu: "onnx",
-  coreml: "onnx",
-  cuda: "onnx",
-  tensorrt: "onnx"
-};
-var RUNTIME_TO_FORMAT = {
-  onnx: "onnx",
-  coreml: "coreml",
-  openvino: "openvino",
-  tflite: "tflite",
-  pytorch: "pt"
-};
-function modelFilePath(modelsDir, modelEntry, format) {
-  const formatEntry = modelEntry.formats[format];
-  if (!formatEntry) {
-    throw new Error(`Model ${modelEntry.id} has no ${format} format`);
-  }
-  const urlParts = formatEntry.url.split("/");
-  const filename = urlParts[urlParts.length - 1] ?? `${modelEntry.id}.${format}`;
-  return path2.join(modelsDir, filename);
-}
-function modelExists(filePath) {
-  try {
-    return fs.existsSync(filePath);
-  } catch {
-    return false;
-  }
-}
-async function resolveEngine(options) {
-  const { runtime, backend, modelEntry, modelsDir, models } = options;
-  let selectedFormat;
-  let selectedBackend;
-  if (runtime === "auto") {
-    const available = await probeOnnxBackends();
-    let chosen = null;
-    for (const b of AUTO_BACKEND_PRIORITY) {
-      if (!available.includes(b)) continue;
-      const fmt = BACKEND_TO_FORMAT[b];
-      if (!fmt) continue;
-      if (!modelEntry.formats[fmt]) continue;
-      chosen = { backend: b, format: fmt };
-      break;
-    }
-    if (!chosen) {
-      throw new Error(
-        `resolveEngine: no compatible backend found for model ${modelEntry.id}. Available backends: ${available.join(", ")}`
-      );
-    }
-    selectedFormat = chosen.format;
-    selectedBackend = chosen.backend;
-  } else {
-    const fmt = RUNTIME_TO_FORMAT[runtime];
-    if (!fmt) {
-      throw new Error(`resolveEngine: unsupported runtime "${runtime}"`);
-    }
-    if (!modelEntry.formats[fmt]) {
-      throw new Error(
-        `resolveEngine: model ${modelEntry.id} has no ${fmt} format for runtime ${runtime}`
-      );
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveEngine = resolveEngine2;
+    exports2.probeOnnxBackends = probeOnnxBackends;
+    var fs = __importStar(require("fs"));
+    var path = __importStar(require("path"));
+    var node_engine_js_1 = require_node_engine();
+    var python_engine_js_1 = require_python_engine();
+    var AUTO_BACKEND_PRIORITY = ["coreml", "cuda", "tensorrt", "cpu"];
+    var BACKEND_TO_FORMAT = {
+      cpu: "onnx",
+      coreml: "onnx",
+      cuda: "onnx",
+      tensorrt: "onnx"
+    };
+    var RUNTIME_TO_FORMAT = {
+      onnx: "onnx",
+      coreml: "coreml",
+      openvino: "openvino",
+      tflite: "tflite",
+      pytorch: "pt"
+    };
+    function modelFilePath(modelsDir, modelEntry, format) {
+      const formatEntry = modelEntry.formats[format];
+      if (!formatEntry) {
+        throw new Error(`Model ${modelEntry.id} has no ${format} format`);
+      }
+      const urlParts = formatEntry.url.split("/");
+      const filename = urlParts[urlParts.length - 1] ?? `${modelEntry.id}.${format}`;
+      return path.join(modelsDir, filename);
     }
-    selectedFormat = fmt;
-    selectedBackend = runtime === "onnx" ? backend || "cpu" : runtime;
-  }
-  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 model service provided`
-      );
+    function modelExists(filePath) {
+      try {
+        return fs.existsSync(filePath);
+      } catch {
+        return false;
+      }
     }
-  }
-  if (selectedFormat === "onnx") {
-    const engine = new NodeInferenceEngine(modelPath, selectedBackend);
-    await engine.initialize();
-    return { engine, format: selectedFormat, modelPath };
-  }
-  const { pythonPath } = options;
-  const PYTHON_SCRIPT_MAP = {
-    coreml: "coreml_inference.py",
-    pytorch: "pytorch_inference.py",
-    openvino: "openvino_inference.py"
-  };
-  const effectiveRuntime = runtime === "auto" ? selectedBackend : runtime;
-  const scriptName = PYTHON_SCRIPT_MAP[effectiveRuntime];
-  if (scriptName && pythonPath) {
-    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")}`
-      );
+    async function resolveEngine2(options) {
+      const { runtime, backend, modelEntry, modelsDir, models } = options;
+      let selectedFormat;
+      let selectedBackend;
+      if (runtime === "auto") {
+        const available = await probeOnnxBackends();
+        let chosen = null;
+        for (const b of AUTO_BACKEND_PRIORITY) {
+          if (!available.includes(b))
+            continue;
+          const fmt = BACKEND_TO_FORMAT[b];
+          if (!fmt)
+            continue;
+          if (!modelEntry.formats[fmt])
+            continue;
+          chosen = { backend: b, format: fmt };
+          break;
+        }
+        if (!chosen) {
+          throw new Error(`resolveEngine: no compatible backend found for model ${modelEntry.id}. Available backends: ${available.join(", ")}`);
+        }
+        selectedFormat = chosen.format;
+        selectedBackend = chosen.backend;
+      } else {
+        const fmt = RUNTIME_TO_FORMAT[runtime];
+        if (!fmt) {
+          throw new Error(`resolveEngine: unsupported runtime "${runtime}"`);
+        }
+        if (!modelEntry.formats[fmt]) {
+          throw new Error(`resolveEngine: model ${modelEntry.id} has no ${fmt} format for runtime ${runtime}`);
+        }
+        selectedFormat = fmt;
+        selectedBackend = runtime === "onnx" ? backend || "cpu" : runtime;
+      }
+      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 model service provided`);
+        }
+      }
+      if (selectedFormat === "onnx") {
+        const engine = new node_engine_js_1.NodeInferenceEngine(modelPath, selectedBackend);
+        await engine.initialize();
+        return { engine, format: selectedFormat, modelPath };
+      }
+      const { pythonPath } = options;
+      const PYTHON_SCRIPT_MAP = {
+        coreml: "coreml_inference.py",
+        pytorch: "pytorch_inference.py",
+        openvino: "openvino_inference.py"
+      };
+      const effectiveRuntime = runtime === "auto" ? selectedBackend : runtime;
+      const scriptName = PYTHON_SCRIPT_MAP[effectiveRuntime];
+      if (scriptName && pythonPath) {
+        const candidates = [
+          path.join(__dirname, "../../python", scriptName),
+          path.join(__dirname, "../python", scriptName),
+          path.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 python_engine_js_1.PythonInferenceEngine(pythonPath, scriptPath, effectiveRuntime, modelPath, [
+          `--input-size=${inputSize}`,
+          `--confidence=0.25`
+        ]);
+        await engine.initialize();
+        return { engine, format: selectedFormat, modelPath };
+      }
+      const fallbackPath = modelFilePath(modelsDir, modelEntry, "onnx");
+      if (modelEntry.formats["onnx"] && modelExists(fallbackPath)) {
+        const engine = new node_engine_js_1.NodeInferenceEngine(fallbackPath, "cpu");
+        await engine.initialize();
+        return { engine, format: "onnx", modelPath: fallbackPath };
+      }
+      throw new Error(`resolveEngine: format ${selectedFormat} is not yet supported by NodeInferenceEngine, no Python runtime is available, and no ONNX fallback exists`);
     }
-    const inputSize = Math.max(modelEntry.inputSize.width, modelEntry.inputSize.height);
-    const engine = new PythonInferenceEngine(pythonPath, scriptPath, effectiveRuntime, modelPath, [
-      `--input-size=${inputSize}`,
-      `--confidence=0.25`
-    ]);
-    await engine.initialize();
-    return { engine, format: selectedFormat, modelPath };
-  }
-  const fallbackPath = modelFilePath(modelsDir, modelEntry, "onnx");
-  if (modelEntry.formats["onnx"] && modelExists(fallbackPath)) {
-    const engine = new NodeInferenceEngine(fallbackPath, "cpu");
-    await engine.initialize();
-    return { engine, format: "onnx", modelPath: fallbackPath };
-  }
-  throw new Error(
-    `resolveEngine: format ${selectedFormat} is not yet supported by NodeInferenceEngine, no Python runtime is available, and no ONNX fallback exists`
-  );
-}
-async function probeOnnxBackends() {
-  const available = ["cpu"];
-  try {
-    const ort = await import("onnxruntime-node");
-    const providers = ort.env?.webgl?.disabled !== void 0 ? ort.InferenceSession?.getAvailableProviders?.() ?? [] : [];
-    for (const p of providers) {
-      const normalized = p.toLowerCase().replace("executionprovider", "");
-      if (normalized === "coreml") available.push("coreml");
-      else if (normalized === "cuda") available.push("cuda");
-      else if (normalized === "tensorrt") available.push("tensorrt");
+    async function probeOnnxBackends() {
+      const available = ["cpu"];
+      try {
+        const ort = await Promise.resolve().then(() => __importStar(require("onnxruntime-node")));
+        const providers = ort.env?.webgl?.disabled !== void 0 ? ort.InferenceSession?.getAvailableProviders?.() ?? [] : [];
+        for (const p of providers) {
+          const normalized = p.toLowerCase().replace("executionprovider", "");
+          if (normalized === "coreml")
+            available.push("coreml");
+          else if (normalized === "cuda")
+            available.push("cuda");
+          else if (normalized === "tensorrt")
+            available.push("tensorrt");
+        }
+      } catch {
+      }
+      if (process.platform === "darwin" && !available.includes("coreml")) {
+        available.push("coreml");
+      }
+      return [...new Set(available)];
     }
-  } catch {
   }
-  if (process.platform === "darwin" && !available.includes("coreml")) {
-    available.push("coreml");
-  }
-  return [...new Set(available)];
-}
+});
 
 // src/addons/object-detection/index.ts
+var object_detection_exports = {};
+__export(object_detection_exports, {
+  default: () => ObjectDetectionAddon
+});
+module.exports = __toCommonJS(object_detection_exports);
+var import_object_detection_models = __toESM(require_object_detection_models());
+var import_segmentation_models = __toESM(require_segmentation_models());
+var import_types = require("@camstack/types");
+var import_image_utils = __toESM(require_image_utils());
+var import_yolo = __toESM(require_yolo());
+var import_yolo_seg = __toESM(require_yolo_seg());
+var import_engine_resolver = __toESM(require_engine_resolver());
 function isSegModel(modelId) {
   return modelId.includes("-seg");
 }
 var ALL_DETECTION_MODELS = [
-  ...OBJECT_DETECTION_MODELS,
-  ...SEGMENTATION_MODELS
+  ...import_object_detection_models.OBJECT_DETECTION_MODELS,
+  ...import_segmentation_models.SEGMENTATION_MODELS
 ];
 function applyClassMap(detections, classMap) {
   return detections.filter((d) => classMap.mapping[d.class] !== void 0).map((d) => ({
@@ -1285,7 +1489,7 @@ var ObjectDetectionAddon = class {
       const result = await this.engine.runJpeg(frame.data);
       const rawDets = result.detections ?? [];
       const detections2 = rawDets.map((d) => ({
-        class: this.classMapMode === "all" ? d.className : import_types3.COCO_TO_MACRO.mapping[d.className] ?? d.className,
+        class: this.classMapMode === "all" ? d.className : import_types.COCO_TO_MACRO.mapping[d.className] ?? d.className,
         originalClass: d.className,
         score: d.score,
         bbox: {
@@ -1294,7 +1498,7 @@ var ObjectDetectionAddon = class {
           w: (d.bbox[2] - d.bbox[0]) * frame.width,
           h: (d.bbox[3] - d.bbox[1]) * frame.height
         }
-      })).filter((d) => this.classMapMode === "all" || import_types3.COCO_TO_MACRO.mapping[d.originalClass] !== void 0);
+      })).filter((d) => this.classMapMode === "all" || import_types.COCO_TO_MACRO.mapping[d.originalClass] !== void 0);
       return {
         detections: detections2,
         inferenceMs: result.inferenceMs ?? Date.now() - start,
@@ -1303,7 +1507,7 @@ var ObjectDetectionAddon = class {
     }
     const { width: inputW, height: inputH } = this.modelEntry.inputSize;
     const targetSize = Math.max(inputW, inputH);
-    const lb = await letterbox(frame.data, targetSize);
+    const lb = await (0, import_image_utils.letterbox)(frame.data, targetSize);
     const numClasses = this.modelEntry.labels.length;
     const labels = this.modelEntry.labels.map((l) => l.id);
     const postprocessOpts = {
@@ -1331,7 +1535,7 @@ var ObjectDetectionAddon = class {
       const numBoxes = detectionOutput.length / (4 + numClasses + numMaskCoeffs);
       const maskHeight = 160;
       const maskWidth = 160;
-      rawDetections = yoloSegPostprocess(
+      rawDetections = (0, import_yolo_seg.yoloSegPostprocess)(
         {
           detectionOutput,
           protoOutput,
@@ -1346,9 +1550,9 @@ var ObjectDetectionAddon = class {
     } else {
       const output = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
       const numBoxes = output.length / (4 + numClasses);
-      rawDetections = yoloPostprocess(output, numClasses, numBoxes, postprocessOpts);
+      rawDetections = (0, import_yolo.yoloPostprocess)(output, numClasses, numBoxes, postprocessOpts);
     }
-    const detections = this.classMapMode === "all" ? rawDetections : applyClassMap(rawDetections, import_types3.COCO_TO_MACRO);
+    const detections = this.classMapMode === "all" ? rawDetections : applyClassMap(rawDetections, import_types.COCO_TO_MACRO);
     return {
       detections,
       inferenceMs: Date.now() - start,
@@ -1379,7 +1583,7 @@ var ObjectDetectionAddon = class {
         }
       }
     }
-    const resolved = await resolveEngine({
+    const resolved = await (0, import_engine_resolver.resolveEngine)({
       runtime,
       backend,
       modelEntry: entry,
@@ -1489,7 +1693,7 @@ var ObjectDetectionAddon = class {
     };
   }
   getClassMap() {
-    return import_types3.COCO_TO_MACRO;
+    return import_types.COCO_TO_MACRO;
   }
   getModelCatalog() {
     return [...ALL_DETECTION_MODELS];
@@ -1498,7 +1702,7 @@ var ObjectDetectionAddon = class {
     return [];
   }
   getActiveLabels() {
-    return this.classMapMode === "all" ? import_types3.COCO_80_LABELS : import_types3.MACRO_LABELS;
+    return this.classMapMode === "all" ? import_types.COCO_80_LABELS : import_types.MACRO_LABELS;
   }
   async probe() {
     return {