@camstack/addon-vision 0.1.0

package/dist/chunk-J4WRYHHY.mjs

@@ -0,0 +1,212 @@
+import {
+  ANIMAL_TYPE_MODELS
+} from "./chunk-ISOIDU4U.mjs";
+import {
+  cropRegion,
+  resizeAndNormalize
+} from "./chunk-6OR5TE7A.mjs";
+import {
+  resolveEngine
+} from "./chunk-LPI42WL6.mjs";
+
+// src/addons/animal-classifier/index.ts
+var ANIMAL_TYPE_LABEL = { id: "animal-type", name: "Animal Type" };
+var ANIMAL_TYPE_LABELS = [ANIMAL_TYPE_LABEL];
+var ANIMAL_CLASS_MAP = { mapping: {}, preserveOriginal: true };
+var ANIMAL_10_CLASSES = [
+  "cat",
+  "cow",
+  "dog",
+  "dolphin",
+  "eagle",
+  "giant panda",
+  "horse",
+  "monkey",
+  "sheep",
+  "spider"
+];
+function softmax(logits) {
+  const max = logits.reduce((a, b) => Math.max(a, b), -Infinity);
+  const exps = logits.map((v) => Math.exp(v - max));
+  const sum = exps.reduce((a, b) => a + b, 0);
+  return exps.map((v) => v / sum);
+}
+var AnimalClassifierAddon = class {
+  id = "animal-classifier";
+  slot = "classifier";
+  inputClasses = ["animal"];
+  outputClasses = ["animal-type:*"];
+  slotPriority = 0;
+  requiredSteps = [];
+  manifest = {
+    id: "animal-classifier",
+    name: "Animal Classifier",
+    version: "0.1.0",
+    description: "ViT-based animal type classifier \u2014 10 common species",
+    packageName: "@camstack/addon-vision",
+    slot: "classifier",
+    inputClasses: ["animal"],
+    outputClasses: ["animal-type:*"],
+    supportsCustomModels: false,
+    mayRequirePython: false,
+    defaultConfig: {
+      modelId: "animals-10",
+      runtime: "auto",
+      backend: "cpu",
+      minConfidence: 0.3
+    }
+  };
+  engine;
+  modelEntry;
+  minConfidence = 0.3;
+  async initialize(ctx) {
+    const cfg = ctx.addonConfig;
+    const modelId = cfg["modelId"] ?? "animals-10";
+    const runtime = cfg["runtime"] ?? "auto";
+    const backend = cfg["backend"] ?? "cpu";
+    this.minConfidence = cfg["minConfidence"] ?? 0.3;
+    const entry = ANIMAL_TYPE_MODELS.find((m) => m.id === modelId);
+    if (!entry) {
+      throw new Error(`AnimalClassifierAddon: unknown modelId "${modelId}"`);
+    }
+    this.modelEntry = entry;
+    const resolved = await resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir: ctx.locationPaths.models
+    });
+    this.engine = resolved.engine;
+  }
+  async classify(input) {
+    const start = Date.now();
+    const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+    const animalCrop = await cropRegion(input.frame.data, input.roi);
+    const normalized = await resizeAndNormalize(animalCrop, inputW, inputH, "imagenet", "nchw");
+    const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW]);
+    const probs = softmax(rawOutput);
+    let maxIdx = 0;
+    let maxScore = probs[0] ?? 0;
+    for (let i = 1; i < probs.length; i++) {
+      const score = probs[i] ?? 0;
+      if (score > maxScore) {
+        maxScore = score;
+        maxIdx = i;
+      }
+    }
+    if (maxScore < this.minConfidence) {
+      return {
+        classifications: [],
+        inferenceMs: Date.now() - start,
+        modelId: this.modelEntry.id
+      };
+    }
+    const label = ANIMAL_10_CLASSES[maxIdx] ?? `animal_${maxIdx}`;
+    return {
+      classifications: [
+        {
+          class: label,
+          score: maxScore
+        }
+      ],
+      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: [...ANIMAL_TYPE_MODELS],
+              allowCustom: false,
+              allowConversion: false,
+              acceptFormats: ["onnx", "coreml", "openvino"],
+              requiredMetadata: ["inputSize", "labels"],
+              outputFormatHint: "classification"
+            }
+          ]
+        },
+        {
+          id: "thresholds",
+          title: "Classification Settings",
+          columns: 1,
+          fields: [
+            {
+              key: "minConfidence",
+              label: "Minimum Confidence",
+              type: "slider",
+              min: 0.05,
+              max: 1,
+              step: 0.05,
+              default: 0.3
+            }
+          ]
+        },
+        {
+          id: "runtime",
+          title: "Runtime",
+          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)" }
+              ]
+            },
+            {
+              key: "backend",
+              label: "Backend",
+              type: "select",
+              dependsOn: { runtime: "onnx" },
+              options: [
+                { value: "cpu", label: "CPU" },
+                { value: "coreml", label: "CoreML" },
+                { value: "cuda", label: "CUDA (NVIDIA)" }
+              ]
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return ANIMAL_CLASS_MAP;
+  }
+  getModelCatalog() {
+    return [...ANIMAL_TYPE_MODELS];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return ANIMAL_TYPE_LABELS;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: this.engine?.runtime ?? "onnx",
+      device: this.engine?.device ?? "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+
+export {
+  AnimalClassifierAddon
+};
+//# sourceMappingURL=chunk-J4WRYHHY.mjs.map

package/dist/chunk-J4WRYHHY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addons/animal-classifier/index.ts"],"sourcesContent":["import type {\n  IClassifierProvider,\n  IDetectionAddon,\n  AddonManifest,\n  AddonContext,\n  CropInput,\n  ClassifierOutput,\n  ConfigUISchema,\n  ClassMapDefinition,\n  ProbeResult,\n  ModelCatalogEntry,\n  DetectionModel,\n  LabelDefinition,\n  IInferenceEngine,\n} from '@camstack/types'\nimport { ANIMAL_TYPE_MODELS } from '../../catalogs/animal-classification-models.js'\nimport { cropRegion, resizeAndNormalize } from '../../shared/image-utils.js'\nimport { resolveEngine } from '../../shared/engine-resolver.js'\n\nconst ANIMAL_TYPE_LABEL: LabelDefinition = { id: 'animal-type', name: 'Animal Type' }\nconst ANIMAL_TYPE_LABELS: readonly LabelDefinition[] = [ANIMAL_TYPE_LABEL]\nconst ANIMAL_CLASS_MAP: ClassMapDefinition = { mapping: {}, preserveOriginal: true }\n\nconst ANIMAL_10_CLASSES = [\n  'cat',\n  'cow',\n  'dog',\n  'dolphin',\n  'eagle',\n  'giant panda',\n  'horse',\n  'monkey',\n  'sheep',\n  'spider',\n] as const\n\nfunction softmax(logits: Float32Array): Float32Array {\n  const max = logits.reduce((a, b) => Math.max(a, b), -Infinity)\n  const exps = logits.map((v) => Math.exp(v - max))\n  const sum = exps.reduce((a, b) => a + b, 0)\n  return exps.map((v) => v / sum) as unknown as Float32Array\n}\n\nexport default class AnimalClassifierAddon implements IClassifierProvider, IDetectionAddon {\n  readonly id = 'animal-classifier'\n  readonly slot = 'classifier' as const\n  readonly inputClasses = ['animal'] as const\n  readonly outputClasses = ['animal-type:*'] as const\n  readonly slotPriority = 0\n  readonly requiredSteps = [] as const\n  readonly manifest: AddonManifest = {\n    id: 'animal-classifier',\n    name: 'Animal Classifier',\n    version: '0.1.0',\n    description: 'ViT-based animal type classifier — 10 common species',\n    packageName: '@camstack/addon-vision',\n    slot: 'classifier',\n    inputClasses: ['animal'],\n    outputClasses: ['animal-type:*'],\n    supportsCustomModels: false,\n    mayRequirePython: false,\n    defaultConfig: {\n      modelId: 'animals-10',\n      runtime: 'auto',\n      backend: 'cpu',\n      minConfidence: 0.3,\n    },\n  }\n\n  private engine!: IInferenceEngine\n  private modelEntry!: ModelCatalogEntry\n  private minConfidence = 0.3\n\n  async initialize(ctx: AddonContext): Promise<void> {\n    const cfg = ctx.addonConfig\n    const modelId = (cfg['modelId'] as string | undefined) ?? 'animals-10'\n    const runtime = (cfg['runtime'] as string | undefined) ?? 'auto'\n    const backend = (cfg['backend'] as string | undefined) ?? 'cpu'\n    this.minConfidence = (cfg['minConfidence'] as number | undefined) ?? 0.3\n\n    const entry = ANIMAL_TYPE_MODELS.find((m) => m.id === modelId)\n    if (!entry) {\n      throw new Error(`AnimalClassifierAddon: unknown modelId \"${modelId}\"`)\n    }\n    this.modelEntry = entry\n\n    const resolved = await resolveEngine({\n      runtime: runtime as 'auto',\n      backend,\n      modelEntry: entry,\n      modelsDir: ctx.locationPaths.models,\n    })\n    this.engine = resolved.engine\n  }\n\n  async classify(input: CropInput): Promise<ClassifierOutput> {\n    const start = Date.now()\n    const { width: inputW, height: inputH } = this.modelEntry.inputSize\n\n    // Crop the animal region\n    const animalCrop = await cropRegion(input.frame.data, input.roi)\n\n    // Resize to 224x224, ImageNet normalization, NCHW\n    const normalized = await resizeAndNormalize(animalCrop, inputW, inputH, 'imagenet', 'nchw')\n\n    // Run inference — output shape: [1, 10]\n    const rawOutput = await this.engine.run(normalized, [1, 3, inputH, inputW])\n\n    // Softmax to get probabilities\n    const probs = softmax(rawOutput)\n\n    // Find argmax\n    let maxIdx = 0\n    let maxScore = probs[0] ?? 0\n    for (let i = 1; i < probs.length; i++) {\n      const score = probs[i] ?? 0\n      if (score > maxScore) {\n        maxScore = score\n        maxIdx = i\n      }\n    }\n\n    if (maxScore < this.minConfidence) {\n      return {\n        classifications: [],\n        inferenceMs: Date.now() - start,\n        modelId: this.modelEntry.id,\n      }\n    }\n\n    const label = ANIMAL_10_CLASSES[maxIdx] ?? `animal_${maxIdx}`\n\n    return {\n      classifications: [\n        {\n          class: label,\n          score: maxScore,\n        },\n      ],\n      inferenceMs: Date.now() - start,\n      modelId: this.modelEntry.id,\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    await this.engine?.dispose()\n  }\n\n  getConfigSchema(): ConfigUISchema {\n    return {\n      sections: [\n        {\n          id: 'model',\n          title: 'Model',\n          columns: 1,\n          fields: [\n            {\n              key: 'modelId',\n              label: 'Model',\n              type: 'model-selector',\n              catalog: [...ANIMAL_TYPE_MODELS],\n              allowCustom: false,\n              allowConversion: false,\n              acceptFormats: ['onnx', 'coreml', 'openvino'],\n              requiredMetadata: ['inputSize', 'labels'],\n              outputFormatHint: 'classification',\n            },\n          ],\n        },\n        {\n          id: 'thresholds',\n          title: 'Classification Settings',\n          columns: 1,\n          fields: [\n            {\n              key: 'minConfidence',\n              label: 'Minimum Confidence',\n              type: 'slider',\n              min: 0.05,\n              max: 1.0,\n              step: 0.05,\n              default: 0.3,\n            },\n          ],\n        },\n        {\n          id: 'runtime',\n          title: 'Runtime',\n          columns: 2,\n          fields: [\n            {\n              key: 'runtime',\n              label: 'Runtime',\n              type: 'select',\n              options: [\n                { value: 'auto', label: 'Auto (recommended)' },\n                { value: 'onnx', label: 'ONNX Runtime' },\n                { value: 'coreml', label: 'CoreML (Apple)' },\n              ],\n            },\n            {\n              key: 'backend',\n              label: 'Backend',\n              type: 'select',\n              dependsOn: { runtime: 'onnx' },\n              options: [\n                { value: 'cpu', label: 'CPU' },\n                { value: 'coreml', label: 'CoreML' },\n                { value: 'cuda', label: 'CUDA (NVIDIA)' },\n              ],\n            },\n          ],\n        },\n      ],\n    }\n  }\n\n  getClassMap(): ClassMapDefinition {\n    return ANIMAL_CLASS_MAP\n  }\n\n  getModelCatalog(): ModelCatalogEntry[] {\n    return [...ANIMAL_TYPE_MODELS]\n  }\n\n  getAvailableModels(): DetectionModel[] {\n    return []\n  }\n\n  getActiveLabels(): readonly LabelDefinition[] {\n    return ANIMAL_TYPE_LABELS\n  }\n\n  async probe(): Promise<ProbeResult> {\n    return {\n      available: true,\n      runtime: this.engine?.runtime ?? 'onnx',\n      device: this.engine?.device ?? 'cpu',\n      capabilities: ['fp32'],\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-KUO2BVFY.mjs

@@ -0,0 +1,90 @@
+// 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;
+}
+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;
+      }
+    }
+    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
+    };
+  });
+}
+
+export {
+  iou,
+  nms,
+  yoloPostprocess
+};
+//# sourceMappingURL=chunk-KUO2BVFY.mjs.map

