@camstack/addon-benchmark 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,288 +1,3 @@
-// src/runner/stats.ts
-function percentile(sorted, p) {
-  if (sorted.length === 0) return 0;
-  const idx = p * (sorted.length - 1);
-  const lo = Math.floor(idx);
-  const hi = Math.ceil(idx);
-  const loVal = sorted[lo] ?? 0;
-  const hiVal = sorted[hi] ?? 0;
-  return loVal + (hiVal - loVal) * (idx - lo);
-}
-function computeLatencyStats(timingsMs) {
-  if (timingsMs.length === 0) {
-    return { mean: 0, median: 0, p95: 0, p99: 0, min: 0, max: 0 };
-  }
-  const sorted = [...timingsMs].sort((a, b) => a - b);
-  const sum = sorted.reduce((acc, v) => acc + v, 0);
-  const mean = sum / sorted.length;
-  return {
-    mean,
-    median: percentile(sorted, 0.5),
-    p95: percentile(sorted, 0.95),
-    p99: percentile(sorted, 0.99),
-    min: sorted[0] ?? 0,
-    max: sorted[sorted.length - 1] ?? 0
-  };
-}
-function computeFps(timingsMs) {
-  if (timingsMs.length === 0) return 0;
-  const stats = computeLatencyStats(timingsMs);
-  if (stats.mean === 0) return 0;
-  return 1e3 / stats.mean;
-}
-
-// src/runner/accuracy.ts
-function iou(pred, gt) {
-  const predX2 = pred.x + pred.w;
-  const predY2 = pred.y + pred.h;
-  const gtX2 = gt.x + gt.w;
-  const gtY2 = gt.y + gt.h;
-  const interX1 = Math.max(pred.x, gt.x);
-  const interY1 = Math.max(pred.y, gt.y);
-  const interX2 = Math.min(predX2, gtX2);
-  const interY2 = Math.min(predY2, gtY2);
-  const interW = Math.max(0, interX2 - interX1);
-  const interH = Math.max(0, interY2 - interY1);
-  const interArea = interW * interH;
-  if (interArea === 0) return 0;
-  const predArea = pred.w * pred.h;
-  const gtArea = gt.w * gt.h;
-  const unionArea = predArea + gtArea - interArea;
-  if (unionArea <= 0) return 0;
-  return interArea / unionArea;
-}
-function areaUnderPRCurve(precision, recall) {
-  if (precision.length < 2) return precision[0] ?? 0;
-  let area = 0;
-  for (let i = 1; i < recall.length; i++) {
-    const dr = (recall[i] ?? 0) - (recall[i - 1] ?? 0);
-    const avgP = ((precision[i] ?? 0) + (precision[i - 1] ?? 0)) / 2;
-    area += dr * avgP;
-  }
-  return Math.abs(area);
-}
-function computeClassAP(predictions, groundTruths, iouThreshold) {
-  const nGt = groundTruths.length;
-  if (nGt === 0) return 0;
-  if (predictions.length === 0) return 0;
-  const matched = /* @__PURE__ */ new Set();
-  const tp = [];
-  const fp = [];
-  for (const pred of predictions) {
-    let bestIou = -1;
-    let bestGtIdx = -1;
-    for (let i = 0; i < groundTruths.length; i++) {
-      if (matched.has(i)) continue;
-      const gt = groundTruths[i];
-      if (!gt) continue;
-      const score = iou(pred.bbox, gt.bbox);
-      if (score > bestIou) {
-        bestIou = score;
-        bestGtIdx = i;
-      }
-    }
-    if (bestIou >= iouThreshold && bestGtIdx >= 0) {
-      matched.add(bestGtIdx);
-      tp.push(1);
-      fp.push(0);
-    } else {
-      tp.push(0);
-      fp.push(1);
-    }
-  }
-  const cumTp = [];
-  const cumFp = [];
-  let sumTp = 0;
-  let sumFp = 0;
-  for (let i = 0; i < tp.length; i++) {
-    sumTp += tp[i] ?? 0;
-    sumFp += fp[i] ?? 0;
-    cumTp.push(sumTp);
-    cumFp.push(sumFp);
-  }
-  const precisions = [];
-  const recalls = [];
-  precisions.push(1);
-  recalls.push(0);
-  for (let i = 0; i < cumTp.length; i++) {
-    const cTp = cumTp[i] ?? 0;
-    const cFp = cumFp[i] ?? 0;
-    const denom = cTp + cFp;
-    precisions.push(denom > 0 ? cTp / denom : 0);
-    recalls.push(nGt > 0 ? cTp / nGt : 0);
-  }
-  return areaUnderPRCurve(precisions, recalls);
-}
-function computeAccuracy(predictions, groundTruth, iouThreshold = 0.5) {
-  if (groundTruth.length === 0) {
-    return { mAP50: void 0, precision: void 0, recall: void 0 };
-  }
-  const classes = [...new Set(groundTruth.map((gt) => gt.class))];
-  const aps = [];
-  let totalTp = 0;
-  let totalFp = 0;
-  let totalGt = 0;
-  for (const cls of classes) {
-    const classPredictions = predictions.filter((p) => p.class === cls).sort((a, b) => b.score - a.score);
-    const classGt = groundTruth.filter((gt) => gt.class === cls);
-    totalGt += classGt.length;
-    const ap = computeClassAP(classPredictions, classGt, iouThreshold);
-    aps.push(ap);
-    const matched = /* @__PURE__ */ new Set();
-    for (const pred of classPredictions) {
-      let bestIou = -1;
-      let bestGtIdx = -1;
-      for (let i = 0; i < classGt.length; i++) {
-        if (matched.has(i)) continue;
-        const gt = classGt[i];
-        if (!gt) continue;
-        const score = iou(pred.bbox, gt.bbox);
-        if (score > bestIou) {
-          bestIou = score;
-          bestGtIdx = i;
-        }
-      }
-      if (bestIou >= iouThreshold && bestGtIdx >= 0) {
-        matched.add(bestGtIdx);
-        totalTp++;
-      } else {
-        totalFp++;
-      }
-    }
-  }
-  const mAP50 = aps.length > 0 ? aps.reduce((sum, ap) => sum + ap, 0) / aps.length : void 0;
-  const precision = totalTp + totalFp > 0 ? totalTp / (totalTp + totalFp) : void 0;
-  const recall = totalGt > 0 ? totalTp / totalGt : void 0;
-  return { mAP50, precision, recall };
-}
-
-// src/runner/benchmark-runner.ts
-function measureResources() {
-  const memUsage = process.memoryUsage();
-  return {
-    peakMemoryMB: Math.round(memUsage.heapUsed / (1024 * 1024)),
-    avgCpuPercent: 0
-    // CPU profiling requires native tooling; best-effort zero
-  };
-}
-var BenchmarkRunner = class {
-  constructor(options) {
-    this.options = options;
-  }
-  /** Run inference on a single frame, picking a reference image round-robin if needed */
-  async runOnce(target, frameIdx = 0) {
-    const images = this.options.referenceImages;
-    if (images.length === 0) {
-      const syntheticFrame = {
-        data: Buffer.alloc(320 * 240 * 3),
-        format: "rgb",
-        width: 320,
-        height: 240,
-        timestamp: Date.now()
-      };
-      return this.options.runInference(syntheticFrame, target.config);
-    }
-    const idx = frameIdx % images.length;
-    const entry = images[idx];
-    if (!entry) {
-      throw new Error(`Reference image at index ${idx} is undefined`);
-    }
-    return this.options.runInference(entry.frame, target.config);
-  }
-  /** Measure accuracy across all reference images */
-  async measureAccuracy(target) {
-    const images = this.options.referenceImages;
-    if (images.length === 0) return void 0;
-    const allPredictions = [];
-    const allGroundTruth = [];
-    for (const entry of images) {
-      const output = await this.options.runInference(entry.frame, target.config);
-      allPredictions.push(...output.detections);
-      allGroundTruth.push(...entry.groundTruth.annotations);
-    }
-    return computeAccuracy(allPredictions, allGroundTruth);
-  }
-  /** Run benchmark for a single target configuration */
-  async runTarget(target, config) {
-    const warmup = config.warmup ?? 10;
-    const iterations = config.iterations ?? 100;
-    const timings = [];
-    for (let i = 0; i < warmup; i++) {
-      await this.runOnce(target, i);
-    }
-    for (let i = 0; i < iterations; i++) {
-      const start = performance.now();
-      await this.runOnce(target, i);
-      timings.push(performance.now() - start);
-      this.options.onProgress?.(i + 1, iterations, target.label);
-    }
-    const latency = computeLatencyStats(timings);
-    const fps = computeFps(timings);
-    const accuracy = await this.measureAccuracy(target);
-    const resources = measureResources();
-    return {
-      label: target.label,
-      addonId: target.addonId,
-      config: target.config,
-      latency,
-      fps,
-      accuracy,
-      resources
-    };
-  }
-  /** Run benchmark for all targets defined in the config */
-  async runAll(config) {
-    const results = [];
-    for (const target of config.targets) {
-      results.push(await this.runTarget(target, config));
-    }
-    return results;
-  }
-};
-
-// src/runner/system-info.ts
-import os from "os";
-import { execSync } from "child_process";
-function detectGpuModel() {
-  try {
-    const output = execSync("nvidia-smi --query-gpu=name --format=csv,noheader", {
-      timeout: 3e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    if (output.length > 0) {
-      return output.split("\n")[0]?.trim();
-    }
-  } catch {
-  }
-  if (process.platform === "darwin") {
-    try {
-      const output = execSync(
-        "system_profiler SPDisplaysDataType 2>/dev/null | grep 'Chipset Model:' | head -1",
-        { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
-      ).toString().trim();
-      const match = output.match(/Chipset Model:\s*(.+)/);
-      if (match?.[1]) {
-        return match[1].trim();
-      }
-    } catch {
-    }
-  }
-  return void 0;
-}
-function collectSystemInfo() {
-  const cpus = os.cpus();
-  const firstCpu = cpus[0];
-  return {
-    os: `${os.type()} ${os.release()}`,
-    arch: os.arch(),
-    cpuModel: firstCpu?.model ?? "Unknown",
-    cpuCores: cpus.length,
-    totalMemoryMB: Math.round(os.totalmem() / (1024 * 1024)),
-    gpuModel: detectGpuModel(),
-    nodeVersion: process.version
-  };
-}
-
 // src/benchmark-addon.ts
 var BenchmarkAddon = class {
   id = "benchmark";
@@ -290,8 +5,8 @@ var BenchmarkAddon = class {
     id: "benchmark",
     name: "Benchmark",
     version: "0.1.0",
-    description: "Detection addon benchmarking with reference images and distributed execution",
-    packageName: "@camstack/addon-benchmark"
+    packageName: "@camstack/addon-benchmark",
+    description: "Detection benchmark, image tester, and pipeline runner"
   };
   pages = [
     {
@@ -299,18 +14,12 @@ var BenchmarkAddon = class {
       label: "Benchmark",
       icon: "gauge",
       path: "/addon/benchmark",
-      bundle: "benchmark.js",
-      element: "camstack-benchmark"
+      bundle: "page.mjs"
     }
   ];
-  context = null;
-  options = {};
-  async initialize(ctx, opts) {
-    this.context = ctx;
-    this.options = opts ?? {};
+  async initialize(_ctx) {
   }
   async shutdown() {
-    this.context = null;
   }
   getCapabilityProvider(name) {
     if (name === "addon-pages") {
@@ -322,435 +31,8 @@ var BenchmarkAddon = class {
     }
     return null;
   }
-  /**
-   * Run a benchmark locally and return a MultiBenchmarkReport.
-   */
-  async run(config, onProgress) {
-    const systemInfo = collectSystemInfo();
-    const results = await this.runLocally(config, onProgress);
-    const leaderboard = results.sort((a, b) => a.latency.mean - b.latency.mean).map((r, idx) => ({
-      rank: idx + 1,
-      agentId: "local",
-      label: r.label,
-      meanMs: r.latency.mean,
-      fps: r.fps,
-      peakMemoryMB: r.resources.peakMemoryMB,
-      accuracy: r.accuracy
-    }));
-    return {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      source: config.source,
-      agents: [
-        {
-          agentId: "local",
-          status: "completed",
-          systemInfo,
-          results
-        }
-      ],
-      leaderboard
-    };
-  }
-  /**
-   * Run a distributed benchmark across agents.
-   *
-   * Stub: distributed execution requires a BenchmarkHub instance bound to
-   * live WebSocket connections. Call BenchmarkHub.dispatch() directly from
-   * the server transport layer. This method runs locally as a fallback.
-   */
-  async runDistributed(config, onProgress) {
-    return this.run(config, onProgress);
-  }
-  async runLocally(config, onProgress) {
-    const { inferenceFactory, referenceImages = [] } = this.options;
-    const firstTarget = config.targets[0];
-    if (!firstTarget) {
-      throw new Error("BenchmarkConfig must have at least one target");
-    }
-    if (!inferenceFactory) {
-      return config.targets.map((target) => ({
-        label: target.label,
-        addonId: target.addonId,
-        config: target.config,
-        latency: { mean: 0, median: 0, p95: 0, p99: 0, min: 0, max: 0 },
-        fps: 0,
-        resources: { peakMemoryMB: 0, avgCpuPercent: 0 }
-      }));
-    }
-    const runInference = inferenceFactory(firstTarget.addonId, firstTarget.config);
-    const runner = new BenchmarkRunner({
-      runInference,
-      referenceImages,
-      onProgress
-    });
-    return runner.runAll(config);
-  }
-};
-
-// src/annotator/result-annotator.ts
-import sharp from "sharp";
-var COLOR_PALETTE = [
-  "#FF4136",
-  "#2ECC40",
-  "#0074D9",
-  "#FF851B",
-  "#B10DC9",
-  "#FFDC00",
-  "#7FDBFF",
-  "#01FF70",
-  "#F012BE",
-  "#3D9970"
-];
-function classColor(cls) {
-  let hash = 0;
-  for (let i = 0; i < cls.length; i++) {
-    hash = hash * 31 + (cls.codePointAt(i) ?? 0) >>> 0;
-  }
-  return COLOR_PALETTE[hash % COLOR_PALETTE.length] ?? "#FF4136";
-}
-function escSvg(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
-function buildSvgOverlay(detections, width, height) {
-  const rects = detections.map((det) => {
-    const color = classColor(det.class);
-    const label = escSvg(`${det.class} ${(det.score * 100).toFixed(0)}%`);
-    const { x, y, w, h } = det.bbox;
-    const clampX = Math.max(0, Math.min(x, width - 1));
-    const clampY = Math.max(0, Math.min(y, height - 1));
-    const clampW = Math.max(1, Math.min(w, width - clampX));
-    const clampH = Math.max(1, Math.min(h, height - clampY));
-    const labelY = clampY > 14 ? clampY - 2 : clampY + clampH + 12;
-    return `
-      <rect x="${clampX}" y="${clampY}" width="${clampW}" height="${clampH}"
-            stroke="${color}" stroke-width="2" fill="none"/>
-      <rect x="${clampX}" y="${labelY - 12}" width="${label.length * 7}" height="14"
-            fill="${color}" fill-opacity="0.75"/>
-      <text x="${clampX + 2}" y="${labelY}" font-family="monospace" font-size="11"
-            fill="white">${label}</text>`;
-  });
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">${rects.join("")}</svg>`;
-}
-async function buildMaskOverlays(detections, width, height) {
-  const overlays = [];
-  for (const det of detections) {
-    if (!det.mask || !det.maskWidth || !det.maskHeight) continue;
-    const color = classColor(det.class);
-    const r = parseInt(color.slice(1, 3), 16);
-    const g = parseInt(color.slice(3, 5), 16);
-    const b = parseInt(color.slice(5, 7), 16);
-    const rgba = Buffer.alloc(det.maskWidth * det.maskHeight * 4);
-    for (let i = 0; i < det.mask.length; i++) {
-      const alpha = det.mask[i] ?? 0;
-      if (alpha > 0) {
-        const base = i * 4;
-        rgba[base] = r;
-        rgba[base + 1] = g;
-        rgba[base + 2] = b;
-        rgba[base + 3] = Math.round(alpha * 0.5);
-      }
-    }
-    const maskBuffer = await sharp(rgba, {
-      raw: { width: det.maskWidth, height: det.maskHeight, channels: 4 }
-    }).resize(width, height).png().toBuffer();
-    overlays.push(maskBuffer);
-  }
-  return overlays;
-}
-async function annotateImage(frame, detections, outputPath) {
-  let image;
-  if (frame.format === "jpeg") {
-    image = sharp(frame.data);
-  } else {
-    image = sharp(frame.data, {
-      raw: { width: frame.width, height: frame.height, channels: 3 }
-    });
-  }
-  const composites = [];
-  const maskBuffers = await buildMaskOverlays(detections, frame.width, frame.height);
-  for (const maskBuf of maskBuffers) {
-    composites.push({ input: maskBuf, blend: "over" });
-  }
-  const svgBuf = Buffer.from(buildSvgOverlay(detections, frame.width, frame.height));
-  composites.push({ input: svgBuf, blend: "over" });
-  await image.composite(composites).jpeg({ quality: 90 }).toFile(outputPath);
-}
-
-// src/distributed/benchmark-hub.ts
-var BenchmarkHub = class {
-  constructor(send) {
-    this.send = send;
-  }
-  agents = /* @__PURE__ */ new Map();
-  activeTaskId = null;
-  resolveTask = null;
-  rejectTask = null;
-  pendingConfig = null;
-  /** Register a connected agent (typically on WS connect + hello message) */
-  registerAgent(agentId, systemInfo) {
-    this.agents.set(agentId, {
-      agentId,
-      systemInfo,
-      status: "idle"
-    });
-  }
-  /** Mark an agent as disconnected */
-  disconnectAgent(agentId) {
-    const entry = this.agents.get(agentId);
-    if (entry) {
-      this.agents.set(agentId, { ...entry, status: "disconnected" });
-    }
-    this.checkCompletion();
-  }
-  /** Handle incoming message from any agent */
-  handleMessage(message) {
-    switch (message.type) {
-      case "agent.hello":
-        this.onAgentHello(message);
-        break;
-      case "benchmark.progress":
-        this.onProgress(message);
-        break;
-      case "benchmark.result":
-        this.onResult(message);
-        break;
-      case "benchmark.error":
-        this.onError(message);
-        break;
-      default:
-        break;
-    }
-  }
-  /**
-   * Dispatch a benchmark to a subset of agents.
-   * Returns a promise that resolves when all targeted agents have finished.
-   *
-   * @param config - Benchmark configuration
-   * @param agentIds - If empty, dispatches to all connected/idle agents
-   * @param referenceImages - Reference image buffers to send to agents
-   */
-  async dispatch(config, agentIds, referenceImages = []) {
-    const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-    this.activeTaskId = taskId;
-    this.pendingConfig = config;
-    const targets = agentIds.length > 0 ? agentIds : [...this.agents.values()].filter((a) => a.status === "idle").map((a) => a.agentId);
-    if (targets.length === 0) {
-      throw new Error("No idle agents available for benchmark dispatch");
-    }
-    for (const agentId of targets) {
-      const entry = this.agents.get(agentId);
-      if (entry) {
-        this.agents.set(agentId, { ...entry, status: "running", results: void 0, error: void 0 });
-      }
-    }
-    for (const agentId of targets) {
-      this.send(agentId, {
-        type: "benchmark.start",
-        taskId,
-        config,
-        referenceImages
-      });
-    }
-    return new Promise((resolve, reject) => {
-      this.resolveTask = resolve;
-      this.rejectTask = reject;
-    });
-  }
-  onAgentHello(message) {
-    this.registerAgent(message.agentId, message.systemInfo);
-  }
-  onProgress(message) {
-    const entry = this.agents.get(message.agentId);
-    if (entry) {
-      this.agents.set(message.agentId, {
-        ...entry,
-        completedIterations: message.completed
-      });
-    }
-  }
-  onResult(message) {
-    const entry = this.agents.get(message.agentId);
-    if (entry) {
-      this.agents.set(message.agentId, {
-        ...entry,
-        status: "done",
-        systemInfo: message.systemInfo,
-        results: message.results
-      });
-    }
-    this.checkCompletion();
-  }
-  onError(message) {
-    const entry = this.agents.get(message.agentId);
-    if (entry) {
-      this.agents.set(message.agentId, {
-        ...entry,
-        status: "error",
-        error: message.error
-      });
-    }
-    this.checkCompletion();
-  }
-  checkCompletion() {
-    if (!this.resolveTask || !this.activeTaskId) return;
-    const runningAgents = [...this.agents.values()].filter(
-      (a) => a.status === "running"
-    );
-    if (runningAgents.length > 0) return;
-    const report = this.buildReport();
-    this.resolveTask(report);
-    this.resolveTask = null;
-    this.rejectTask = null;
-    this.activeTaskId = null;
-  }
-  buildReport() {
-    const source = this.pendingConfig?.source ?? { type: "reference", images: "all" };
-    const agentEntries = [...this.agents.values()];
-    const allResults = [];
-    for (const agent of agentEntries) {
-      if (agent.results) {
-        for (const result of agent.results) {
-          allResults.push({ agentId: agent.agentId, result });
-        }
-      }
-    }
-    const leaderboard = allResults.sort((a, b) => a.result.latency.mean - b.result.latency.mean).map((entry, idx) => ({
-      rank: idx + 1,
-      agentId: entry.agentId,
-      label: entry.result.label,
-      meanMs: entry.result.latency.mean,
-      fps: entry.result.fps,
-      peakMemoryMB: entry.result.resources.peakMemoryMB,
-      accuracy: entry.result.accuracy
-    }));
-    return {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      source,
-      agents: agentEntries.map((a) => ({
-        agentId: a.agentId,
-        status: a.status === "done" ? "completed" : a.status === "error" ? "failed" : a.status === "disconnected" ? "disconnected" : "partial",
-        systemInfo: a.systemInfo ?? {
-          os: "unknown",
-          arch: "unknown",
-          cpuModel: "unknown",
-          cpuCores: 0,
-          totalMemoryMB: 0,
-          nodeVersion: "unknown"
-        },
-        results: a.results ?? [],
-        error: a.error,
-        completedIterations: a.completedIterations
-      })),
-      leaderboard
-    };
-  }
-};
-
-// src/distributed/benchmark-agent.ts
-var BenchmarkAgent = class {
-  constructor(agentId, send, inferenceFactory) {
-    this.send = send;
-    this.inferenceFactory = inferenceFactory;
-    this.agentId = agentId;
-    this.systemInfo = collectSystemInfo();
-  }
-  agentId;
-  systemInfo;
-  cancelRequested = false;
-  /** Send hello to the hub — call this on WS connect */
-  hello() {
-    this.send({
-      type: "agent.hello",
-      agentId: this.agentId,
-      systemInfo: this.systemInfo
-    });
-  }
-  /** Handle incoming message from the hub */
-  handleMessage(message) {
-    switch (message.type) {
-      case "benchmark.start":
-        void this.onStart(message);
-        break;
-      case "benchmark.cancel":
-        this.onCancel(message);
-        break;
-      default:
-        break;
-    }
-  }
-  async onStart(message) {
-    this.cancelRequested = false;
-    const { taskId, config } = message;
-    try {
-      const referenceImages = message.referenceImages.map((img) => ({
-        frame: {
-          data: img.data,
-          format: "jpeg",
-          width: img.width,
-          height: img.height,
-          timestamp: Date.now()
-        },
-        groundTruth: { image: img.name, annotations: [] }
-      }));
-      const firstTarget = config.targets[0];
-      if (!firstTarget) {
-        throw new Error("No benchmark targets specified");
-      }
-      const runInference = this.inferenceFactory(firstTarget.addonId, firstTarget.config);
-      const runner = new BenchmarkRunner({
-        runInference,
-        referenceImages,
-        onProgress: (completed, total, currentTarget) => {
-          if (this.cancelRequested) return;
-          this.send({
-            type: "benchmark.progress",
-            taskId,
-            agentId: this.agentId,
-            completed,
-            total,
-            currentTarget
-          });
-        }
-      });
-      const results = await runner.runAll(config);
-      if (!this.cancelRequested) {
-        this.send({
-          type: "benchmark.result",
-          taskId,
-          agentId: this.agentId,
-          systemInfo: this.systemInfo,
-          results
-        });
-      }
-    } catch (err) {
-      this.send({
-        type: "benchmark.error",
-        taskId,
-        agentId: this.agentId,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  onCancel(message) {
-    if (message.taskId === this.activeTaskId) {
-      this.cancelRequested = true;
-    }
-  }
-  /** Returns the current task ID (last started), or null if idle */
-  get activeTaskId() {
-    return null;
-  }
 };
 export {
-  BenchmarkAddon,
-  BenchmarkAgent,
-  BenchmarkHub,
-  BenchmarkRunner,
-  annotateImage,
-  collectSystemInfo,
-  computeAccuracy,
-  computeFps,
-  computeLatencyStats,
-  iou
+  BenchmarkAddon
 };
 //# sourceMappingURL=index.mjs.map