@camstack/addon-vision 0.1.0

package/dist/chunk-AYBFB7ID.mjs

@@ -0,0 +1,763 @@
+import {
+  nms,
+  yoloPostprocess
+} from "./chunk-KUO2BVFY.mjs";
+import {
+  letterbox
+} from "./chunk-6OR5TE7A.mjs";
+import {
+  resolveEngine
+} from "./chunk-LPI42WL6.mjs";
+
+// src/catalogs/object-detection-models.ts
+import { hfModelUrl, COCO_80_LABELS } from "@camstack/types";
+var HF_REPO = "camstack/camstack-models";
+var OBJECT_DETECTION_MODELS = [
+  {
+    id: "yolov8n",
+    name: "YOLOv8 Nano",
+    description: "YOLOv8 Nano \u2014 fastest, smallest object detection model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8n.onnx"),
+        sizeMB: 12
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8n.mlpackage"),
+        sizeMB: 6
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8n.xml"),
+        sizeMB: 7
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8n_float32.tflite"),
+        sizeMB: 12
+      }
+    }
+  },
+  {
+    id: "yolov8s",
+    name: "YOLOv8 Small",
+    description: "YOLOv8 Small \u2014 balanced speed and accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8s.onnx"),
+        sizeMB: 43
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8s.mlpackage"),
+        sizeMB: 21
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8s.xml"),
+        sizeMB: 22
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8s_float32.tflite"),
+        sizeMB: 43
+      }
+    }
+  },
+  {
+    id: "yolov8m",
+    name: "YOLOv8 Medium",
+    description: "YOLOv8 Medium \u2014 higher accuracy, moderate size",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/onnx/camstack-yolov8m.onnx"),
+        sizeMB: 99
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/coreml/camstack-yolov8m.mlpackage"),
+        sizeMB: 49
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/openvino/camstack-yolov8m.xml"),
+        sizeMB: 50
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov8/tflite/camstack-yolov8m_float32.tflite"),
+        sizeMB: 99
+      }
+    }
+  },
+  {
+    id: "yolov9t",
+    name: "YOLOv9 Tiny",
+    description: "YOLOv9 Tiny \u2014 ultra-lightweight next-gen detector",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9t.onnx"),
+        sizeMB: 8
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9t.mlpackage"),
+        sizeMB: 4
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9t.xml"),
+        sizeMB: 6
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9t_float32.tflite"),
+        sizeMB: 8
+      }
+    }
+  },
+  {
+    id: "yolov9s",
+    name: "YOLOv9 Small",
+    description: "YOLOv9 Small \u2014 improved efficiency over YOLOv8s",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9s.onnx"),
+        sizeMB: 28
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9s.mlpackage"),
+        sizeMB: 14
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9s.xml"),
+        sizeMB: 16
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9s_float32.tflite"),
+        sizeMB: 28
+      }
+    }
+  },
+  {
+    id: "yolov9c",
+    name: "YOLOv9 C",
+    description: "YOLOv9 C \u2014 high-accuracy compact model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/onnx/camstack-yolov9c.onnx"),
+        sizeMB: 97
+      },
+      coreml: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/coreml/camstack-yolov9c.mlpackage"),
+        sizeMB: 48
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/openvino/camstack-yolov9c.xml"),
+        sizeMB: 49
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolov9/tflite/camstack-yolov9c_float32.tflite"),
+        sizeMB: 97
+      }
+    }
+  },
+  // YOLO11 — no CoreML (coremltools incompatible)
+  {
+    id: "yolo11n",
+    name: "YOLO11 Nano",
+    description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 detection model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11n.onnx"),
+        sizeMB: 10
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11n.xml"),
+        sizeMB: 5.4
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11n_float32.tflite"),
+        sizeMB: 10
+      }
+    }
+  },
+  {
+    id: "yolo11s",
+    name: "YOLO11 Small",
+    description: "YOLO11 Small \u2014 balanced speed and accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11s.onnx"),
+        sizeMB: 36
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11s.xml"),
+        sizeMB: 18
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11s_float32.tflite"),
+        sizeMB: 36
+      }
+    }
+  },
+  {
+    id: "yolo11m",
+    name: "YOLO11 Medium",
+    description: "YOLO11 Medium \u2014 higher accuracy, moderate size",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11m.onnx"),
+        sizeMB: 77
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11m.xml"),
+        sizeMB: 39
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11m_float32.tflite"),
+        sizeMB: 77
+      }
+    }
+  },
+  {
+    id: "yolo11l",
+    name: "YOLO11 Large",
+    description: "YOLO11 Large \u2014 high-accuracy large model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11l.onnx"),
+        sizeMB: 97
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11l.xml"),
+        sizeMB: 49
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11l_float32.tflite"),
+        sizeMB: 97
+      }
+    }
+  },
+  {
+    id: "yolo11x",
+    name: "YOLO11 Extra-Large",
+    description: "YOLO11 Extra-Large \u2014 maximum accuracy",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS,
+    formats: {
+      onnx: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/onnx/camstack-yolo11x.onnx"),
+        sizeMB: 218
+      },
+      openvino: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/openvino/camstack-yolo11x.xml"),
+        sizeMB: 109
+      },
+      tflite: {
+        url: hfModelUrl(HF_REPO, "objectDetection/yolo11/tflite/camstack-yolo11x_float32.tflite"),
+        sizeMB: 218
+      }
+    }
+  }
+];
+
+// src/catalogs/segmentation-models.ts
+import { hfModelUrl as hfModelUrl2, COCO_80_LABELS as COCO_80_LABELS2 } from "@camstack/types";
+var HF_REPO2 = "camstack/camstack-models";
+var SEGMENTATION_MODELS = [
+  // YOLO11-seg — no CoreML (coremltools incompatible)
+  {
+    id: "yolo11n-seg",
+    name: "YOLO11 Nano Segmentation",
+    description: "YOLO11 Nano \u2014 fastest, smallest YOLO11 instance segmentation model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11n-seg.onnx"),
+        sizeMB: 11
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11n-seg.xml"),
+        sizeMB: 6
+      }
+    }
+  },
+  {
+    id: "yolo11s-seg",
+    name: "YOLO11 Small Segmentation",
+    description: "YOLO11 Small \u2014 balanced speed and accuracy for instance segmentation",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11s-seg.onnx"),
+        sizeMB: 39
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11s-seg.xml"),
+        sizeMB: 20
+      }
+    }
+  },
+  {
+    id: "yolo11m-seg",
+    name: "YOLO11 Medium Segmentation",
+    description: "YOLO11 Medium \u2014 higher accuracy instance segmentation",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/onnx/camstack-yolo11m-seg.onnx"),
+        sizeMB: 86
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolo11-seg/openvino/camstack-yolo11m-seg.xml"),
+        sizeMB: 43
+      }
+    }
+  },
+  // YOLOv8-seg — CoreML available
+  {
+    id: "yolov8n-seg",
+    name: "YOLOv8 Nano Segmentation",
+    description: "YOLOv8 Nano \u2014 fastest, smallest YOLOv8 instance segmentation model",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8n-seg.onnx"),
+        sizeMB: 13
+      },
+      coreml: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8n-seg.mlpackage"),
+        sizeMB: 7
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8n-seg.xml"),
+        sizeMB: 7
+      }
+    }
+  },
+  {
+    id: "yolov8s-seg",
+    name: "YOLOv8 Small Segmentation",
+    description: "YOLOv8 Small \u2014 balanced speed and accuracy for instance segmentation",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8s-seg.onnx"),
+        sizeMB: 45
+      },
+      coreml: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8s-seg.mlpackage"),
+        sizeMB: 23
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8s-seg.xml"),
+        sizeMB: 23
+      }
+    }
+  },
+  {
+    id: "yolov8m-seg",
+    name: "YOLOv8 Medium Segmentation",
+    description: "YOLOv8 Medium \u2014 higher accuracy instance segmentation",
+    inputSize: { width: 640, height: 640 },
+    labels: COCO_80_LABELS2,
+    formats: {
+      onnx: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/onnx/camstack-yolov8m-seg.onnx"),
+        sizeMB: 104
+      },
+      coreml: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/coreml/camstack-yolov8m-seg.mlpackage"),
+        sizeMB: 52
+      },
+      openvino: {
+        url: hfModelUrl2(HF_REPO2, "segmentation/yolov8-seg/openvino/camstack-yolov8m-seg.xml"),
+        sizeMB: 53
+      }
+    }
+  }
+];
+
+// src/addons/object-detection/index.ts
+import { COCO_TO_MACRO, MACRO_LABELS, COCO_80_LABELS as COCO_80_LABELS3 } from "@camstack/types";
+
+// 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;
+      }
+    }
+    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 = 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/addons/object-detection/index.ts
+function isSegModel(modelId) {
+  return modelId.includes("-seg");
+}
+var ALL_DETECTION_MODELS = [
+  ...OBJECT_DETECTION_MODELS,
+  ...SEGMENTATION_MODELS
+];
+function applyClassMap(detections, classMap) {
+  return detections.filter((d) => classMap.mapping[d.class] !== void 0).map((d) => ({
+    ...d,
+    originalClass: d.class,
+    class: classMap.mapping[d.class]
+  }));
+}
+var ObjectDetectionAddon = class {
+  id = "object-detection";
+  slot = "detector";
+  inputClasses = null;
+  outputClasses = ["person", "vehicle", "animal"];
+  slotPriority = 0;
+  manifest = {
+    id: "object-detection",
+    name: "Object Detection",
+    version: "0.1.0",
+    description: "YOLO-based object detection \u2014 detects persons, vehicles, and animals",
+    packageName: "@camstack/addon-vision",
+    slot: "detector",
+    inputClasses: void 0,
+    outputClasses: ["person", "vehicle", "animal"],
+    supportsCustomModels: true,
+    mayRequirePython: false,
+    defaultConfig: {
+      modelId: "yolov8n",
+      runtime: "auto",
+      backend: "cpu",
+      confidence: 0.5,
+      iouThreshold: 0.45,
+      classMapMode: "macro"
+    }
+  };
+  engine;
+  modelEntry;
+  confidence = 0.5;
+  iouThreshold = 0.45;
+  classMapMode = "macro";
+  async initialize(ctx) {
+    const cfg = ctx.addonConfig;
+    const modelId = cfg["modelId"] ?? "yolov8n";
+    const runtime = cfg["runtime"] ?? "auto";
+    const backend = cfg["backend"] ?? "cpu";
+    this.confidence = cfg["confidence"] ?? 0.5;
+    this.iouThreshold = cfg["iouThreshold"] ?? 0.45;
+    this.classMapMode = cfg["classMapMode"] ?? "macro";
+    const entry = ALL_DETECTION_MODELS.find((m) => m.id === modelId);
+    if (!entry) {
+      throw new Error(`ObjectDetectionAddon: unknown modelId "${modelId}"`);
+    }
+    this.modelEntry = entry;
+    const resolved = await resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir: ctx.locationPaths.models
+    });
+    this.engine = resolved.engine;
+  }
+  async detect(frame) {
+    const start = Date.now();
+    const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+    const targetSize = Math.max(inputW, inputH);
+    const lb = await letterbox(frame.data, targetSize);
+    const numClasses = this.modelEntry.labels.length;
+    const labels = this.modelEntry.labels.map((l) => l.id);
+    const postprocessOpts = {
+      confidence: this.confidence,
+      iouThreshold: this.iouThreshold,
+      labels,
+      scale: lb.scale,
+      padX: lb.padX,
+      padY: lb.padY,
+      originalWidth: lb.originalWidth,
+      originalHeight: lb.originalHeight
+    };
+    let rawDetections;
+    if (isSegModel(this.modelEntry.id)) {
+      const outputs = await this.engine.runMultiOutput(lb.data, [1, 3, targetSize, targetSize]);
+      const outputNames = Object.keys(outputs);
+      if (outputNames.length < 2) {
+        throw new Error(
+          `ObjectDetectionAddon: seg model "${this.modelEntry.id}" returned ${outputNames.length} output(s); expected 2`
+        );
+      }
+      const detectionOutput = outputs[outputNames[0]];
+      const protoOutput = outputs[outputNames[1]];
+      const numMaskCoeffs = 32;
+      const numBoxes = detectionOutput.length / (4 + numClasses + numMaskCoeffs);
+      const maskHeight = 160;
+      const maskWidth = 160;
+      rawDetections = yoloSegPostprocess(
+        {
+          detectionOutput,
+          protoOutput,
+          numClasses,
+          numBoxes,
+          numMaskCoeffs,
+          maskHeight,
+          maskWidth
+        },
+        postprocessOpts
+      );
+    } else {
+      const output = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+      const numBoxes = output.length / (4 + numClasses);
+      rawDetections = yoloPostprocess(output, numClasses, numBoxes, postprocessOpts);
+    }
+    const detections = this.classMapMode === "all" ? rawDetections : applyClassMap(rawDetections, COCO_TO_MACRO);
+    return {
+      detections,
+      inferenceMs: Date.now() - start,
+      modelId: this.modelEntry.id
+    };
+  }
+  async shutdown() {
+    await this.engine?.dispose();
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "model",
+          title: "Model",
+          columns: 2,
+          fields: [
+            {
+              key: "modelId",
+              label: "Model",
+              type: "model-selector",
+              catalog: [...ALL_DETECTION_MODELS],
+              allowCustom: true,
+              allowConversion: true,
+              acceptFormats: ["onnx", "coreml", "openvino", "tflite"],
+              requiredMetadata: ["inputSize", "labels", "outputFormat"],
+              outputFormatHint: "yolo"
+            }
+          ]
+        },
+        {
+          id: "runtime",
+          title: "Runtime",
+          columns: 2,
+          fields: [
+            {
+              key: "runtime",
+              label: "Runtime",
+              type: "select",
+              options: [
+                { value: "auto", label: "Auto (recommended)" },
+                { value: "onnx", label: "ONNX Runtime" },
+                { value: "coreml", label: "CoreML (Apple)" },
+                { value: "openvino", label: "OpenVINO (Intel)" }
+              ]
+            },
+            {
+              key: "backend",
+              label: "Backend",
+              type: "select",
+              dependsOn: { runtime: "onnx" },
+              options: [
+                { value: "cpu", label: "CPU" },
+                { value: "coreml", label: "CoreML" },
+                { value: "cuda", label: "CUDA (NVIDIA)" },
+                { value: "tensorrt", label: "TensorRT (NVIDIA)" }
+              ]
+            }
+          ]
+        },
+        {
+          id: "thresholds",
+          title: "Detection Thresholds",
+          columns: 2,
+          fields: [
+            {
+              key: "confidence",
+              label: "Confidence Threshold",
+              type: "slider",
+              min: 0.1,
+              max: 1,
+              step: 0.05,
+              default: 0.5
+            },
+            {
+              key: "iouThreshold",
+              label: "IoU Threshold (NMS)",
+              type: "slider",
+              min: 0.1,
+              max: 1,
+              step: 0.05,
+              default: 0.45
+            }
+          ]
+        },
+        {
+          id: "classmap",
+          title: "Class Mapping",
+          columns: 1,
+          fields: [
+            {
+              key: "classMapMode",
+              label: "Output classes",
+              type: "select",
+              options: [
+                { value: "macro", label: "Macro (person / vehicle / animal)" },
+                { value: "all", label: "All COCO classes (80)" }
+              ]
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return COCO_TO_MACRO;
+  }
+  getModelCatalog() {
+    return [...ALL_DETECTION_MODELS];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return this.classMapMode === "all" ? COCO_80_LABELS3 : MACRO_LABELS;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: this.engine?.runtime ?? "onnx",
+      device: this.engine?.device ?? "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+
+export {
+  OBJECT_DETECTION_MODELS,
+  SEGMENTATION_MODELS,
+  ObjectDetectionAddon
+};
+//# sourceMappingURL=chunk-AYBFB7ID.mjs.map