package/dist/chunk-KUO2BVFY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/postprocess/yolo.ts"],"sourcesContent":["import type { SpatialDetection, BoundingBox } from '@camstack/types'\n\nexport interface YoloPostprocessOptions {\n  readonly confidence: number\n  readonly iouThreshold: number\n  readonly labels: readonly string[]\n  readonly scale: number\n  readonly padX: number\n  readonly padY: number\n  readonly originalWidth: number\n  readonly originalHeight: number\n}\n\n/** Calculate IoU between two bounding boxes */\nexport function iou(a: BoundingBox, b: BoundingBox): number {\n  const ax1 = a.x\n  const ay1 = a.y\n  const ax2 = a.x + a.w\n  const ay2 = a.y + a.h\n\n  const bx1 = b.x\n  const by1 = b.y\n  const bx2 = b.x + b.w\n  const by2 = b.y + b.h\n\n  const interX1 = Math.max(ax1, bx1)\n  const interY1 = Math.max(ay1, by1)\n  const interX2 = Math.min(ax2, bx2)\n  const interY2 = Math.min(ay2, by2)\n\n  const interW = Math.max(0, interX2 - interX1)\n  const interH = Math.max(0, interY2 - interY1)\n  const interArea = interW * interH\n\n  if (interArea === 0) return 0\n\n  const areaA = a.w * a.h\n  const areaB = b.w * b.h\n  const unionArea = areaA + areaB - interArea\n\n  return unionArea === 0 ? 0 : interArea / unionArea\n}\n\n/** Non-maximum suppression — returns indices of kept boxes (sorted by score desc) */\nexport function nms(\n  boxes: ReadonlyArray<{ readonly bbox: BoundingBox; readonly score: number }>,\n  iouThreshold: number,\n): number[] {\n  const indices = boxes\n    .map((_, i) => i)\n    .sort((a, b) => (boxes[b]!.score) - (boxes[a]!.score))\n\n  const kept: number[] = []\n  const suppressed = new Set<number>()\n\n  for (const idx of indices) {\n    if (suppressed.has(idx)) continue\n    kept.push(idx)\n    for (const other of indices) {\n      if (other === idx || suppressed.has(other)) continue\n      if (iou(boxes[idx]!.bbox, boxes[other]!.bbox) > iouThreshold) {\n        suppressed.add(other)\n      }\n    }\n  }\n\n  return kept\n}\n\n/** Full YOLO v8/v9 postprocessing: filter → NMS → scale back to original coords */\nexport function yoloPostprocess(\n  output: Float32Array,\n  numClasses: number,\n  numBoxes: number,\n  options: YoloPostprocessOptions,\n): SpatialDetection[] {\n  const { confidence, iouThreshold, labels, scale, padX, padY, originalWidth, originalHeight } = options\n\n  interface Candidate {\n    readonly bbox: BoundingBox\n    readonly score: number\n    readonly classIdx: number\n  }\n\n  const candidates: Candidate[] = []\n\n  for (let i = 0; i < numBoxes; i++) {\n    // YOLO v8/v9 output layout: [1, 4+numClasses, numBoxes] stored row-major\n    const cx = output[0 * numBoxes + i]!\n    const cy = output[1 * numBoxes + i]!\n    const w = output[2 * numBoxes + i]!\n    const h = output[3 * numBoxes + i]!\n\n    let bestScore = -Infinity\n    let bestClass = 0\n\n    for (let j = 0; j < numClasses; j++) {\n      const score = output[(4 + j) * numBoxes + i]!\n      if (score > bestScore) {\n        bestScore = score\n        bestClass = j\n      }\n    }\n\n    if (bestScore < confidence) continue\n\n    // Convert cx,cy,w,h to x,y,w,h (top-left origin)\n    const bbox: BoundingBox = {\n      x: cx - w / 2,\n      y: cy - h / 2,\n      w,\n      h,\n    }\n\n    candidates.push({ bbox, score: bestScore, classIdx: bestClass })\n  }\n\n  if (candidates.length === 0) return []\n\n  const keptIndices = nms(candidates, iouThreshold)\n\n  return keptIndices.map((idx) => {\n    const { bbox, score, classIdx } = candidates[idx]!\n    const label = labels[classIdx] ?? String(classIdx)\n\n    // Transform from letterbox coords back to original image coords\n    const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale))\n    const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale))\n    const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale))\n    const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale))\n\n    const finalBbox: BoundingBox = { x, y, w: x2 - x, h: y2 - y }\n\n    return {\n      class: label,\n      originalClass: label,\n      score,\n      bbox: finalBbox,\n    } satisfies SpatialDetection\n  })\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LPI42WL6.mjs

@@ -0,0 +1,324 @@
+// src/shared/node-engine.ts
+import * as path from "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
+import { spawn } from "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 = 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
+import * as fs from "fs";
+import * as path2 from "path";
+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 { 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 scriptPath = path2.join(__dirname, "../../python", scriptName);
+    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)];
+}
+
+export {
+  NodeInferenceEngine,
+  PythonInferenceEngine,
+  resolveEngine,
+  probeOnnxBackends
+};
+//# sourceMappingURL=chunk-LPI42WL6.mjs.map