@camstack/vision 0.1.0

package/dist/addons/camera-native-detection/index.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/addons/camera-native-detection/index.ts
+var camera_native_detection_exports = {};
+__export(camera_native_detection_exports, {
+  default: () => CameraNativeDetectionAddon
+});
+module.exports = __toCommonJS(camera_native_detection_exports);
+var NATIVE_LABELS = [
+  { id: "person", name: "Person" },
+  { id: "vehicle", name: "Vehicle" },
+  { id: "motion", name: "Motion" },
+  { id: "face", name: "Face" }
+];
+var NATIVE_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+var CameraNativeDetectionAddon = class {
+  id = "camera-native-detection";
+  slot = "detector";
+  inputClasses = null;
+  outputClasses = ["person", "vehicle", "motion", "face"];
+  slotPriority = 5;
+  manifest = {
+    id: "camera-native-detection",
+    name: "Camera Native Detection",
+    version: "0.1.0",
+    description: "Passthrough adapter for camera-native events (Frigate, Scrypted, ONVIF) \u2014 no inference engine",
+    packageName: "@camstack/vision",
+    slot: "detector",
+    inputClasses: void 0,
+    outputClasses: ["person", "vehicle", "motion", "face"],
+    supportsCustomModels: false,
+    mayRequirePython: false,
+    defaultConfig: {}
+  };
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async initialize(_ctx) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async detect(_frame) {
+    return {
+      detections: [],
+      inferenceMs: 0,
+      modelId: "camera-native"
+    };
+  }
+  async shutdown() {
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "info",
+          title: "Camera Native Detection",
+          description: "This addon forwards detections from native camera events (Frigate webhooks, Scrypted push notifications, ONVIF events). No configuration required.",
+          fields: []
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return NATIVE_CLASS_MAP;
+  }
+  getModelCatalog() {
+    return [];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return NATIVE_LABELS;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: "onnx",
+      // no runtime used; satisfies the type
+      device: "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+//# sourceMappingURL=index.js.map

package/dist/addons/camera-native-detection/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/addons/camera-native-detection/index.ts"],"sourcesContent":["import type {\n  IDetectorProvider,\n  IDetectionAddon,\n  AddonManifest,\n  AddonContext,\n  FrameInput,\n  DetectorOutput,\n  ConfigUISchema,\n  ClassMapDefinition,\n  ProbeResult,\n  ModelCatalogEntry,\n  DetectionModel,\n  LabelDefinition,\n} from '@camstack/types'\n\n// Labels reported by cameras natively (a superset across manufacturers)\nconst NATIVE_LABELS: readonly LabelDefinition[] = [\n  { id: 'person', name: 'Person' },\n  { id: 'vehicle', name: 'Vehicle' },\n  { id: 'motion', name: 'Motion' },\n  { id: 'face', name: 'Face' },\n] as const\n\nconst NATIVE_CLASS_MAP: ClassMapDefinition = { mapping: {}, preserveOriginal: true }\n\n/**\n * CameraNativeDetectionAddon\n *\n * A stub detector that wraps native camera event subscriptions (e.g. Frigate / Scrypted\n * webhooks). The detect() method always returns empty — real detections are delivered\n * asynchronously via external event subscriptions which should populate the pipeline\n * from outside this addon's detect() call.\n *\n * This addon exists so the pipeline can declare a 'detector' slot backed by camera events\n * without requiring any inference model.\n */\nexport default class CameraNativeDetectionAddon implements IDetectorProvider, IDetectionAddon {\n  readonly id = 'camera-native-detection'\n  readonly slot = 'detector' as const\n  readonly inputClasses: readonly string[] | null = null\n  readonly outputClasses = ['person', 'vehicle', 'motion', 'face'] as const\n  readonly slotPriority = 5\n  readonly manifest: AddonManifest = {\n    id: 'camera-native-detection',\n    name: 'Camera Native Detection',\n    version: '0.1.0',\n    description:\n      'Passthrough adapter for camera-native events (Frigate, Scrypted, ONVIF) — no inference engine',\n    packageName: '@camstack/vision',\n    slot: 'detector',\n    inputClasses: undefined,\n    outputClasses: ['person', 'vehicle', 'motion', 'face'],\n    supportsCustomModels: false,\n    mayRequirePython: false,\n    defaultConfig: {},\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async initialize(_ctx: AddonContext): Promise<void> {\n    // No engine to initialize — events come from external subscriptions\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async detect(_frame: FrameInput): Promise<DetectorOutput> {\n    // Real detections are delivered via event subscriptions, not through detect().\n    // This method intentionally returns empty.\n    return {\n      detections: [],\n      inferenceMs: 0,\n      modelId: 'camera-native',\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    // Nothing to tear down\n  }\n\n  getConfigSchema(): ConfigUISchema {\n    return {\n      sections: [\n        {\n          id: 'info',\n          title: 'Camera Native Detection',\n          description:\n            'This addon forwards detections from native camera events (Frigate webhooks, ' +\n            'Scrypted push notifications, ONVIF events). No configuration required.',\n          fields: [],\n        },\n      ],\n    }\n  }\n\n  getClassMap(): ClassMapDefinition {\n    return NATIVE_CLASS_MAP\n  }\n\n  getModelCatalog(): ModelCatalogEntry[] {\n    return []\n  }\n\n  getAvailableModels(): DetectionModel[] {\n    return []\n  }\n\n  getActiveLabels(): readonly LabelDefinition[] {\n    return NATIVE_LABELS\n  }\n\n  async probe(): Promise<ProbeResult> {\n    return {\n      available: true,\n      runtime: 'onnx', // no runtime used; satisfies the type\n      device: 'cpu',\n      capabilities: ['fp32'],\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,IAAM,gBAA4C;AAAA,EAChD,EAAE,IAAI,UAAU,MAAM,SAAS;AAAA,EAC/B,EAAE,IAAI,WAAW,MAAM,UAAU;AAAA,EACjC,EAAE,IAAI,UAAU,MAAM,SAAS;AAAA,EAC/B,EAAE,IAAI,QAAQ,MAAM,OAAO;AAC7B;AAEA,IAAM,mBAAuC,EAAE,SAAS,CAAC,GAAG,kBAAkB,KAAK;AAanF,IAAqB,6BAArB,MAA8F;AAAA,EACnF,KAAK;AAAA,EACL,OAAO;AAAA,EACP,eAAyC;AAAA,EACzC,gBAAgB,CAAC,UAAU,WAAW,UAAU,MAAM;AAAA,EACtD,eAAe;AAAA,EACf,WAA0B;AAAA,IACjC,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,SAAS;AAAA,IACT,aACE;AAAA,IACF,aAAa;AAAA,IACb,MAAM;AAAA,IACN,cAAc;AAAA,IACd,eAAe,CAAC,UAAU,WAAW,UAAU,MAAM;AAAA,IACrD,sBAAsB;AAAA,IACtB,kBAAkB;AAAA,IAClB,eAAe,CAAC;AAAA,EAClB;AAAA;AAAA,EAGA,MAAM,WAAW,MAAmC;AAAA,EAEpD;AAAA;AAAA,EAGA,MAAM,OAAO,QAA6C;AAGxD,WAAO;AAAA,MACL,YAAY,CAAC;AAAA,MACb,aAAa;AAAA,MACb,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EAEA,MAAM,WAA0B;AAAA,EAEhC;AAAA,EAEA,kBAAkC;AAChC,WAAO;AAAA,MACL,UAAU;AAAA,QACR;AAAA,UACE,IAAI;AAAA,UACJ,OAAO;AAAA,UACP,aACE;AAAA,UAEF,QAAQ,CAAC;AAAA,QACX;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,cAAkC;AAChC,WAAO;AAAA,EACT;AAAA,EAEA,kBAAuC;AACrC,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,qBAAuC;AACrC,WAAO,CAAC;AAAA,EACV;AAAA,EAEA,kBAA8C;AAC5C,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,QAA8B;AAClC,WAAO;AAAA,MACL,WAAW;AAAA,MACX,SAAS;AAAA;AAAA,MACT,QAAQ;AAAA,MACR,cAAc,CAAC,MAAM;AAAA,IACvB;AAAA,EACF;AACF;","names":[]}

package/dist/addons/camera-native-detection/index.mjs

@@ -0,0 +1,7 @@
+import {
+  CameraNativeDetectionAddon
+} from "../../chunk-IYHMGYGP.mjs";
+export {
+  CameraNativeDetectionAddon as default
+};
+//# sourceMappingURL=index.mjs.map

package/dist/addons/camera-native-detection/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/addons/face-detection/index.d.mts

@@ -0,0 +1,24 @@
+import { ICropperProvider, IDetectionAddon, AddonManifest, AddonContext, CropInput, CropperOutput, ConfigUISchema, ClassMapDefinition, ModelCatalogEntry, DetectionModel, LabelDefinition, ProbeResult } from '@camstack/types';
+
+declare class FaceDetectionAddon implements ICropperProvider, IDetectionAddon {
+    readonly id = "face-detection";
+    readonly slot: "cropper";
+    readonly inputClasses: readonly ["person"];
+    readonly outputClasses: readonly ["face"];
+    readonly slotPriority = 0;
+    readonly manifest: AddonManifest;
+    private engine;
+    private modelEntry;
+    private confidence;
+    initialize(ctx: AddonContext): Promise<void>;
+    crop(input: CropInput): Promise<CropperOutput>;
+    shutdown(): Promise<void>;
+    getConfigSchema(): ConfigUISchema;
+    getClassMap(): ClassMapDefinition;
+    getModelCatalog(): ModelCatalogEntry[];
+    getAvailableModels(): DetectionModel[];
+    getActiveLabels(): readonly LabelDefinition[];
+    probe(): Promise<ProbeResult>;
+}
+
+export { FaceDetectionAddon as default };

package/dist/addons/face-detection/index.d.ts

@@ -0,0 +1,24 @@
+import { ICropperProvider, IDetectionAddon, AddonManifest, AddonContext, CropInput, CropperOutput, ConfigUISchema, ClassMapDefinition, ModelCatalogEntry, DetectionModel, LabelDefinition, ProbeResult } from '@camstack/types';
+
+declare class FaceDetectionAddon implements ICropperProvider, IDetectionAddon {
+    readonly id = "face-detection";
+    readonly slot: "cropper";
+    readonly inputClasses: readonly ["person"];
+    readonly outputClasses: readonly ["face"];
+    readonly slotPriority = 0;
+    readonly manifest: AddonManifest;
+    private engine;
+    private modelEntry;
+    private confidence;
+    initialize(ctx: AddonContext): Promise<void>;
+    crop(input: CropInput): Promise<CropperOutput>;
+    shutdown(): Promise<void>;
+    getConfigSchema(): ConfigUISchema;
+    getClassMap(): ClassMapDefinition;
+    getModelCatalog(): ModelCatalogEntry[];
+    getAvailableModels(): DetectionModel[];
+    getActiveLabels(): readonly LabelDefinition[];
+    probe(): Promise<ProbeResult>;
+}
+
+export { FaceDetectionAddon as default };

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

@@ -0,0 +1,513 @@
+"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/face-detection/index.ts
+var face_detection_exports = {};
+__export(face_detection_exports, {
+  default: () => FaceDetectionAddon
+});
+module.exports = __toCommonJS(face_detection_exports);
+var import_types = require("@camstack/types");
+
+// 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 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);
+      }
+    }
+  }
+  return kept;
+}
+
+// src/shared/postprocess/scrfd.ts
+var STRIDES = [8, 16, 32];
+var NUM_ANCHORS_PER_STRIDE = 2;
+function generateAnchors(stride, inputSize) {
+  const featureSize = Math.ceil(inputSize / stride);
+  const anchors = [];
+  for (let y = 0; y < featureSize; y++) {
+    for (let x = 0; x < featureSize; x++) {
+      for (let k = 0; k < NUM_ANCHORS_PER_STRIDE; k++) {
+        anchors.push({
+          cx: (x + 0.5) * stride,
+          cy: (y + 0.5) * stride
+        });
+      }
+    }
+  }
+  return anchors;
+}
+function scrfdPostprocess(outputs, confidence, inputSize, originalWidth, originalHeight) {
+  const scaleX = originalWidth / inputSize;
+  const scaleY = originalHeight / inputSize;
+  const candidates = [];
+  for (const stride of STRIDES) {
+    const scoreKey = Object.keys(outputs).find((k) => k.includes(`score_${stride}`) || k.includes(`_${stride}_score`));
+    const bboxKey = Object.keys(outputs).find((k) => k.includes(`bbox_${stride}`) || k.includes(`_${stride}_bbox`));
+    const kpsKey = Object.keys(outputs).find((k) => k.includes(`kps_${stride}`) || k.includes(`_${stride}_kps`));
+    if (!scoreKey || !bboxKey) continue;
+    const scores = outputs[scoreKey];
+    const bboxes = outputs[bboxKey];
+    const kps = kpsKey ? outputs[kpsKey] : void 0;
+    const anchors = generateAnchors(stride, inputSize);
+    const n = anchors.length;
+    for (let i = 0; i < n; i++) {
+      const score = scores[i];
+      if (score < confidence) continue;
+      const anchor = anchors[i];
+      const x1 = anchor.cx - bboxes[i * 4] * stride;
+      const y1 = anchor.cy - bboxes[i * 4 + 1] * stride;
+      const x2 = anchor.cx + bboxes[i * 4 + 2] * stride;
+      const y2 = anchor.cy + bboxes[i * 4 + 3] * stride;
+      const bbox = {
+        x: x1 * scaleX,
+        y: y1 * scaleY,
+        w: (x2 - x1) * scaleX,
+        h: (y2 - y1) * scaleY
+      };
+      let landmarks;
+      if (kps) {
+        const pts = [];
+        for (let p = 0; p < 5; p++) {
+          pts.push({
+            x: (anchor.cx + kps[i * 10 + p * 2] * stride) * scaleX,
+            y: (anchor.cy + kps[i * 10 + p * 2 + 1] * stride) * scaleY
+          });
+        }
+        landmarks = pts;
+      }
+      candidates.push({ bbox, score, landmarks });
+    }
+  }
+  if (candidates.length === 0) return [];
+  const keptIndices = nms(candidates, 0.45);
+  return keptIndices.map((idx) => {
+    const { bbox, score, landmarks } = candidates[idx];
+    return {
+      class: "face",
+      originalClass: "face",
+      score,
+      bbox,
+      ...landmarks ? { landmarks } : {}
+    };
+  });
+}
+
+// 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/engine-resolver.ts
+var AUTO_BACKEND_PRIORITY = ["coreml", "cuda", "tensorrt", "cpu"];
+var BACKEND_TO_FORMAT = {
+  cpu: "onnx",
+  coreml: "coreml",
+  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, downloadModel } = 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 = modelFilePath(modelsDir, modelEntry, selectedFormat);
+  if (!modelExists(modelPath)) {
+    if (downloadModel) {
+      const formatEntry = modelEntry.formats[selectedFormat];
+      modelPath = await downloadModel(formatEntry.url, modelsDir);
+    } else {
+      throw new Error(
+        `resolveEngine: model file not found at ${modelPath} and no downloadModel function provided`
+      );
+    }
+  }
+  if (selectedFormat === "onnx" || selectedFormat === "coreml") {
+    const engine = new NodeInferenceEngine(modelPath, selectedBackend);
+    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 and no ONNX fallback is available`
+  );
+}
+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/face-detection/index.ts
+var FACE_LABEL = { id: "face", name: "Face" };
+var FACE_LABELS = [FACE_LABEL];
+var FACE_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+var FaceDetectionAddon = class {
+  id = "face-detection";
+  slot = "cropper";
+  inputClasses = ["person"];
+  outputClasses = ["face"];
+  slotPriority = 0;
+  manifest = {
+    id: "face-detection",
+    name: "Face Detection",
+    version: "0.1.0",
+    description: "SCRFD-based face detector \u2014 crops face regions from person detections",
+    packageName: "@camstack/vision",
+    slot: "cropper",
+    inputClasses: ["person"],
+    outputClasses: ["face"],
+    supportsCustomModels: false,
+    mayRequirePython: false,
+    defaultConfig: {
+      modelId: "scrfd-500m",
+      runtime: "auto",
+      backend: "cpu",
+      confidence: 0.5
+    }
+  };
+  engine;
+  modelEntry;
+  confidence = 0.5;
+  async initialize(ctx) {
+    const cfg = ctx.addonConfig;
+    const modelId = cfg["modelId"] ?? "scrfd-500m";
+    const runtime = cfg["runtime"] ?? "auto";
+    const backend = cfg["backend"] ?? "cpu";
+    this.confidence = cfg["confidence"] ?? 0.5;
+    const entry = import_types.FACE_DETECTION_MODELS.find((m) => m.id === modelId);
+    if (!entry) {
+      throw new Error(`FaceDetectionAddon: unknown modelId "${modelId}"`);
+    }
+    this.modelEntry = entry;
+    const resolved = await resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir: ctx.locationPaths.models
+    });
+    this.engine = resolved.engine;
+  }
+  async crop(input) {
+    const start = Date.now();
+    const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+    const targetSize = Math.max(inputW, inputH);
+    const personCrop = await cropRegion(input.frame.data, input.roi);
+    const lb = await letterbox(personCrop, targetSize);
+    const engineWithMulti = this.engine;
+    let outputs;
+    if (typeof engineWithMulti.runMultiOutput === "function") {
+      outputs = await engineWithMulti.runMultiOutput(lb.data, [1, 3, targetSize, targetSize]);
+    } else {
+      const single = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+      outputs = { output0: single };
+    }
+    const crops = scrfdPostprocess(
+      outputs,
+      this.confidence,
+      targetSize,
+      lb.originalWidth,
+      lb.originalHeight
+    );
+    return {
+      crops,
+      inferenceMs: Date.now() - start,
+      modelId: this.modelEntry.id
+    };
+  }
+  async shutdown() {
+    await this.engine?.dispose();
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "model",
+          title: "Model",
+          columns: 1,
+          fields: [
+            {
+              key: "modelId",
+              label: "Model",
+              type: "model-selector",
+              catalog: [...import_types.FACE_DETECTION_MODELS],
+              allowCustom: false,
+              allowConversion: false,
+              acceptFormats: ["onnx", "coreml", "openvino"],
+              requiredMetadata: ["inputSize", "labels", "outputFormat"],
+              outputFormatHint: "ssd"
+            }
+          ]
+        },
+        {
+          id: "thresholds",
+          title: "Detection Thresholds",
+          columns: 1,
+          fields: [
+            {
+              key: "confidence",
+              label: "Confidence Threshold",
+              type: "slider",
+              min: 0.1,
+              max: 1,
+              step: 0.05,
+              default: 0.5
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return FACE_CLASS_MAP;
+  }
+  getModelCatalog() {
+    return [...import_types.FACE_DETECTION_MODELS];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return FACE_LABELS;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: this.engine?.runtime ?? "onnx",
+      device: this.engine?.device ?? "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+//# sourceMappingURL=index.js.map