@camstack/addon-vision 0.1.0 → 0.1.2

package/dist/addons/segmentation-refiner/index.js

@@ -0,0 +1,1048 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/addons/segmentation-refiner/index.ts
+var segmentation_refiner_exports = {};
+__export(segmentation_refiner_exports, {
+  default: () => SegmentationRefinerAddon
+});
+module.exports = __toCommonJS(segmentation_refiner_exports);
+
+// src/catalogs/segmentation-refiner-models.ts
+var import_types2 = require("@camstack/types");
+
+// src/catalogs/object-detection-models.ts
+var import_types = require("@camstack/types");
+var HF_REPO = "camstack/camstack-models";
+var MLPACKAGE_FILES = [
+  "Manifest.json",
+  "Data/com.apple.CoreML/model.mlmodel",
+  "Data/com.apple.CoreML/weights/weight.bin"
+];
+var OBJECT_DETECTION_MODELS = [
+  // ── YOLOv8 ──────────────────────────────────────────────────────
+  {
+    id: "yolov8n",
+    name: "YOLOv8 Nano",
+    description: "YOLOv8 Nano \u2014 fastest, smallest object detection model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8n.onnx"),
+        sizeMB: 12
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8n.mlpackage"),
+        sizeMB: 6,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8n.xml"),
+        sizeMB: 7,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8n_float32.tflite"),
+        sizeMB: 12,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8s",
+    name: "YOLOv8 Small",
+    description: "YOLOv8 Small \u2014 balanced speed and accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s.onnx"),
+        sizeMB: 43
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8s.mlpackage"),
+        sizeMB: 21,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8s.xml"),
+        sizeMB: 22,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8s_float32.tflite"),
+        sizeMB: 43,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8s-relu",
+    name: "YOLOv8 Small ReLU",
+    description: "YOLOv8 Small with ReLU activation \u2014 better hardware compatibility",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s-relu.onnx"),
+        sizeMB: 43
+      }
+    }
+  },
+  {
+    id: "yolov8m",
+    name: "YOLOv8 Medium",
+    description: "YOLOv8 Medium \u2014 higher accuracy, moderate size",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8m.onnx"),
+        sizeMB: 99
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8m.mlpackage"),
+        sizeMB: 49,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8m.xml"),
+        sizeMB: 50,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8m_float32.tflite"),
+        sizeMB: 99,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8l",
+    name: "YOLOv8 Large",
+    description: "YOLOv8 Large \u2014 high-accuracy large model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8l.onnx"),
+        sizeMB: 167
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8l.mlpackage"),
+        sizeMB: 83,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8l.xml"),
+        sizeMB: 84,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov8x",
+    name: "YOLOv8 Extra-Large",
+    description: "YOLOv8 Extra-Large \u2014 maximum accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8x.onnx"),
+        sizeMB: 260
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8x.mlpackage"),
+        sizeMB: 130,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8x.xml"),
+        sizeMB: 131,
+        runtimes: ["python"]
+      }
+    }
+  },
+  // ── YOLOv9 ──────────────────────────────────────────────────────
+  {
+    id: "yolov9t",
+    name: "YOLOv9 Tiny",
+    description: "YOLOv9 Tiny \u2014 ultra-lightweight next-gen detector",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+        sizeMB: 8
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+        sizeMB: 4,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
+        sizeMB: 6,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9t_float32.tflite"),
+        sizeMB: 8,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov9s",
+    name: "YOLOv9 Small",
+    description: "YOLOv9 Small \u2014 improved efficiency over YOLOv8s",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+        sizeMB: 28
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+        sizeMB: 14,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
+        sizeMB: 16,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9s_float32.tflite"),
+        sizeMB: 28,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolov9c",
+    name: "YOLOv9 C",
+    description: "YOLOv9 C \u2014 high-accuracy compact model",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+        sizeMB: 97
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+        sizeMB: 48,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
+        sizeMB: 49,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9c_float32.tflite"),
+        sizeMB: 97,
+        runtimes: ["python"]
+      }
+    }
+  },
+  // ── YOLO11 ────────────────────────────────────────────────────
+  {
+    id: "yolo11n",
+    name: "YOLO11 Nano",
+    description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 detection model (mAP 39.5)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11n.onnx"),
+        sizeMB: 10
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11n.mlpackage"),
+        sizeMB: 5,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11n.xml"),
+        sizeMB: 5,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11n_float32.tflite"),
+        sizeMB: 10,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11s",
+    name: "YOLO11 Small",
+    description: "YOLO11 Small \u2014 balanced speed and accuracy (mAP 47.0)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11s.onnx"),
+        sizeMB: 36
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11s.mlpackage"),
+        sizeMB: 18,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11s.xml"),
+        sizeMB: 18,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11s_float32.tflite"),
+        sizeMB: 36,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11m",
+    name: "YOLO11 Medium",
+    description: "YOLO11 Medium \u2014 higher accuracy, moderate size (mAP 51.5)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11m.onnx"),
+        sizeMB: 77
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11m.mlpackage"),
+        sizeMB: 39,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11m.xml"),
+        sizeMB: 39,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11m_float32.tflite"),
+        sizeMB: 77,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11l",
+    name: "YOLO11 Large",
+    description: "YOLO11 Large \u2014 high-accuracy large model (mAP 53.4)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11l.onnx"),
+        sizeMB: 97
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11l.mlpackage"),
+        sizeMB: 49,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11l.xml"),
+        sizeMB: 49,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11l_float32.tflite"),
+        sizeMB: 97,
+        runtimes: ["python"]
+      }
+    }
+  },
+  {
+    id: "yolo11x",
+    name: "YOLO11 Extra-Large",
+    description: "YOLO11 Extra-Large \u2014 maximum accuracy (mAP 54.7)",
+    inputSize: { width: 640, height: 640 },
+    labels: import_types.COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11x.onnx"),
+        sizeMB: 218
+      },
+      coreml: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/coreml/camstack-yolo11x.mlpackage"),
+        sizeMB: 109,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      },
+      openvino: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11x.xml"),
+        sizeMB: 109,
+        runtimes: ["python"]
+      },
+      tflite: {
+        url: (0, import_types.hfModelUrl)(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11x_float32.tflite"),
+        sizeMB: 218,
+        runtimes: ["python"]
+      }
+    }
+  }
+];
+
+// src/catalogs/segmentation-refiner-models.ts
+var HF_REPO2 = "camstack/camstack-models";
+var hf = (path3) => (0, import_types2.hfModelUrl)(HF_REPO2, path3);
+var MASK_LABELS = [
+  { id: "mask", name: "Segmentation Mask" }
+];
+var SEGMENTATION_REFINER_MODELS = [
+  {
+    id: "u2netp",
+    name: "U2-Net Portable",
+    description: "U2-Net-P \u2014 ultra-lightweight salient object segmentation (4.7 MB), no prompt needed",
+    inputSize: { width: 320, height: 320 },
+    labels: MASK_LABELS,
+    formats: {
+      onnx: { url: hf("segmentationRefiner/u2netp/onnx/camstack-u2netp.onnx"), sizeMB: 5 },
+      coreml: {
+        url: hf("segmentationRefiner/u2netp/coreml/camstack-u2netp.mlpackage"),
+        sizeMB: 3,
+        isDirectory: true,
+        files: MLPACKAGE_FILES,
+        runtimes: ["python"]
+      }
+      // OpenVINO: not yet converted
+    }
+  }
+];
+
+// src/shared/image-utils.ts
+var import_sharp = __toESM(require("sharp"));
+async function cropRegion(jpeg, roi) {
+  return (0, import_sharp.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();
+}
+async function resizeAndNormalize(jpeg, targetWidth, targetHeight, normalization, layout) {
+  const { data } = await (0, import_sharp.default)(jpeg).resize(targetWidth, targetHeight, { fit: "fill" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const numPixels = targetWidth * targetHeight;
+  const float32 = new Float32Array(3 * numPixels);
+  const mean = [0.485, 0.456, 0.406];
+  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;
+}
+
+// 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]
+    };
+    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;
+    }
+    return out;
+  }
+  async dispose() {
+    this.session = null;
+  }
+};
+
+// src/shared/python-engine.ts
+var import_node_child_process = require("child_process");
+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;
+      }
+    });
+    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}`));
+        }
+      });
+    });
+  }
+  _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}`
+      );
+    }
+    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 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")}`
+      );
+    }
+    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");
+    }
+  } catch {
+  }
+  if (process.platform === "darwin" && !available.includes("coreml")) {
+    available.push("coreml");
+  }
+  return [...new Set(available)];
+}
+
+// src/addons/segmentation-refiner/index.ts
+var MASK_LABEL = { id: "mask", name: "Segmentation Mask" };
+var MASK_LABELS2 = [MASK_LABEL];
+var MASK_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+var DEFAULT_MASK_THRESHOLD = 0.5;
+var SegmentationRefinerAddon = class {
+  id = "segmentation-refiner";
+  slot = "refiner";
+  inputClasses = null;
+  outputClasses = ["mask:*"];
+  slotPriority = 0;
+  requiredSteps = [];
+  manifest = {
+    id: "segmentation-refiner",
+    name: "Segmentation Refiner",
+    version: "0.1.0",
+    description: "Post-detection segmentation \u2014 refines bboxes into precise binary masks using U2-Net-P or EdgeSAM",
+    slot: "refiner",
+    outputClasses: ["mask:*"],
+    supportsCustomModels: false,
+    mayRequirePython: false,
+    defaultConfig: {
+      modelId: "u2netp",
+      runtime: "node",
+      backend: "cpu",
+      maskThreshold: DEFAULT_MASK_THRESHOLD
+    }
+  };
+  engine = null;
+  modelEntry;
+  maskThreshold = DEFAULT_MASK_THRESHOLD;
+  resolvedConfig = null;
+  ctx = null;
+  getModelRequirements() {
+    return SEGMENTATION_REFINER_MODELS.map((m) => ({
+      modelId: m.id,
+      name: m.name,
+      minRAM_MB: 256,
+      accuracyScore: 80,
+      formats: Object.keys(m.formats)
+    }));
+  }
+  configure(config) {
+    this.resolvedConfig = config;
+  }
+  async initialize(ctx) {
+    this.ctx = ctx;
+    const cfg = ctx.addonConfig;
+    const modelId = cfg["modelId"] ?? this.resolvedConfig?.modelId ?? "u2netp";
+    this.maskThreshold = cfg["maskThreshold"] ?? DEFAULT_MASK_THRESHOLD;
+    const entry = SEGMENTATION_REFINER_MODELS.find((m) => m.id === modelId);
+    if (!entry) {
+      throw new Error(`SegmentationRefinerAddon: unknown modelId "${modelId}"`);
+    }
+    this.modelEntry = entry;
+  }
+  async refine(input) {
+    if (!this.engine) await this.ensureEngine();
+    const start = Date.now();
+    const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+    const crop = await cropRegion(input.frame.data, input.roi);
+    const normalized = await resizeAndNormalize(crop, inputW, inputH, "zero-one", "nchw");
+    const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+    const maskSize = inputW * inputH;
+    const mask = new Uint8Array(maskSize);
+    const threshold = this.maskThreshold;
+    for (let i = 0; i < maskSize; i++) {
+      mask[i] = (rawOutput[i] ?? 0) > threshold ? 255 : 0;
+    }
+    return {
+      mask: Buffer.from(mask).toString("base64"),
+      maskWidth: inputW,
+      maskHeight: inputH,
+      inferenceMs: Date.now() - start,
+      modelId: this.modelEntry.id
+    };
+  }
+  async ensureEngine() {
+    const config = this.resolvedConfig;
+    const modelId = config?.modelId ?? this.modelEntry.id;
+    const runtime = config?.runtime === "python" ? "coreml" : config?.runtime === "node" ? "onnx" : "auto";
+    const backend = config?.backend ?? "cpu";
+    const format = config?.format ?? "onnx";
+    const entry = SEGMENTATION_REFINER_MODELS.find((m) => m.id === modelId) ?? this.modelEntry;
+    this.modelEntry = entry;
+    const modelsDir = this.ctx.models?.getModelsDir() ?? this.ctx.locationPaths.models;
+    if (this.ctx.models) {
+      await this.ctx.models.ensure(modelId, format);
+    }
+    const resolved = await resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir,
+      models: this.ctx.models
+    });
+    this.engine = resolved.engine;
+  }
+  async shutdown() {
+    await this.engine?.dispose();
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "model",
+          title: "Model",
+          columns: 1,
+          fields: [
+            {
+              key: "modelId",
+              label: "Model",
+              type: "model-selector",
+              catalog: [...SEGMENTATION_REFINER_MODELS],
+              allowCustom: false,
+              allowConversion: false,
+              acceptFormats: ["onnx", "coreml", "openvino"],
+              requiredMetadata: ["inputSize", "labels"],
+              outputFormatHint: "segmentation"
+            }
+          ]
+        },
+        {
+          id: "runtime",
+          title: "Runtime",
+          columns: 2,
+          fields: [
+            {
+              key: "runtime",
+              label: "Runtime",
+              type: "select",
+              options: [
+                { value: "auto", label: "Auto" },
+                { value: "onnx", label: "ONNX Runtime" },
+                { value: "coreml", label: "CoreML (Apple)" },
+                { value: "openvino", label: "OpenVINO (Intel)" }
+              ]
+            },
+            {
+              key: "backend",
+              label: "Backend",
+              type: "select",
+              showWhen: { field: "runtime", equals: "onnx" },
+              options: [
+                { value: "auto", label: "Auto" },
+                { value: "cpu", label: "CPU" },
+                { value: "coreml", label: "CoreML" },
+                { value: "cuda", label: "CUDA (NVIDIA)" }
+              ]
+            }
+          ]
+        },
+        {
+          id: "thresholds",
+          title: "Segmentation Settings",
+          columns: 1,
+          fields: [
+            {
+              key: "maskThreshold",
+              label: "Mask Threshold",
+              type: "slider",
+              min: 0.1,
+              max: 0.9,
+              step: 0.05,
+              default: DEFAULT_MASK_THRESHOLD
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return MASK_CLASS_MAP;
+  }
+  getModelCatalog() {
+    return [...SEGMENTATION_REFINER_MODELS];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return MASK_LABELS2;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: this.engine?.runtime ?? "onnx",
+      device: this.engine?.device ?? "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+//# sourceMappingURL=index.js.map