@camstack/lib-pipeline-analysis 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,1279 +1,1544 @@
-// src/zones/geometry.ts
-function pointInPolygon(point, polygon) {
-  if (polygon.length < 3) return false;
-  let inside = false;
-  const { x, y } = point;
-  const n = polygon.length;
-  for (let i = 0, j = n - 1; i < n; j = i++) {
-    const xi = polygon[i].x;
-    const yi = polygon[i].y;
-    const xj = polygon[j].x;
-    const yj = polygon[j].y;
-    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
-    if (intersect) inside = !inside;
-  }
-  return inside;
-}
-function lineIntersection(a, b) {
-  const dx1 = a.p2.x - a.p1.x;
-  const dy1 = a.p2.y - a.p1.y;
-  const dx2 = b.p2.x - b.p1.x;
-  const dy2 = b.p2.y - b.p1.y;
-  const denom = dx1 * dy2 - dy1 * dx2;
-  if (Math.abs(denom) < 1e-10) return null;
-  const dx3 = b.p1.x - a.p1.x;
-  const dy3 = b.p1.y - a.p1.y;
-  const t = (dx3 * dy2 - dy3 * dx2) / denom;
-  const u = (dx3 * dy1 - dy3 * dx1) / denom;
-  if (t < 0 || t > 1 || u < 0 || u > 1) return null;
-  return {
-    x: a.p1.x + t * dx1,
-    y: a.p1.y + t * dy1
-  };
-}
-function tripwireCrossing(prev, curr, tripwire) {
-  const movement = { p1: prev, p2: curr };
-  const intersection = lineIntersection(movement, tripwire);
-  if (intersection === null) return null;
-  const twDx = tripwire.p2.x - tripwire.p1.x;
-  const twDy = tripwire.p2.y - tripwire.p1.y;
-  const movDx = curr.x - prev.x;
-  const movDy = curr.y - prev.y;
-  const cross = twDx * movDy - twDy * movDx;
-  const direction = cross > 0 ? "left" : "right";
-  return { crossed: true, direction };
-}
-function bboxCentroid(bbox) {
-  return {
-    x: bbox.x + bbox.w / 2,
-    y: bbox.y + bbox.h / 2
-  };
-}
-function normalizeToPixel(point, imageWidth, imageHeight) {
-  return {
-    x: point.x * imageWidth,
-    y: point.y * imageHeight
-  };
-}
-
-// src/tracker/hungarian.ts
-function greedyAssignment(costMatrix, threshold) {
-  const numTracks = costMatrix.length;
-  const numDetections = numTracks > 0 ? costMatrix[0]?.length ?? 0 : 0;
-  const candidates = [];
-  for (let t = 0; t < numTracks; t++) {
-    for (let d = 0; d < numDetections; d++) {
-      const iou2 = costMatrix[t][d] ?? 0;
-      if (iou2 >= threshold) {
-        candidates.push({ iou: iou2, trackIdx: t, detIdx: d });
-      }
-    }
-  }
-  candidates.sort((a, b) => b.iou - a.iou);
-  const assignedTracks = /* @__PURE__ */ new Set();
-  const assignedDets = /* @__PURE__ */ new Set();
-  const matches = [];
-  for (const { trackIdx, detIdx } of candidates) {
-    if (assignedTracks.has(trackIdx) || assignedDets.has(detIdx)) continue;
-    matches.push([trackIdx, detIdx]);
-    assignedTracks.add(trackIdx);
-    assignedDets.add(detIdx);
-  }
-  const unmatchedTracks = [];
-  for (let t = 0; t < numTracks; t++) {
-    if (!assignedTracks.has(t)) unmatchedTracks.push(t);
-  }
-  const unmatchedDetections = [];
-  for (let d = 0; d < numDetections; d++) {
-    if (!assignedDets.has(d)) unmatchedDetections.push(d);
-  }
-  return { matches, unmatchedTracks, unmatchedDetections };
-}
-
-// src/tracker/sort-tracker.ts
-var MAX_PATH_LENGTH = 300;
-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 aArea = a.w * a.h;
-  const bArea = b.w * b.h;
-  const unionArea = aArea + bArea - interArea;
-  return unionArea <= 0 ? 0 : interArea / unionArea;
-}
-function trackToTrackedDetection(track) {
-  return {
-    class: track.class,
-    originalClass: track.originalClass,
-    score: track.score,
-    bbox: track.bbox,
-    landmarks: track.landmarks,
-    trackId: track.id,
-    trackAge: track.hits,
-    velocity: track.velocity,
-    path: track.path.slice()
-  };
-}
-function pushToRingBuffer(buffer, item, maxLength) {
-  if (buffer.length >= maxLength) {
-    buffer.shift();
-  }
-  buffer.push(item);
-}
-var DEFAULT_TRACKER_CONFIG = {
-  maxAge: 30,
-  minHits: 3,
-  iouThreshold: 0.3
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var SortTracker = class {
-  tracks = [];
-  lostTracks = [];
-  nextTrackId = 1;
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_TRACKER_CONFIG, ...config };
+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 });
   }
-  update(detections, frameTimestamp) {
-    this.lostTracks = [];
-    if (this.tracks.length === 0) {
-      for (const det of detections) {
-        this.createTrack(det, frameTimestamp);
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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
+));
+
+// src/zones/geometry.js
+var require_geometry = __commonJS({
+  "src/zones/geometry.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pointInPolygon = pointInPolygon;
+    exports.lineIntersection = lineIntersection;
+    exports.tripwireCrossing = tripwireCrossing;
+    exports.bboxCentroid = bboxCentroid;
+    exports.normalizeToPixel = normalizeToPixel;
+    function pointInPolygon(point, polygon) {
+      if (polygon.length < 3)
+        return false;
+      let inside = false;
+      const { x, y } = point;
+      const n = polygon.length;
+      for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = polygon[i].x;
+        const yi = polygon[i].y;
+        const xj = polygon[j].x;
+        const yj = polygon[j].y;
+        const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+        if (intersect)
+          inside = !inside;
       }
-      return this.getConfirmedTracks();
-    }
-    if (detections.length === 0) {
-      this.ageTracksAndPruneLost(frameTimestamp);
-      return this.getConfirmedTracks();
-    }
-    const costMatrix = this.tracks.map(
-      (track) => detections.map((det) => iou(track.bbox, det.bbox))
-    );
-    const { matches, unmatchedTracks, unmatchedDetections } = greedyAssignment(
-      costMatrix,
-      this.config.iouThreshold
-    );
-    for (const [trackIdx, detIdx] of matches) {
-      const track = this.tracks[trackIdx];
-      const det = detections[detIdx];
-      const prevCx = track.bbox.x + track.bbox.w / 2;
-      const prevCy = track.bbox.y + track.bbox.h / 2;
-      const newCx = det.bbox.x + det.bbox.w / 2;
-      const newCy = det.bbox.y + det.bbox.h / 2;
-      pushToRingBuffer(track.path, track.bbox, MAX_PATH_LENGTH);
-      track.bbox = det.bbox;
-      track.class = det.class;
-      track.originalClass = det.originalClass;
-      track.score = det.score;
-      track.landmarks = det.landmarks;
-      track.age = 0;
-      track.hits++;
-      track.lastSeen = frameTimestamp;
-      track.velocity = { dx: newCx - prevCx, dy: newCy - prevCy };
+      return inside;
     }
-    for (const trackIdx of unmatchedTracks) {
-      const track = this.tracks[trackIdx];
-      track.age++;
+    function lineIntersection(a, b) {
+      const dx1 = a.p2.x - a.p1.x;
+      const dy1 = a.p2.y - a.p1.y;
+      const dx2 = b.p2.x - b.p1.x;
+      const dy2 = b.p2.y - b.p1.y;
+      const denom = dx1 * dy2 - dy1 * dx2;
+      if (Math.abs(denom) < 1e-10)
+        return null;
+      const dx3 = b.p1.x - a.p1.x;
+      const dy3 = b.p1.y - a.p1.y;
+      const t = (dx3 * dy2 - dy3 * dx2) / denom;
+      const u = (dx3 * dy1 - dy3 * dx1) / denom;
+      if (t < 0 || t > 1 || u < 0 || u > 1)
+        return null;
+      return {
+        x: a.p1.x + t * dx1,
+        y: a.p1.y + t * dy1
+      };
     }
-    const survived = [];
-    for (const track of this.tracks) {
-      if (track.age > this.config.maxAge) {
-        track.lost = true;
-        this.lostTracks.push(track);
-      } else {
-        survived.push(track);
-      }
+    function tripwireCrossing(prev, curr, tripwire) {
+      const movement = { p1: prev, p2: curr };
+      const intersection = lineIntersection(movement, tripwire);
+      if (intersection === null)
+        return null;
+      const twDx = tripwire.p2.x - tripwire.p1.x;
+      const twDy = tripwire.p2.y - tripwire.p1.y;
+      const movDx = curr.x - prev.x;
+      const movDy = curr.y - prev.y;
+      const cross = twDx * movDy - twDy * movDx;
+      const direction = cross > 0 ? "left" : "right";
+      return { crossed: true, direction };
     }
-    this.tracks = survived;
-    for (const detIdx of unmatchedDetections) {
-      const det = detections[detIdx];
-      this.createTrack(det, frameTimestamp);
+    function bboxCentroid(bbox) {
+      return {
+        x: bbox.x + bbox.w / 2,
+        y: bbox.y + bbox.h / 2
+      };
     }
-    return this.getConfirmedTracks();
-  }
-  getActiveTracks() {
-    return this.tracks.map(trackToTrackedDetection);
-  }
-  getLostTracks() {
-    return this.lostTracks.map(trackToTrackedDetection);
-  }
-  reset() {
-    this.tracks = [];
-    this.lostTracks = [];
-    this.nextTrackId = 1;
-  }
-  createTrack(det, timestamp) {
-    const track = {
-      id: String(this.nextTrackId++),
-      bbox: det.bbox,
-      class: det.class,
-      originalClass: det.originalClass,
-      score: det.score,
-      landmarks: det.landmarks,
-      age: 0,
-      hits: 1,
-      path: [],
-      firstSeen: timestamp,
-      lastSeen: timestamp,
-      velocity: { dx: 0, dy: 0 },
-      lost: false
-    };
-    this.tracks.push(track);
-    return track;
-  }
-  getConfirmedTracks() {
-    return this.tracks.filter((t) => t.hits >= this.config.minHits).map(trackToTrackedDetection);
-  }
-  ageTracksAndPruneLost(frameTimestamp) {
-    const survived = [];
-    for (const track of this.tracks) {
-      track.age++;
-      if (track.age > this.config.maxAge) {
-        track.lost = true;
-        this.lostTracks.push(track);
-      } else {
-        survived.push(track);
-      }
+    function normalizeToPixel(point, imageWidth, imageHeight) {
+      return {
+        x: point.x * imageWidth,
+        y: point.y * imageHeight
+      };
     }
-    this.tracks = survived;
-    void frameTimestamp;
   }
-};
+});
 
-// src/state/state-analyzer.ts
-var DEFAULT_STATE_ANALYZER_CONFIG = {
-  stationaryThresholdSec: 10,
-  loiteringThresholdSec: 60,
-  velocityThreshold: 2,
-  enteringFrames: 5
-};
-function magnitude(v) {
-  return Math.sqrt(v.dx * v.dx + v.dy * v.dy);
-}
-var StateAnalyzer = class {
-  states = /* @__PURE__ */ new Map();
-  config;
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_STATE_ANALYZER_CONFIG, ...config };
-  }
-  analyze(tracks, timestamp) {
-    const results = [];
-    const activeIds = /* @__PURE__ */ new Set();
-    for (const track of tracks) {
-      activeIds.add(track.trackId);
-      const prev = this.states.get(track.trackId);
-      const centroid = {
-        x: track.bbox.x + track.bbox.w / 2,
-        y: track.bbox.y + track.bbox.h / 2
-      };
-      const speed = track.velocity ? magnitude(track.velocity) : 0;
-      let enteredAt;
-      let stationarySince;
-      let totalDistancePx;
-      if (!prev) {
-        enteredAt = timestamp;
-        stationarySince = speed <= this.config.velocityThreshold ? timestamp : void 0;
-        totalDistancePx = 0;
-      } else {
-        enteredAt = prev.enteredAt;
-        const dx = centroid.x - prev.lastPosition.x;
-        const dy = centroid.y - prev.lastPosition.y;
-        const dist = Math.sqrt(dx * dx + dy * dy);
-        totalDistancePx = prev.totalDistancePx + dist;
-        if (speed > this.config.velocityThreshold) {
-          stationarySince = void 0;
-        } else {
-          stationarySince = prev.stationarySince ?? timestamp;
+// src/tracker/hungarian.js
+var require_hungarian = __commonJS({
+  "src/tracker/hungarian.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.greedyAssignment = greedyAssignment2;
+    function greedyAssignment2(costMatrix, threshold) {
+      const numTracks = costMatrix.length;
+      const numDetections = numTracks > 0 ? costMatrix[0]?.length ?? 0 : 0;
+      const candidates = [];
+      for (let t = 0; t < numTracks; t++) {
+        for (let d = 0; d < numDetections; d++) {
+          const iou = costMatrix[t][d] ?? 0;
+          if (iou >= threshold) {
+            candidates.push({ iou, trackIdx: t, detIdx: d });
+          }
         }
       }
-      const newInternal = {
-        enteredAt,
-        stationarySince,
-        totalDistancePx,
-        lastPosition: centroid
-      };
-      this.states.set(track.trackId, newInternal);
-      const dwellTimeMs = timestamp - enteredAt;
-      const state = this.computeObjectState(track.trackAge, speed, stationarySince, timestamp);
-      results.push({
-        trackId: track.trackId,
-        state,
-        stationarySince,
-        enteredAt,
-        totalDistancePx,
-        dwellTimeMs
-      });
-    }
-    for (const [id, internalState] of this.states) {
-      if (!activeIds.has(id)) {
-        results.push({
-          trackId: id,
-          state: "leaving",
-          stationarySince: internalState.stationarySince,
-          enteredAt: internalState.enteredAt,
-          totalDistancePx: internalState.totalDistancePx,
-          dwellTimeMs: timestamp - internalState.enteredAt
-        });
-        this.states.delete(id);
+      candidates.sort((a, b) => b.iou - a.iou);
+      const assignedTracks = /* @__PURE__ */ new Set();
+      const assignedDets = /* @__PURE__ */ new Set();
+      const matches = [];
+      for (const { trackIdx, detIdx } of candidates) {
+        if (assignedTracks.has(trackIdx) || assignedDets.has(detIdx))
+          continue;
+        matches.push([trackIdx, detIdx]);
+        assignedTracks.add(trackIdx);
+        assignedDets.add(detIdx);
       }
-    }
-    return results;
-  }
-  computeObjectState(trackAge, speed, stationarySince, timestamp) {
-    if (trackAge <= this.config.enteringFrames) {
-      return "entering";
-    }
-    if (stationarySince !== void 0) {
-      const stationaryDurationSec = (timestamp - stationarySince) / 1e3;
-      if (stationaryDurationSec >= this.config.loiteringThresholdSec) {
-        return "loitering";
+      const unmatchedTracks = [];
+      for (let t = 0; t < numTracks; t++) {
+        if (!assignedTracks.has(t))
+          unmatchedTracks.push(t);
       }
-      if (stationaryDurationSec >= this.config.stationaryThresholdSec) {
-        return "stationary";
+      const unmatchedDetections = [];
+      for (let d = 0; d < numDetections; d++) {
+        if (!assignedDets.has(d))
+          unmatchedDetections.push(d);
       }
+      return { matches, unmatchedTracks, unmatchedDetections };
     }
-    if (speed > this.config.velocityThreshold) {
-      return "moving";
-    }
-    return "moving";
   }
-};
+});
 
-// src/zones/zone-evaluator.ts
-var ZoneEvaluator = class {
-  /** Track which zones each track was in last frame */
-  trackZoneState = /* @__PURE__ */ new Map();
-  evaluate(tracks, zones, imageWidth, imageHeight, timestamp) {
-    const events = [];
-    const activeTrackIds = /* @__PURE__ */ new Set();
-    for (const track of tracks) {
-      activeTrackIds.add(track.trackId);
-      const centroid = bboxCentroid(track.bbox);
-      const prevZones = this.trackZoneState.get(track.trackId) ?? /* @__PURE__ */ new Set();
-      const currZones = /* @__PURE__ */ new Set();
-      for (const zone of zones) {
-        if (zone.alertOnClasses && zone.alertOnClasses.length > 0) {
-          if (!zone.alertOnClasses.includes(track.class)) continue;
+// src/tracker/sort-tracker.js
+var require_sort_tracker = __commonJS({
+  "src/tracker/sort-tracker.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SortTracker = exports.DEFAULT_TRACKER_CONFIG = void 0;
+    var hungarian_js_1 = require_hungarian();
+    var MAX_PATH_LENGTH = 300;
+    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 aArea = a.w * a.h;
+      const bArea = b.w * b.h;
+      const unionArea = aArea + bArea - interArea;
+      return unionArea <= 0 ? 0 : interArea / unionArea;
+    }
+    function trackToTrackedDetection(track) {
+      return {
+        class: track.class,
+        originalClass: track.originalClass,
+        score: track.score,
+        bbox: track.bbox,
+        landmarks: track.landmarks,
+        trackId: track.id,
+        trackAge: track.hits,
+        velocity: track.velocity,
+        path: track.path.slice()
+      };
+    }
+    function pushToRingBuffer(buffer, item, maxLength) {
+      if (buffer.length >= maxLength) {
+        buffer.shift();
+      }
+      buffer.push(item);
+    }
+    exports.DEFAULT_TRACKER_CONFIG = {
+      maxAge: 30,
+      minHits: 3,
+      iouThreshold: 0.3
+    };
+    var SortTracker2 = class {
+      tracks = [];
+      lostTracks = [];
+      nextTrackId = 1;
+      config;
+      constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_TRACKER_CONFIG, ...config };
+      }
+      update(detections, frameTimestamp) {
+        this.lostTracks = [];
+        if (this.tracks.length === 0) {
+          for (const det of detections) {
+            this.createTrack(det, frameTimestamp);
+          }
+          return this.getConfirmedTracks();
         }
-        if (zone.type === "polygon") {
-          const pixelPoints = zone.points.map((p) => normalizeToPixel(p, imageWidth, imageHeight));
-          const inside = pointInPolygon(centroid, pixelPoints);
-          if (inside) {
-            currZones.add(zone.id);
+        if (detections.length === 0) {
+          this.ageTracksAndPruneLost(frameTimestamp);
+          return this.getConfirmedTracks();
+        }
+        const costMatrix = this.tracks.map((track) => detections.map((det) => iou(track.bbox, det.bbox)));
+        const { matches, unmatchedTracks, unmatchedDetections } = (0, hungarian_js_1.greedyAssignment)(costMatrix, this.config.iouThreshold);
+        for (const [trackIdx, detIdx] of matches) {
+          const track = this.tracks[trackIdx];
+          const det = detections[detIdx];
+          const prevCx = track.bbox.x + track.bbox.w / 2;
+          const prevCy = track.bbox.y + track.bbox.h / 2;
+          const newCx = det.bbox.x + det.bbox.w / 2;
+          const newCy = det.bbox.y + det.bbox.h / 2;
+          pushToRingBuffer(track.path, track.bbox, MAX_PATH_LENGTH);
+          track.bbox = det.bbox;
+          track.class = det.class;
+          track.originalClass = det.originalClass;
+          track.score = det.score;
+          track.landmarks = det.landmarks;
+          track.age = 0;
+          track.hits++;
+          track.lastSeen = frameTimestamp;
+          track.velocity = { dx: newCx - prevCx, dy: newCy - prevCy };
+        }
+        for (const trackIdx of unmatchedTracks) {
+          const track = this.tracks[trackIdx];
+          track.age++;
+        }
+        const survived = [];
+        for (const track of this.tracks) {
+          if (track.age > this.config.maxAge) {
+            track.lost = true;
+            this.lostTracks.push(track);
+          } else {
+            survived.push(track);
           }
-          if (inside && !prevZones.has(zone.id)) {
-            events.push({
-              type: "zone-enter",
-              zoneId: zone.id,
-              zoneName: zone.name,
-              trackId: track.trackId,
-              detection: track,
-              timestamp
-            });
+        }
+        this.tracks = survived;
+        for (const detIdx of unmatchedDetections) {
+          const det = detections[detIdx];
+          this.createTrack(det, frameTimestamp);
+        }
+        return this.getConfirmedTracks();
+      }
+      getActiveTracks() {
+        return this.tracks.map(trackToTrackedDetection);
+      }
+      getLostTracks() {
+        return this.lostTracks.map(trackToTrackedDetection);
+      }
+      reset() {
+        this.tracks = [];
+        this.lostTracks = [];
+        this.nextTrackId = 1;
+      }
+      createTrack(det, timestamp) {
+        const track = {
+          id: String(this.nextTrackId++),
+          bbox: det.bbox,
+          class: det.class,
+          originalClass: det.originalClass,
+          score: det.score,
+          landmarks: det.landmarks,
+          age: 0,
+          hits: 1,
+          path: [],
+          firstSeen: timestamp,
+          lastSeen: timestamp,
+          velocity: { dx: 0, dy: 0 },
+          lost: false
+        };
+        this.tracks.push(track);
+        return track;
+      }
+      getConfirmedTracks() {
+        return this.tracks.filter((t) => t.hits >= this.config.minHits).map(trackToTrackedDetection);
+      }
+      ageTracksAndPruneLost(frameTimestamp) {
+        const survived = [];
+        for (const track of this.tracks) {
+          track.age++;
+          if (track.age > this.config.maxAge) {
+            track.lost = true;
+            this.lostTracks.push(track);
+          } else {
+            survived.push(track);
           }
-          if (!inside && prevZones.has(zone.id)) {
-            events.push({
-              type: "zone-exit",
-              zoneId: zone.id,
-              zoneName: zone.name,
-              trackId: track.trackId,
-              detection: track,
-              timestamp
-            });
+        }
+        this.tracks = survived;
+        void frameTimestamp;
+      }
+    };
+    exports.SortTracker = SortTracker2;
+  }
+});
+
+// src/state/state-analyzer.js
+var require_state_analyzer = __commonJS({
+  "src/state/state-analyzer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StateAnalyzer = exports.DEFAULT_STATE_ANALYZER_CONFIG = void 0;
+    exports.DEFAULT_STATE_ANALYZER_CONFIG = {
+      stationaryThresholdSec: 10,
+      loiteringThresholdSec: 60,
+      velocityThreshold: 2,
+      enteringFrames: 5
+    };
+    function magnitude(v) {
+      return Math.sqrt(v.dx * v.dx + v.dy * v.dy);
+    }
+    var StateAnalyzer2 = class {
+      states = /* @__PURE__ */ new Map();
+      config;
+      constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_STATE_ANALYZER_CONFIG, ...config };
+      }
+      analyze(tracks, timestamp) {
+        const results = [];
+        const activeIds = /* @__PURE__ */ new Set();
+        for (const track of tracks) {
+          activeIds.add(track.trackId);
+          const prev = this.states.get(track.trackId);
+          const centroid = {
+            x: track.bbox.x + track.bbox.w / 2,
+            y: track.bbox.y + track.bbox.h / 2
+          };
+          const speed = track.velocity ? magnitude(track.velocity) : 0;
+          let enteredAt;
+          let stationarySince;
+          let totalDistancePx;
+          if (!prev) {
+            enteredAt = timestamp;
+            stationarySince = speed <= this.config.velocityThreshold ? timestamp : void 0;
+            totalDistancePx = 0;
+          } else {
+            enteredAt = prev.enteredAt;
+            const dx = centroid.x - prev.lastPosition.x;
+            const dy = centroid.y - prev.lastPosition.y;
+            const dist = Math.sqrt(dx * dx + dy * dy);
+            totalDistancePx = prev.totalDistancePx + dist;
+            if (speed > this.config.velocityThreshold) {
+              stationarySince = void 0;
+            } else {
+              stationarySince = prev.stationarySince ?? timestamp;
+            }
           }
-        } else if (zone.type === "tripwire" && track.path.length >= 1) {
-          const prevBbox = track.path[track.path.length - 1];
-          if (!prevBbox) continue;
-          const prevCentroid = bboxCentroid(prevBbox);
-          const p0 = zone.points[0];
-          const p1 = zone.points[1];
-          if (!p0 || !p1) continue;
-          const tripwireLine = {
-            p1: normalizeToPixel(p0, imageWidth, imageHeight),
-            p2: normalizeToPixel(p1, imageWidth, imageHeight)
+          const newInternal = {
+            enteredAt,
+            stationarySince,
+            totalDistancePx,
+            lastPosition: centroid
           };
-          const cross = tripwireCrossing(prevCentroid, centroid, tripwireLine);
-          if (cross?.crossed) {
-            events.push({
-              type: "tripwire-cross",
-              zoneId: zone.id,
-              zoneName: zone.name,
-              trackId: track.trackId,
-              detection: track,
-              direction: cross.direction,
-              timestamp
+          this.states.set(track.trackId, newInternal);
+          const dwellTimeMs = timestamp - enteredAt;
+          const state = this.computeObjectState(track.trackAge, speed, stationarySince, timestamp);
+          results.push({
+            trackId: track.trackId,
+            state,
+            stationarySince,
+            enteredAt,
+            totalDistancePx,
+            dwellTimeMs
+          });
+        }
+        for (const [id, internalState] of this.states) {
+          if (!activeIds.has(id)) {
+            results.push({
+              trackId: id,
+              state: "leaving",
+              stationarySince: internalState.stationarySince,
+              enteredAt: internalState.enteredAt,
+              totalDistancePx: internalState.totalDistancePx,
+              dwellTimeMs: timestamp - internalState.enteredAt
             });
+            this.states.delete(id);
           }
         }
+        return results;
       }
-      this.trackZoneState.set(track.trackId, currZones);
-    }
-    for (const trackId of this.trackZoneState.keys()) {
-      if (!activeTrackIds.has(trackId)) {
-        this.trackZoneState.delete(trackId);
+      computeObjectState(trackAge, speed, stationarySince, timestamp) {
+        if (trackAge <= this.config.enteringFrames) {
+          return "entering";
+        }
+        if (stationarySince !== void 0) {
+          const stationaryDurationSec = (timestamp - stationarySince) / 1e3;
+          if (stationaryDurationSec >= this.config.loiteringThresholdSec) {
+            return "loitering";
+          }
+          if (stationaryDurationSec >= this.config.stationaryThresholdSec) {
+            return "stationary";
+          }
+        }
+        if (speed > this.config.velocityThreshold) {
+          return "moving";
+        }
+        return "moving";
       }
-    }
-    return events;
-  }
-  /** Returns a snapshot of the current track → zones mapping */
-  getTrackZones() {
-    return new Map(this.trackZoneState);
+    };
+    exports.StateAnalyzer = StateAnalyzer2;
   }
-};
+});
 
-// src/events/event-filters.ts
-var DEFAULT_EVENT_FILTER_CONFIG = {
-  minTrackAge: 3,
-  cooldownSec: 5,
-  enabledTypes: [
-    "object.entering",
-    "object.leaving",
-    "object.stationary",
-    "object.loitering",
-    "zone.enter",
-    "zone.exit",
-    "tripwire.cross"
-  ]
-};
-var EventFilter = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /** key: `${trackId}:${eventType}` → last emitted timestamp */
-  lastEmitted = /* @__PURE__ */ new Map();
-  shouldEmit(trackId, eventType, trackAge, timestamp) {
-    if (!this.config.enabledTypes.includes(eventType)) return false;
-    if (trackAge < this.config.minTrackAge) return false;
-    const key = `${trackId}:${eventType}`;
-    const last = this.lastEmitted.get(key);
-    if (last !== void 0 && timestamp - last < this.config.cooldownSec * 1e3) return false;
-    this.lastEmitted.set(key, timestamp);
-    return true;
-  }
-  /** Record an emission without a gate check — for events that bypass normal cooldown logic */
-  recordEmission(trackId, eventType, timestamp) {
-    const key = `${trackId}:${eventType}`;
-    this.lastEmitted.set(key, timestamp);
-  }
-  /** Remove cooldown entries for tracks that are no longer active */
-  cleanup(activeTrackIds) {
-    for (const key of this.lastEmitted.keys()) {
-      const colonIdx = key.indexOf(":");
-      if (colonIdx === -1) continue;
-      const trackId = key.slice(0, colonIdx);
-      if (!activeTrackIds.has(trackId)) {
-        this.lastEmitted.delete(key);
+// src/zones/zone-evaluator.js
+var require_zone_evaluator = __commonJS({
+  "src/zones/zone-evaluator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ZoneEvaluator = void 0;
+    var geometry_js_1 = require_geometry();
+    var ZoneEvaluator2 = class {
+      /** Track which zones each track was in last frame */
+      trackZoneState = /* @__PURE__ */ new Map();
+      evaluate(tracks, zones, imageWidth, imageHeight, timestamp) {
+        const events = [];
+        const activeTrackIds = /* @__PURE__ */ new Set();
+        for (const track of tracks) {
+          activeTrackIds.add(track.trackId);
+          const centroid = (0, geometry_js_1.bboxCentroid)(track.bbox);
+          const prevZones = this.trackZoneState.get(track.trackId) ?? /* @__PURE__ */ new Set();
+          const currZones = /* @__PURE__ */ new Set();
+          for (const zone of zones) {
+            if (zone.alertOnClasses && zone.alertOnClasses.length > 0) {
+              if (!zone.alertOnClasses.includes(track.class))
+                continue;
+            }
+            if (zone.type === "polygon") {
+              const pixelPoints = zone.points.map((p) => (0, geometry_js_1.normalizeToPixel)(p, imageWidth, imageHeight));
+              const inside = (0, geometry_js_1.pointInPolygon)(centroid, pixelPoints);
+              if (inside) {
+                currZones.add(zone.id);
+              }
+              if (inside && !prevZones.has(zone.id)) {
+                events.push({
+                  type: "zone-enter",
+                  zoneId: zone.id,
+                  zoneName: zone.name,
+                  trackId: track.trackId,
+                  detection: track,
+                  timestamp
+                });
+              }
+              if (!inside && prevZones.has(zone.id)) {
+                events.push({
+                  type: "zone-exit",
+                  zoneId: zone.id,
+                  zoneName: zone.name,
+                  trackId: track.trackId,
+                  detection: track,
+                  timestamp
+                });
+              }
+            } else if (zone.type === "tripwire" && track.path.length >= 1) {
+              const prevBbox = track.path[track.path.length - 1];
+              if (!prevBbox)
+                continue;
+              const prevCentroid = (0, geometry_js_1.bboxCentroid)(prevBbox);
+              const p0 = zone.points[0];
+              const p1 = zone.points[1];
+              if (!p0 || !p1)
+                continue;
+              const tripwireLine = {
+                p1: (0, geometry_js_1.normalizeToPixel)(p0, imageWidth, imageHeight),
+                p2: (0, geometry_js_1.normalizeToPixel)(p1, imageWidth, imageHeight)
+              };
+              const cross = (0, geometry_js_1.tripwireCrossing)(prevCentroid, centroid, tripwireLine);
+              if (cross?.crossed) {
+                events.push({
+                  type: "tripwire-cross",
+                  zoneId: zone.id,
+                  zoneName: zone.name,
+                  trackId: track.trackId,
+                  detection: track,
+                  direction: cross.direction,
+                  timestamp
+                });
+              }
+            }
+          }
+          this.trackZoneState.set(track.trackId, currZones);
+        }
+        for (const trackId of this.trackZoneState.keys()) {
+          if (!activeTrackIds.has(trackId)) {
+            this.trackZoneState.delete(trackId);
+          }
+        }
+        return events;
       }
-    }
-  }
-  /** Reset all cooldown state */
-  reset() {
-    this.lastEmitted.clear();
+      /** Returns a snapshot of the current track → zones mapping */
+      getTrackZones() {
+        return new Map(this.trackZoneState);
+      }
+    };
+    exports.ZoneEvaluator = ZoneEvaluator2;
   }
-};
+});
 
-// src/events/event-emitter.ts
-import { randomUUID } from "crypto";
-var DetectionEventEmitter = class {
-  filter;
-  /** trackId → last known ObjectState */
-  previousStates = /* @__PURE__ */ new Map();
-  constructor(filterConfig = {}) {
-    this.filter = new EventFilter({ ...DEFAULT_EVENT_FILTER_CONFIG, ...filterConfig });
-  }
-  emit(tracks, states, zoneEvents, classifications, deviceId) {
-    const events = [];
-    const timestamp = Date.now();
-    const trackMap = /* @__PURE__ */ new Map();
-    for (const t of tracks) trackMap.set(t.trackId, t);
-    const stateMap = /* @__PURE__ */ new Map();
-    for (const s of states) stateMap.set(s.trackId, s);
-    const classifMap = /* @__PURE__ */ new Map();
-    for (const c of classifications) classifMap.set(c.trackId, c.classifications);
-    for (const state of states) {
-      const track = trackMap.get(state.trackId);
-      if (!track) continue;
-      const prevState = this.previousStates.get(state.trackId);
-      const classifs = classifMap.get(state.trackId) ?? [];
-      if (state.state === "entering" && prevState === void 0) {
-        this.tryEmit(events, "object.entering", track, state, classifs, [], deviceId, timestamp);
-      }
-      if (state.state === "leaving") {
-        this.tryEmit(events, "object.leaving", track, state, classifs, [], deviceId, timestamp);
-      }
-      if (state.state === "stationary" && prevState !== void 0 && prevState !== "stationary" && prevState !== "loitering") {
-        this.tryEmit(events, "object.stationary", track, state, classifs, [], deviceId, timestamp);
-      }
-      if (state.state === "loitering" && prevState === "stationary") {
-        this.tryEmit(events, "object.loitering", track, state, classifs, [], deviceId, timestamp);
-      }
-      if (state.state !== "leaving") {
-        this.previousStates.set(state.trackId, state.state);
-      } else {
-        this.previousStates.delete(state.trackId);
+// src/events/event-filters.js
+var require_event_filters = __commonJS({
+  "src/events/event-filters.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventFilter = exports.DEFAULT_EVENT_FILTER_CONFIG = void 0;
+    exports.DEFAULT_EVENT_FILTER_CONFIG = {
+      minTrackAge: 3,
+      cooldownSec: 5,
+      enabledTypes: [
+        "object.entering",
+        "object.leaving",
+        "object.stationary",
+        "object.loitering",
+        "zone.enter",
+        "zone.exit",
+        "tripwire.cross"
+      ]
+    };
+    var EventFilter2 = class {
+      config;
+      /** key: `${trackId}:${eventType}` → last emitted timestamp */
+      lastEmitted = /* @__PURE__ */ new Map();
+      constructor(config) {
+        this.config = config;
       }
-    }
-    for (const ze of zoneEvents) {
-      const track = trackMap.get(ze.trackId);
-      if (!track) continue;
-      const state = stateMap.get(ze.trackId);
-      if (!state) continue;
-      let eventType;
-      if (ze.type === "tripwire-cross") {
-        eventType = "tripwire.cross";
-      } else if (ze.type === "zone-enter") {
-        eventType = "zone.enter";
-      } else {
-        eventType = "zone.exit";
-      }
-      const classifs = classifMap.get(ze.trackId) ?? [];
-      this.tryEmit(events, eventType, track, state, classifs, [ze], deviceId, timestamp);
-    }
-    const activeIds = new Set(tracks.map((t) => t.trackId));
-    this.filter.cleanup(activeIds);
-    return events;
-  }
-  tryEmit(events, eventType, track, state, classifications, zoneEvents, deviceId, timestamp) {
-    if (!this.filter.shouldEmit(track.trackId, eventType, track.trackAge, timestamp)) return;
-    events.push({
-      id: randomUUID(),
-      type: eventType,
-      timestamp,
-      deviceId,
-      detection: track,
-      classifications,
-      objectState: state,
-      zoneEvents,
-      trackPath: track.path
-    });
-  }
-  reset() {
-    this.previousStates.clear();
-    this.filter.reset();
+      shouldEmit(trackId, eventType, trackAge, timestamp) {
+        if (!this.config.enabledTypes.includes(eventType))
+          return false;
+        if (trackAge < this.config.minTrackAge)
+          return false;
+        const key = `${trackId}:${eventType}`;
+        const last = this.lastEmitted.get(key);
+        if (last !== void 0 && timestamp - last < this.config.cooldownSec * 1e3)
+          return false;
+        this.lastEmitted.set(key, timestamp);
+        return true;
+      }
+      /** Record an emission without a gate check — for events that bypass normal cooldown logic */
+      recordEmission(trackId, eventType, timestamp) {
+        const key = `${trackId}:${eventType}`;
+        this.lastEmitted.set(key, timestamp);
+      }
+      /** Remove cooldown entries for tracks that are no longer active */
+      cleanup(activeTrackIds) {
+        for (const key of this.lastEmitted.keys()) {
+          const colonIdx = key.indexOf(":");
+          if (colonIdx === -1)
+            continue;
+          const trackId = key.slice(0, colonIdx);
+          if (!activeTrackIds.has(trackId)) {
+            this.lastEmitted.delete(key);
+          }
+        }
+      }
+      /** Reset all cooldown state */
+      reset() {
+        this.lastEmitted.clear();
+      }
+    };
+    exports.EventFilter = EventFilter2;
   }
-};
+});
 
-// src/analytics/track-store.ts
-var MAX_PATH_LENGTH2 = 300;
-var TrackStore = class {
-  activeTracks = /* @__PURE__ */ new Map();
-  update(tracks, states, zoneEvents, classifications) {
-    const stateMap = /* @__PURE__ */ new Map();
-    for (const s of states) stateMap.set(s.trackId, s);
-    const classifMap = /* @__PURE__ */ new Map();
-    for (const c of classifications) classifMap.set(c.trackId, c.classifications);
-    const now = Date.now();
-    for (const track of tracks) {
-      let acc = this.activeTracks.get(track.trackId);
-      if (!acc) {
-        acc = {
-          trackId: track.trackId,
-          class: track.class,
-          originalClass: track.originalClass,
-          state: "entering",
-          firstSeen: track.path.length === 0 ? now : now,
-          lastSeen: now,
-          path: [],
-          zoneTransitions: [],
-          events: []
-        };
-        this.activeTracks.set(track.trackId, acc);
-      }
-      acc.class = track.class;
-      acc.originalClass = track.originalClass;
-      acc.lastSeen = now;
-      const state = stateMap.get(track.trackId);
-      if (state) acc.state = state.state;
-      const pathPoint = {
-        timestamp: now,
-        bbox: track.bbox,
-        velocity: track.velocity ?? { dx: 0, dy: 0 }
-      };
-      if (acc.path.length >= MAX_PATH_LENGTH2) {
-        acc.path.shift();
-      }
-      acc.path.push(pathPoint);
-      const classifs = classifMap.get(track.trackId) ?? [];
-      for (const c of classifs) {
-        if (c.metadata?.type === "face-recognition" && typeof c.text === "string") {
-          acc.identity = { name: c.text, confidence: c.score, matchedAt: now };
-        } else if (c.metadata?.type === "plate-recognition" && typeof c.text === "string") {
-          acc.plateText = { text: c.text, confidence: c.score, readAt: now };
-        } else if (c.metadata?.type === "sub-class") {
-          acc.subClass = { class: c.class, confidence: c.score };
-        }
+// src/events/event-emitter.js
+var require_event_emitter = __commonJS({
+  "src/events/event-emitter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DetectionEventEmitter = void 0;
+    var node_crypto_1 = __require("crypto");
+    var event_filters_js_1 = require_event_filters();
+    var DetectionEventEmitter2 = class {
+      filter;
+      /** trackId → last known ObjectState */
+      previousStates = /* @__PURE__ */ new Map();
+      constructor(filterConfig = {}) {
+        this.filter = new event_filters_js_1.EventFilter({ ...event_filters_js_1.DEFAULT_EVENT_FILTER_CONFIG, ...filterConfig });
       }
-    }
-    for (const ze of zoneEvents) {
-      const acc = this.activeTracks.get(ze.trackId);
-      if (!acc) continue;
-      if (ze.type === "zone-enter") {
-        acc.zoneTransitions.push({
-          zoneId: ze.zoneId,
-          zoneName: ze.zoneName,
-          entered: ze.timestamp,
-          dwellMs: 0
-        });
-      } else if (ze.type === "zone-exit") {
-        let openIdx = -1;
-        for (let i = acc.zoneTransitions.length - 1; i >= 0; i--) {
-          const t = acc.zoneTransitions[i];
-          if (t.zoneId === ze.zoneId && t.exited === void 0) {
-            openIdx = i;
-            break;
+      emit(tracks, states, zoneEvents, classifications, deviceId) {
+        const events = [];
+        const timestamp = Date.now();
+        const trackMap = /* @__PURE__ */ new Map();
+        for (const t of tracks)
+          trackMap.set(t.trackId, t);
+        const stateMap = /* @__PURE__ */ new Map();
+        for (const s of states)
+          stateMap.set(s.trackId, s);
+        const classifMap = /* @__PURE__ */ new Map();
+        for (const c of classifications)
+          classifMap.set(c.trackId, c.classifications);
+        for (const state of states) {
+          const track = trackMap.get(state.trackId);
+          if (!track)
+            continue;
+          const prevState = this.previousStates.get(state.trackId);
+          const classifs = classifMap.get(state.trackId) ?? [];
+          if (state.state === "entering" && prevState === void 0) {
+            this.tryEmit(events, "object.entering", track, state, classifs, [], deviceId, timestamp);
+          }
+          if (state.state === "leaving") {
+            this.tryEmit(events, "object.leaving", track, state, classifs, [], deviceId, timestamp);
+          }
+          if (state.state === "stationary" && prevState !== void 0 && prevState !== "stationary" && prevState !== "loitering") {
+            this.tryEmit(events, "object.stationary", track, state, classifs, [], deviceId, timestamp);
+          }
+          if (state.state === "loitering" && prevState === "stationary") {
+            this.tryEmit(events, "object.loitering", track, state, classifs, [], deviceId, timestamp);
+          }
+          if (state.state !== "leaving") {
+            this.previousStates.set(state.trackId, state.state);
+          } else {
+            this.previousStates.delete(state.trackId);
           }
         }
-        if (openIdx >= 0) {
-          const open = acc.zoneTransitions[openIdx];
-          acc.zoneTransitions[openIdx] = {
-            ...open,
-            exited: ze.timestamp,
-            dwellMs: ze.timestamp - open.entered
-          };
+        for (const ze of zoneEvents) {
+          const track = trackMap.get(ze.trackId);
+          if (!track)
+            continue;
+          const state = stateMap.get(ze.trackId);
+          if (!state)
+            continue;
+          let eventType;
+          if (ze.type === "tripwire-cross") {
+            eventType = "tripwire.cross";
+          } else if (ze.type === "zone-enter") {
+            eventType = "zone.enter";
+          } else {
+            eventType = "zone.exit";
+          }
+          const classifs = classifMap.get(ze.trackId) ?? [];
+          this.tryEmit(events, eventType, track, state, classifs, [ze], deviceId, timestamp);
         }
+        const activeIds = new Set(tracks.map((t) => t.trackId));
+        this.filter.cleanup(activeIds);
+        return events;
+      }
+      tryEmit(events, eventType, track, state, classifications, zoneEvents, deviceId, timestamp) {
+        if (!this.filter.shouldEmit(track.trackId, eventType, track.trackAge, timestamp))
+          return;
+        events.push({
+          id: (0, node_crypto_1.randomUUID)(),
+          type: eventType,
+          timestamp,
+          deviceId,
+          detection: track,
+          classifications,
+          objectState: state,
+          zoneEvents,
+          trackPath: track.path
+        });
+      }
+      reset() {
+        this.previousStates.clear();
+        this.filter.reset();
       }
-    }
-  }
-  /** Attach a DetectionEvent to its associated track accumulator */
-  addEvent(trackId, event) {
-    const acc = this.activeTracks.get(trackId);
-    if (!acc) return;
-    acc.events.push(event);
-    if (event.snapshot && !acc.bestSnapshot) {
-      acc.bestSnapshot = event.snapshot;
-    }
-  }
-  /** Get accumulated detail for an active track */
-  getTrackDetail(trackId) {
-    const acc = this.activeTracks.get(trackId);
-    if (!acc) return null;
-    return this.buildTrackDetail(acc);
-  }
-  /** Called when a track ends — returns complete TrackDetail and removes from active set */
-  finishTrack(trackId) {
-    const acc = this.activeTracks.get(trackId);
-    if (!acc) return null;
-    const detail = this.buildTrackDetail(acc);
-    this.activeTracks.delete(trackId);
-    return detail;
-  }
-  /** Get all active track IDs */
-  getActiveTrackIds() {
-    return Array.from(this.activeTracks.keys());
-  }
-  /** Clear all accumulated state */
-  reset() {
-    this.activeTracks.clear();
-  }
-  buildTrackDetail(acc) {
-    return {
-      trackId: acc.trackId,
-      class: acc.class,
-      originalClass: acc.originalClass,
-      state: acc.state,
-      firstSeen: acc.firstSeen,
-      lastSeen: acc.lastSeen,
-      totalDwellMs: acc.lastSeen - acc.firstSeen,
-      path: acc.path,
-      identity: acc.identity,
-      plateText: acc.plateText,
-      subClass: acc.subClass,
-      zoneTransitions: acc.zoneTransitions,
-      bestSnapshot: acc.bestSnapshot,
-      events: acc.events
     };
+    exports.DetectionEventEmitter = DetectionEventEmitter2;
   }
-};
+});
 
-// src/analytics/live-state-manager.ts
-var FpsCounter = class {
-  frameTimes = [];
-  windowMs = 5e3;
-  tick(timestamp) {
-    this.frameTimes.push(timestamp);
-    const cutoff = timestamp - this.windowMs;
-    while (this.frameTimes.length > 0 && this.frameTimes[0] < cutoff) {
-      this.frameTimes.shift();
-    }
-  }
-  getFps() {
-    if (this.frameTimes.length < 2) return 0;
-    const oldest = this.frameTimes[0];
-    const newest = this.frameTimes[this.frameTimes.length - 1];
-    const durationSec = (newest - oldest) / 1e3;
-    if (durationSec <= 0) return 0;
-    return (this.frameTimes.length - 1) / durationSec;
-  }
-};
-var LiveStateManager = class {
-  zones = [];
-  fpsCounter = new FpsCounter();
-  pipelineMsHistory = [];
-  maxPipelineHistory = 30;
-  setZones(zones) {
-    this.zones = [...zones];
-  }
-  buildState(deviceId, tracks, states, trackZones, pipelineStatus, pipelineMs, lastEvent, timestamp) {
-    this.fpsCounter.tick(timestamp);
-    if (this.pipelineMsHistory.length >= this.maxPipelineHistory) {
-      this.pipelineMsHistory.shift();
-    }
-    this.pipelineMsHistory.push(pipelineMs);
-    const avgPipelineMs = this.pipelineMsHistory.length === 0 ? 0 : this.pipelineMsHistory.reduce((sum, v) => sum + v, 0) / this.pipelineMsHistory.length;
-    const stateMap = /* @__PURE__ */ new Map();
-    for (const s of states) stateMap.set(s.trackId, s);
-    const trackSummaries = tracks.map((track) => {
-      const state = stateMap.get(track.trackId);
-      const inZones = Array.from(trackZones.get(track.trackId) ?? []);
-      return {
-        trackId: track.trackId,
-        class: track.class,
-        originalClass: track.originalClass,
-        state: state?.state ?? "moving",
-        bbox: track.bbox,
-        velocity: track.velocity ?? { dx: 0, dy: 0 },
-        dwellTimeMs: state?.dwellTimeMs ?? 0,
-        inZones
-      };
-    });
-    let movingObjects = 0;
-    let stationaryObjects = 0;
-    for (const summary of trackSummaries) {
-      if (summary.state === "moving" || summary.state === "entering") movingObjects++;
-      else if (summary.state === "stationary" || summary.state === "loitering") stationaryObjects++;
-    }
-    const objectCounts = {};
-    for (const summary of trackSummaries) {
-      objectCounts[summary.class] = (objectCounts[summary.class] ?? 0) + 1;
-    }
-    const zoneLiveStates = this.zones.map((zone) => {
-      const tracksInZone = trackSummaries.filter((t) => t.inZones.includes(zone.id));
-      const objectsByClass = {};
-      const loiteringTracks = [];
-      for (const t of tracksInZone) {
-        objectsByClass[t.class] = (objectsByClass[t.class] ?? 0) + 1;
-        if (t.state === "loitering") loiteringTracks.push(t.trackId);
-      }
-      const avgDwellTimeMs = tracksInZone.length === 0 ? 0 : tracksInZone.reduce((sum, t) => sum + t.dwellTimeMs, 0) / tracksInZone.length;
-      return {
-        zoneId: zone.id,
-        zoneName: zone.name,
-        occupied: tracksInZone.length > 0,
-        objectCount: tracksInZone.length,
-        objectsByClass,
-        trackIds: tracksInZone.map((t) => t.trackId),
-        avgDwellTimeMs,
-        totalEntrancesToday: 0,
-        // requires DB — left for server orchestrator
-        totalExitsToday: 0,
-        loiteringTracks
-      };
-    });
-    return {
-      deviceId,
-      lastFrameTimestamp: timestamp,
-      activeObjects: trackSummaries.length,
-      movingObjects,
-      stationaryObjects,
-      objectCounts,
-      tracks: trackSummaries,
-      zones: zoneLiveStates,
-      lastEvent,
-      pipelineStatus,
-      avgPipelineMs,
-      currentFps: this.fpsCounter.getFps()
+// src/analytics/track-store.js
+var require_track_store = __commonJS({
+  "src/analytics/track-store.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TrackStore = void 0;
+    var MAX_PATH_LENGTH = 300;
+    var TrackStore2 = class {
+      activeTracks = /* @__PURE__ */ new Map();
+      update(tracks, states, zoneEvents, classifications) {
+        const stateMap = /* @__PURE__ */ new Map();
+        for (const s of states)
+          stateMap.set(s.trackId, s);
+        const classifMap = /* @__PURE__ */ new Map();
+        for (const c of classifications)
+          classifMap.set(c.trackId, c.classifications);
+        const now = Date.now();
+        for (const track of tracks) {
+          let acc = this.activeTracks.get(track.trackId);
+          if (!acc) {
+            acc = {
+              trackId: track.trackId,
+              class: track.class,
+              originalClass: track.originalClass,
+              state: "entering",
+              firstSeen: track.path.length === 0 ? now : now,
+              lastSeen: now,
+              path: [],
+              zoneTransitions: [],
+              events: []
+            };
+            this.activeTracks.set(track.trackId, acc);
+          }
+          acc.class = track.class;
+          acc.originalClass = track.originalClass;
+          acc.lastSeen = now;
+          const state = stateMap.get(track.trackId);
+          if (state)
+            acc.state = state.state;
+          const pathPoint = {
+            timestamp: now,
+            bbox: track.bbox,
+            velocity: track.velocity ?? { dx: 0, dy: 0 }
+          };
+          if (acc.path.length >= MAX_PATH_LENGTH) {
+            acc.path.shift();
+          }
+          acc.path.push(pathPoint);
+          const classifs = classifMap.get(track.trackId) ?? [];
+          for (const c of classifs) {
+            if (c.metadata?.type === "face-recognition" && typeof c.text === "string") {
+              acc.identity = { name: c.text, confidence: c.score, matchedAt: now };
+            } else if (c.metadata?.type === "plate-recognition" && typeof c.text === "string") {
+              acc.plateText = { text: c.text, confidence: c.score, readAt: now };
+            } else if (c.metadata?.type === "sub-class") {
+              acc.subClass = { class: c.class, confidence: c.score };
+            }
+          }
+        }
+        for (const ze of zoneEvents) {
+          const acc = this.activeTracks.get(ze.trackId);
+          if (!acc)
+            continue;
+          if (ze.type === "zone-enter") {
+            acc.zoneTransitions.push({
+              zoneId: ze.zoneId,
+              zoneName: ze.zoneName,
+              entered: ze.timestamp,
+              dwellMs: 0
+            });
+          } else if (ze.type === "zone-exit") {
+            let openIdx = -1;
+            for (let i = acc.zoneTransitions.length - 1; i >= 0; i--) {
+              const t = acc.zoneTransitions[i];
+              if (t.zoneId === ze.zoneId && t.exited === void 0) {
+                openIdx = i;
+                break;
+              }
+            }
+            if (openIdx >= 0) {
+              const open = acc.zoneTransitions[openIdx];
+              acc.zoneTransitions[openIdx] = {
+                ...open,
+                exited: ze.timestamp,
+                dwellMs: ze.timestamp - open.entered
+              };
+            }
+          }
+        }
+      }
+      /** Attach a DetectionEvent to its associated track accumulator */
+      addEvent(trackId, event) {
+        const acc = this.activeTracks.get(trackId);
+        if (!acc)
+          return;
+        acc.events.push(event);
+        if (event.snapshot && !acc.bestSnapshot) {
+          acc.bestSnapshot = event.snapshot;
+        }
+      }
+      /** Get accumulated detail for an active track */
+      getTrackDetail(trackId) {
+        const acc = this.activeTracks.get(trackId);
+        if (!acc)
+          return null;
+        return this.buildTrackDetail(acc);
+      }
+      /** Called when a track ends — returns complete TrackDetail and removes from active set */
+      finishTrack(trackId) {
+        const acc = this.activeTracks.get(trackId);
+        if (!acc)
+          return null;
+        const detail = this.buildTrackDetail(acc);
+        this.activeTracks.delete(trackId);
+        return detail;
+      }
+      /** Get all active track IDs */
+      getActiveTrackIds() {
+        return Array.from(this.activeTracks.keys());
+      }
+      /** Clear all accumulated state */
+      reset() {
+        this.activeTracks.clear();
+      }
+      buildTrackDetail(acc) {
+        return {
+          trackId: acc.trackId,
+          class: acc.class,
+          originalClass: acc.originalClass,
+          state: acc.state,
+          firstSeen: acc.firstSeen,
+          lastSeen: acc.lastSeen,
+          totalDwellMs: acc.lastSeen - acc.firstSeen,
+          path: acc.path,
+          identity: acc.identity,
+          plateText: acc.plateText,
+          subClass: acc.subClass,
+          zoneTransitions: acc.zoneTransitions,
+          bestSnapshot: acc.bestSnapshot,
+          events: acc.events
+        };
+      }
     };
+    exports.TrackStore = TrackStore2;
   }
-  reset() {
-    this.pipelineMsHistory.length = 0;
-  }
-};
+});
 
-// src/analytics/heatmap-aggregator.ts
-var HeatmapAggregator = class {
-  constructor(width, height, gridSize) {
-    this.width = width;
-    this.height = height;
-    this.gridSize = gridSize;
-    if (gridSize <= 0) throw new Error("gridSize must be > 0");
-    this.grid = new Float32Array(gridSize * gridSize);
-  }
-  grid;
-  maxCount = 0;
-  /**
-   * Add a normalized point (0–1 range) to the heatmap.
-   * Points outside [0, 1] are clamped to the grid boundary.
-   */
-  addPoint(x, y) {
-    const col = Math.min(Math.floor(x * this.gridSize), this.gridSize - 1);
-    const row = Math.min(Math.floor(y * this.gridSize), this.gridSize - 1);
-    const idx = row * this.gridSize + col;
-    this.grid[idx] += 1;
-    if (this.grid[idx] > this.maxCount) {
-      this.maxCount = this.grid[idx];
-    }
-  }
-  /** Add a pixel-coordinate point. Normalizes against the configured width/height. */
-  addPixelPoint(px, py) {
-    this.addPoint(px / this.width, py / this.height);
-  }
-  getHeatmap() {
-    return {
-      width: this.width,
-      height: this.height,
-      gridSize: this.gridSize,
-      cells: new Float32Array(this.grid),
-      maxCount: this.maxCount
+// src/analytics/live-state-manager.js
+var require_live_state_manager = __commonJS({
+  "src/analytics/live-state-manager.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LiveStateManager = void 0;
+    var FpsCounter = class {
+      frameTimes = [];
+      windowMs = 5e3;
+      tick(timestamp) {
+        this.frameTimes.push(timestamp);
+        const cutoff = timestamp - this.windowMs;
+        while (this.frameTimes.length > 0 && this.frameTimes[0] < cutoff) {
+          this.frameTimes.shift();
+        }
+      }
+      getFps() {
+        if (this.frameTimes.length < 2)
+          return 0;
+        const oldest = this.frameTimes[0];
+        const newest = this.frameTimes[this.frameTimes.length - 1];
+        const durationSec = (newest - oldest) / 1e3;
+        if (durationSec <= 0)
+          return 0;
+        return (this.frameTimes.length - 1) / durationSec;
+      }
     };
-  }
-  reset() {
-    this.grid.fill(0);
-    this.maxCount = 0;
-  }
-  /** Total number of points accumulated */
-  get totalPoints() {
-    let total = 0;
-    for (let i = 0; i < this.grid.length; i++) {
-      total += this.grid[i];
-    }
-    return total;
-  }
-};
-
-// src/analytics/analytics-provider.ts
-var AnalyticsProvider = class {
-  constructor(liveStateManager, trackStore, getZoneHistoryCb, getHeatmapCb, lastLiveState = null) {
-    this.liveStateManager = liveStateManager;
-    this.trackStore = trackStore;
-    this.getZoneHistoryCb = getZoneHistoryCb;
-    this.getHeatmapCb = getHeatmapCb;
-    this.lastLiveState = lastLiveState;
-  }
-  /** Called by the orchestrator each frame to update the cached live state */
-  updateLiveState(state) {
-    this.lastLiveState = state;
-  }
-  getLiveState(_deviceId) {
-    return this.lastLiveState;
-  }
-  getTracks(_deviceId, filter) {
-    const tracks = this.lastLiveState?.tracks ?? [];
-    if (!filter) return [...tracks];
-    return tracks.filter((t) => {
-      if (filter.class && !filter.class.includes(t.class)) return false;
-      if (filter.state && !filter.state.includes(t.state)) return false;
-      if (filter.inZone && !t.inZones.includes(filter.inZone)) return false;
-      if (filter.minDwellMs !== void 0 && t.dwellTimeMs < filter.minDwellMs) return false;
-      return true;
-    });
-  }
-  getZoneState(_deviceId, zoneId) {
-    return this.lastLiveState?.zones.find((z) => z.zoneId === zoneId) ?? null;
-  }
-  async getZoneHistory(deviceId, zoneId, options) {
-    if (this.getZoneHistoryCb) {
-      return this.getZoneHistoryCb(deviceId, zoneId, options);
-    }
-    return [];
-  }
-  async getHeatmap(deviceId, options) {
-    if (this.getHeatmapCb) {
-      return this.getHeatmapCb(deviceId, options);
-    }
-    const gridSize = options.resolution;
-    return {
-      width: 1920,
-      height: 1080,
-      gridSize,
-      cells: new Float32Array(gridSize * gridSize),
-      maxCount: 0
+    var LiveStateManager2 = class {
+      zones = [];
+      fpsCounter = new FpsCounter();
+      pipelineMsHistory = [];
+      maxPipelineHistory = 30;
+      setZones(zones) {
+        this.zones = [...zones];
+      }
+      buildState(deviceId, tracks, states, trackZones, pipelineStatus, pipelineMs, lastEvent, timestamp) {
+        this.fpsCounter.tick(timestamp);
+        if (this.pipelineMsHistory.length >= this.maxPipelineHistory) {
+          this.pipelineMsHistory.shift();
+        }
+        this.pipelineMsHistory.push(pipelineMs);
+        const avgPipelineMs = this.pipelineMsHistory.length === 0 ? 0 : this.pipelineMsHistory.reduce((sum, v) => sum + v, 0) / this.pipelineMsHistory.length;
+        const stateMap = /* @__PURE__ */ new Map();
+        for (const s of states)
+          stateMap.set(s.trackId, s);
+        const trackSummaries = tracks.map((track) => {
+          const state = stateMap.get(track.trackId);
+          const inZones = Array.from(trackZones.get(track.trackId) ?? []);
+          return {
+            trackId: track.trackId,
+            class: track.class,
+            originalClass: track.originalClass,
+            state: state?.state ?? "moving",
+            bbox: track.bbox,
+            velocity: track.velocity ?? { dx: 0, dy: 0 },
+            dwellTimeMs: state?.dwellTimeMs ?? 0,
+            inZones
+          };
+        });
+        let movingObjects = 0;
+        let stationaryObjects = 0;
+        for (const summary of trackSummaries) {
+          if (summary.state === "moving" || summary.state === "entering")
+            movingObjects++;
+          else if (summary.state === "stationary" || summary.state === "loitering")
+            stationaryObjects++;
+        }
+        const objectCounts = {};
+        for (const summary of trackSummaries) {
+          objectCounts[summary.class] = (objectCounts[summary.class] ?? 0) + 1;
+        }
+        const zoneLiveStates = this.zones.map((zone) => {
+          const tracksInZone = trackSummaries.filter((t) => t.inZones.includes(zone.id));
+          const objectsByClass = {};
+          const loiteringTracks = [];
+          for (const t of tracksInZone) {
+            objectsByClass[t.class] = (objectsByClass[t.class] ?? 0) + 1;
+            if (t.state === "loitering")
+              loiteringTracks.push(t.trackId);
+          }
+          const avgDwellTimeMs = tracksInZone.length === 0 ? 0 : tracksInZone.reduce((sum, t) => sum + t.dwellTimeMs, 0) / tracksInZone.length;
+          return {
+            zoneId: zone.id,
+            zoneName: zone.name,
+            occupied: tracksInZone.length > 0,
+            objectCount: tracksInZone.length,
+            objectsByClass,
+            trackIds: tracksInZone.map((t) => t.trackId),
+            avgDwellTimeMs,
+            totalEntrancesToday: 0,
+            // requires DB — left for server orchestrator
+            totalExitsToday: 0,
+            loiteringTracks
+          };
+        });
+        return {
+          deviceId,
+          lastFrameTimestamp: timestamp,
+          activeObjects: trackSummaries.length,
+          movingObjects,
+          stationaryObjects,
+          objectCounts,
+          tracks: trackSummaries,
+          zones: zoneLiveStates,
+          lastEvent,
+          pipelineStatus,
+          avgPipelineMs,
+          currentFps: this.fpsCounter.getFps()
+        };
+      }
+      reset() {
+        this.pipelineMsHistory.length = 0;
+      }
     };
+    exports.LiveStateManager = LiveStateManager2;
   }
-  getTrackDetail(_deviceId, trackId) {
-    return this.trackStore.getTrackDetail(trackId);
-  }
-  getCameraStatus(_deviceId) {
-    return this.lastLiveState ? [...this.lastLiveState.pipelineStatus] : [];
-  }
-};
+});
 
-// src/snapshots/snapshot-manager.ts
-var DEFAULT_SNAPSHOT_CONFIG = {
-  enabled: false,
-  saveThumbnail: true,
-  saveAnnotatedFrame: false,
-  saveDebugThumbnails: false
-};
-var SnapshotManager = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async capture(frame, detection, allDetections, eventId) {
-    if (!this.config.enabled) return void 0;
-    await this.ensureOutputDir();
-    let thumbnailPath;
-    let annotatedFramePath;
-    if (this.config.saveThumbnail) {
-      thumbnailPath = await this.saveThumbnail(frame, detection.bbox, eventId);
-    }
-    if (this.config.saveAnnotatedFrame) {
-      annotatedFramePath = await this.saveAnnotatedFrame(frame, allDetections, eventId);
-    }
-    if (!thumbnailPath && !annotatedFramePath) return void 0;
-    return {
-      thumbnailPath: thumbnailPath ?? "",
-      annotatedFramePath: annotatedFramePath ?? ""
+// src/analytics/heatmap-aggregator.js
+var require_heatmap_aggregator = __commonJS({
+  "src/analytics/heatmap-aggregator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.HeatmapAggregator = void 0;
+    var HeatmapAggregator2 = class {
+      width;
+      height;
+      gridSize;
+      grid;
+      maxCount = 0;
+      constructor(width, height, gridSize) {
+        this.width = width;
+        this.height = height;
+        this.gridSize = gridSize;
+        if (gridSize <= 0)
+          throw new Error("gridSize must be > 0");
+        this.grid = new Float32Array(gridSize * gridSize);
+      }
+      /**
+       * Add a normalized point (0–1 range) to the heatmap.
+       * Points outside [0, 1] are clamped to the grid boundary.
+       */
+      addPoint(x, y) {
+        const col = Math.min(Math.floor(x * this.gridSize), this.gridSize - 1);
+        const row = Math.min(Math.floor(y * this.gridSize), this.gridSize - 1);
+        const idx = row * this.gridSize + col;
+        this.grid[idx] += 1;
+        if (this.grid[idx] > this.maxCount) {
+          this.maxCount = this.grid[idx];
+        }
+      }
+      /** Add a pixel-coordinate point. Normalizes against the configured width/height. */
+      addPixelPoint(px, py) {
+        this.addPoint(px / this.width, py / this.height);
+      }
+      getHeatmap() {
+        return {
+          width: this.width,
+          height: this.height,
+          gridSize: this.gridSize,
+          cells: new Float32Array(this.grid),
+          maxCount: this.maxCount
+        };
+      }
+      reset() {
+        this.grid.fill(0);
+        this.maxCount = 0;
+      }
+      /** Total number of points accumulated */
+      get totalPoints() {
+        let total = 0;
+        for (let i = 0; i < this.grid.length; i++) {
+          total += this.grid[i];
+        }
+        return total;
+      }
     };
+    exports.HeatmapAggregator = HeatmapAggregator2;
   }
-  async saveThumbnail(frame, bbox, eventId) {
-    const sharp = await import("sharp");
-    const { frameWidth, frameHeight } = await this.resolveFrameDimensions(frame);
-    const left = Math.max(0, Math.round(bbox.x));
-    const top = Math.max(0, Math.round(bbox.y));
-    const width = Math.min(Math.round(bbox.w), frameWidth - left);
-    const height = Math.min(Math.round(bbox.h), frameHeight - top);
-    if (width <= 0 || height <= 0) {
-      throw new Error(`Invalid crop dimensions for event ${eventId}: ${JSON.stringify({ left, top, width, height, frameWidth, frameHeight })}`);
-    }
-    const relativePath = `${eventId}_thumb.jpg`;
-    const inputOptions = this.sharpInputOptions(frame);
-    const buffer = await sharp.default(frame.data, inputOptions).extract({ left, top, width, height }).jpeg({ quality: 85 }).toBuffer();
-    await this.writeOutput(relativePath, buffer);
-    return relativePath;
-  }
-  async saveAnnotatedFrame(frame, detections, eventId) {
-    const sharp = await import("sharp");
-    const { frameWidth, frameHeight } = await this.resolveFrameDimensions(frame);
-    const relativePath = `${eventId}_annotated.jpg`;
-    const svgBoxes = detections.map((det) => {
-      const x = Math.max(0, Math.round(det.bbox.x));
-      const y = Math.max(0, Math.round(det.bbox.y));
-      const w = Math.min(Math.round(det.bbox.w), frameWidth - x);
-      const h = Math.min(Math.round(det.bbox.h), frameHeight - y);
-      const label = `${det.class} ${(det.score * 100).toFixed(0)}%`;
-      return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="none" stroke="lime" stroke-width="2"/>
-        <text x="${x + 2}" y="${Math.max(y - 2, 10)}" font-size="12" fill="lime" font-family="sans-serif">${label}</text>`;
-    }).join("\n");
-    const svgOverlay = Buffer.from(
-      `<svg width="${frameWidth}" height="${frameHeight}" xmlns="http://www.w3.org/2000/svg">${svgBoxes}</svg>`
-    );
-    const inputOptions = this.sharpInputOptions(frame);
-    const buffer = await sharp.default(frame.data, inputOptions).composite([{ input: svgOverlay, top: 0, left: 0 }]).jpeg({ quality: 85 }).toBuffer();
-    await this.writeOutput(relativePath, buffer);
-    return relativePath;
-  }
-  /**
-   * Write output using mediaStorage if available, otherwise fall back to fs.writeFile.
-   */
-  async writeOutput(relativePath, data) {
-    if (this.config.mediaStorage) {
-      await this.config.mediaStorage.writeFile(relativePath, data);
-    } else if (this.config.outputDir) {
-      const { writeFile } = await import("fs/promises");
-      const { join } = await import("path");
-      await writeFile(join(this.config.outputDir, relativePath), data);
-    }
-  }
-  /**
-   * Resolve actual frame dimensions. JPEG frames from decoders may report
-   * width=0, height=0 — in that case read the real size from sharp metadata.
-   */
-  async resolveFrameDimensions(frame) {
-    if (frame.width > 0 && frame.height > 0) {
-      return { frameWidth: frame.width, frameHeight: frame.height };
-    }
-    if (frame.format === "jpeg") {
-      const sharp = await import("sharp");
-      const meta = await sharp.default(frame.data).metadata();
-      return {
-        frameWidth: meta.width ?? 0,
-        frameHeight: meta.height ?? 0
-      };
-    }
-    return { frameWidth: frame.width, frameHeight: frame.height };
-  }
-  sharpInputOptions(frame) {
-    if (frame.format === "jpeg") {
-      return {};
-    }
-    const channels = frame.format === "rgb" ? 3 : 3;
-    return {
-      raw: {
-        width: frame.width,
-        height: frame.height,
-        channels
+});
+
+// src/analytics/analytics-provider.js
+var require_analytics_provider = __commonJS({
+  "src/analytics/analytics-provider.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnalyticsProvider = void 0;
+    var AnalyticsProvider2 = class {
+      liveStateManager;
+      trackStore;
+      getZoneHistoryCb;
+      getHeatmapCb;
+      lastLiveState;
+      constructor(liveStateManager, trackStore, getZoneHistoryCb, getHeatmapCb, lastLiveState = null) {
+        this.liveStateManager = liveStateManager;
+        this.trackStore = trackStore;
+        this.getZoneHistoryCb = getZoneHistoryCb;
+        this.getHeatmapCb = getHeatmapCb;
+        this.lastLiveState = lastLiveState;
+      }
+      /** Called by the orchestrator each frame to update the cached live state */
+      updateLiveState(state) {
+        this.lastLiveState = state;
+      }
+      getLiveState(_deviceId) {
+        return this.lastLiveState;
+      }
+      getTracks(_deviceId, filter) {
+        const tracks = this.lastLiveState?.tracks ?? [];
+        if (!filter)
+          return [...tracks];
+        return tracks.filter((t) => {
+          if (filter.class && !filter.class.includes(t.class))
+            return false;
+          if (filter.state && !filter.state.includes(t.state))
+            return false;
+          if (filter.inZone && !t.inZones.includes(filter.inZone))
+            return false;
+          if (filter.minDwellMs !== void 0 && t.dwellTimeMs < filter.minDwellMs)
+            return false;
+          return true;
+        });
+      }
+      getZoneState(_deviceId, zoneId) {
+        return this.lastLiveState?.zones.find((z) => z.zoneId === zoneId) ?? null;
+      }
+      async getZoneHistory(deviceId, zoneId, options) {
+        if (this.getZoneHistoryCb) {
+          return this.getZoneHistoryCb(deviceId, zoneId, options);
+        }
+        return [];
+      }
+      async getHeatmap(deviceId, options) {
+        if (this.getHeatmapCb) {
+          return this.getHeatmapCb(deviceId, options);
+        }
+        const gridSize = options.resolution;
+        return {
+          width: 1920,
+          height: 1080,
+          gridSize,
+          cells: new Float32Array(gridSize * gridSize),
+          maxCount: 0
+        };
+      }
+      getTrackDetail(_deviceId, trackId) {
+        return this.trackStore.getTrackDetail(trackId);
+      }
+      getCameraStatus(_deviceId) {
+        return this.lastLiveState ? [...this.lastLiveState.pipelineStatus] : [];
       }
     };
+    exports.AnalyticsProvider = AnalyticsProvider2;
   }
-  async ensureOutputDir() {
-    if (this.config.outputDir) {
-      const { mkdir } = await import("fs/promises");
-      await mkdir(this.config.outputDir, { recursive: true });
-    }
-  }
-};
+});
 
-// src/pipeline/analysis-pipeline.ts
-var AnalysisPipeline = class {
-  id = "pipeline-analysis";
-  manifest = {
-    id: "pipeline-analysis",
-    name: "Pipeline Analysis",
-    version: "0.1.0",
-    description: "Object tracking, state analysis, zone evaluation, and event emission",
-    packageName: "@camstack/lib-pipeline-analysis"
-  };
-  config;
-  cameras = /* @__PURE__ */ new Map();
-  knownFaces = [];
-  knownPlates = [];
-  listeners = /* @__PURE__ */ new Map();
-  /** Optional callback: server orchestrator can hook in to persist finished tracks */
-  onTrackFinished;
-  constructor(config = {}) {
-    this.config = {
-      tracker: config.tracker ?? {},
-      stateAnalyzer: config.stateAnalyzer ?? {},
-      eventFilter: config.eventFilter ?? {},
-      snapshot: config.snapshot ?? {},
-      heatmapGridSize: config.heatmapGridSize ?? 32,
-      defaultFrameWidth: config.defaultFrameWidth ?? 1920,
-      defaultFrameHeight: config.defaultFrameHeight ?? 1080
+// src/snapshots/snapshot-manager.js
+var require_snapshot_manager = __commonJS({
+  "src/snapshots/snapshot-manager.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SnapshotManager = exports.DEFAULT_SNAPSHOT_CONFIG = void 0;
+    exports.DEFAULT_SNAPSHOT_CONFIG = {
+      enabled: false,
+      saveThumbnail: true,
+      saveAnnotatedFrame: false,
+      saveDebugThumbnails: false
     };
-  }
-  async initialize(_ctx) {
-  }
-  async shutdown() {
-    this.cameras.clear();
-    this.listeners.clear();
-  }
-  async processFrame(deviceId, frame, pipelineResult) {
-    const camera = this.getOrCreateCamera(deviceId);
-    const frameWidth = frame.width > 0 ? frame.width : this.config.defaultFrameWidth;
-    const frameHeight = frame.height > 0 ? frame.height : this.config.defaultFrameHeight;
-    const timestamp = frame.timestamp;
-    const detections = pipelineResult ? this.extractDetections(pipelineResult) : [];
-    const tracked = camera.tracker.update(detections, timestamp);
-    const states = camera.stateAnalyzer.analyze(tracked, timestamp);
-    const zoneEvents = camera.zoneEvaluator.evaluate(
-      tracked,
-      camera.zones,
-      frameWidth,
-      frameHeight,
-      timestamp
-    );
-    const classificationsByTrack = pipelineResult ? this.matchClassifications(pipelineResult, tracked.map((t) => t.trackId)) : [];
-    camera.trackStore.update(tracked, states, zoneEvents, classificationsByTrack);
-    const events = camera.eventEmitter.emit(
-      tracked,
-      states,
-      zoneEvents,
-      classificationsByTrack,
-      deviceId
-    );
-    for (const event of events) {
-      const snapshot = await camera.snapshotManager.capture(frame, event.detection, tracked, event.id);
-      if (snapshot) {
-        ;
-        event.snapshot = snapshot;
-      }
-      camera.trackStore.addEvent(event.detection.trackId, event);
-    }
-    for (const track of tracked) {
-      const cx = (track.bbox.x + track.bbox.w / 2) / frameWidth;
-      const cy = (track.bbox.y + track.bbox.h / 2) / frameHeight;
-      camera.heatmapAggregator.addPoint(cx, cy);
-    }
-    for (const lostTrack of camera.tracker.getLostTracks()) {
-      const detail = camera.trackStore.finishTrack(lostTrack.trackId);
-      if (detail && this.onTrackFinished) {
-        this.onTrackFinished(deviceId, detail);
+    var SnapshotManager2 = class {
+      config;
+      constructor(config) {
+        this.config = config;
       }
-    }
-    const pipelineMs = pipelineResult?.totalMs ?? 0;
-    const pipelineStatus = [];
-    const liveState = camera.liveStateManager.buildState(
-      deviceId,
-      tracked,
-      states,
-      camera.zoneEvaluator.getTrackZones(),
-      pipelineStatus,
-      pipelineMs,
-      events[events.length - 1],
-      timestamp
-    );
-    camera.lastLiveState = liveState;
-    camera.analyticsProvider.updateLiveState(liveState);
-    const cameraListeners = this.listeners.get(deviceId);
-    if (cameraListeners) {
-      for (const cb of cameraListeners) {
-        cb(liveState);
+      async capture(frame, detection, allDetections, eventId) {
+        if (!this.config.enabled)
+          return void 0;
+        await this.ensureOutputDir();
+        let thumbnailPath;
+        let annotatedFramePath;
+        if (this.config.saveThumbnail) {
+          thumbnailPath = await this.saveThumbnail(frame, detection.bbox, eventId);
+        }
+        if (this.config.saveAnnotatedFrame) {
+          annotatedFramePath = await this.saveAnnotatedFrame(frame, allDetections, eventId);
+        }
+        if (!thumbnailPath && !annotatedFramePath)
+          return void 0;
+        return {
+          thumbnailPath: thumbnailPath ?? "",
+          annotatedFramePath: annotatedFramePath ?? ""
+        };
+      }
+      async saveThumbnail(frame, bbox, eventId) {
+        const sharp = await Promise.resolve().then(() => __importStar(__require("sharp")));
+        const { frameWidth, frameHeight } = await this.resolveFrameDimensions(frame);
+        const left = Math.max(0, Math.round(bbox.x));
+        const top = Math.max(0, Math.round(bbox.y));
+        const width = Math.min(Math.round(bbox.w), frameWidth - left);
+        const height = Math.min(Math.round(bbox.h), frameHeight - top);
+        if (width <= 0 || height <= 0) {
+          throw new Error(`Invalid crop dimensions for event ${eventId}: ${JSON.stringify({ left, top, width, height, frameWidth, frameHeight })}`);
+        }
+        const relativePath = `${eventId}_thumb.jpg`;
+        const inputOptions = this.sharpInputOptions(frame);
+        const buffer = await sharp.default(frame.data, inputOptions).extract({ left, top, width, height }).jpeg({ quality: 85 }).toBuffer();
+        await this.writeOutput(relativePath, buffer);
+        return relativePath;
+      }
+      async saveAnnotatedFrame(frame, detections, eventId) {
+        const sharp = await Promise.resolve().then(() => __importStar(__require("sharp")));
+        const { frameWidth, frameHeight } = await this.resolveFrameDimensions(frame);
+        const relativePath = `${eventId}_annotated.jpg`;
+        const svgBoxes = detections.map((det) => {
+          const x = Math.max(0, Math.round(det.bbox.x));
+          const y = Math.max(0, Math.round(det.bbox.y));
+          const w = Math.min(Math.round(det.bbox.w), frameWidth - x);
+          const h = Math.min(Math.round(det.bbox.h), frameHeight - y);
+          const label = `${det.class} ${(det.score * 100).toFixed(0)}%`;
+          return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="none" stroke="lime" stroke-width="2"/>
+        <text x="${x + 2}" y="${Math.max(y - 2, 10)}" font-size="12" fill="lime" font-family="sans-serif">${label}</text>`;
+        }).join("\n");
+        const svgOverlay = Buffer.from(`<svg width="${frameWidth}" height="${frameHeight}" xmlns="http://www.w3.org/2000/svg">${svgBoxes}</svg>`);
+        const inputOptions = this.sharpInputOptions(frame);
+        const buffer = await sharp.default(frame.data, inputOptions).composite([{ input: svgOverlay, top: 0, left: 0 }]).jpeg({ quality: 85 }).toBuffer();
+        await this.writeOutput(relativePath, buffer);
+        return relativePath;
+      }
+      /**
+       * Write output using mediaStorage if available, otherwise fall back to fs.writeFile.
+       */
+      async writeOutput(relativePath, data) {
+        if (this.config.mediaStorage) {
+          await this.config.mediaStorage.writeFile(relativePath, data);
+        } else if (this.config.outputDir) {
+          const { writeFile } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+          const { join } = await Promise.resolve().then(() => __importStar(__require("path")));
+          await writeFile(join(this.config.outputDir, relativePath), data);
+        }
+      }
+      /**
+       * Resolve actual frame dimensions. JPEG frames from decoders may report
+       * width=0, height=0 — in that case read the real size from sharp metadata.
+       */
+      async resolveFrameDimensions(frame) {
+        if (frame.width > 0 && frame.height > 0) {
+          return { frameWidth: frame.width, frameHeight: frame.height };
+        }
+        if (frame.format === "jpeg") {
+          const sharp = await Promise.resolve().then(() => __importStar(__require("sharp")));
+          const meta = await sharp.default(frame.data).metadata();
+          return {
+            frameWidth: meta.width ?? 0,
+            frameHeight: meta.height ?? 0
+          };
+        }
+        return { frameWidth: frame.width, frameHeight: frame.height };
+      }
+      sharpInputOptions(frame) {
+        if (frame.format === "jpeg") {
+          return {};
+        }
+        const channels = frame.format === "rgb" ? 3 : 3;
+        return {
+          raw: {
+            width: frame.width,
+            height: frame.height,
+            channels
+          }
+        };
+      }
+      async ensureOutputDir() {
+        if (this.config.outputDir) {
+          const { mkdir } = await Promise.resolve().then(() => __importStar(__require("fs/promises")));
+          await mkdir(this.config.outputDir, { recursive: true });
+        }
       }
-    }
-    return events;
-  }
-  setCameraPipeline(deviceId, _config) {
-    this.getOrCreateCamera(deviceId);
-  }
-  setCameraZones(deviceId, zones) {
-    const camera = this.getOrCreateCamera(deviceId);
-    camera.zones = [...zones];
-    camera.liveStateManager.setZones(zones);
-  }
-  setKnownFaces(faces) {
-    this.knownFaces = [...faces];
-  }
-  setKnownPlates(plates) {
-    this.knownPlates = [...plates];
-  }
-  onLiveStateChange(deviceId, callback) {
-    if (!this.listeners.has(deviceId)) {
-      this.listeners.set(deviceId, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(deviceId).add(callback);
-    return () => {
-      this.listeners.get(deviceId)?.delete(callback);
     };
+    exports.SnapshotManager = SnapshotManager2;
   }
-  // ICameraAnalyticsProvider delegates to per-camera AnalyticsProvider
-  getLiveState(deviceId) {
-    return this.cameras.get(deviceId)?.lastLiveState ?? null;
-  }
-  getTracks(deviceId, filter) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) return [];
-    return camera.analyticsProvider.getTracks(deviceId, filter);
-  }
-  getZoneState(deviceId, zoneId) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) return null;
-    return camera.analyticsProvider.getZoneState(deviceId, zoneId);
-  }
-  async getZoneHistory(deviceId, zoneId, options) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) return [];
-    return camera.analyticsProvider.getZoneHistory(deviceId, zoneId, options);
-  }
-  async getHeatmap(deviceId, options) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) {
-      const gridSize = options.resolution;
-      return {
-        width: this.config.defaultFrameWidth,
-        height: this.config.defaultFrameHeight,
-        gridSize,
-        cells: new Float32Array(gridSize * gridSize),
-        maxCount: 0
+});
+
+// src/pipeline/analysis-pipeline.js
+var require_analysis_pipeline = __commonJS({
+  "src/pipeline/analysis-pipeline.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AnalysisPipeline = void 0;
+    var sort_tracker_js_1 = require_sort_tracker();
+    var state_analyzer_js_1 = require_state_analyzer();
+    var zone_evaluator_js_1 = require_zone_evaluator();
+    var event_emitter_js_1 = require_event_emitter();
+    var track_store_js_1 = require_track_store();
+    var live_state_manager_js_1 = require_live_state_manager();
+    var heatmap_aggregator_js_1 = require_heatmap_aggregator();
+    var analytics_provider_js_1 = require_analytics_provider();
+    var snapshot_manager_js_1 = require_snapshot_manager();
+    var AnalysisPipeline2 = class {
+      id = "pipeline-analysis";
+      manifest = {
+        id: "pipeline-analysis",
+        name: "Pipeline Analysis",
+        version: "0.1.0",
+        description: "Object tracking, state analysis, zone evaluation, and event emission",
+        packageName: "@camstack/lib-pipeline-analysis"
       };
-    }
-    return camera.heatmapAggregator.getHeatmap();
-  }
-  getTrackDetail(deviceId, trackId) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) return null;
-    return camera.trackStore.getTrackDetail(trackId);
-  }
-  getCameraStatus(deviceId) {
-    const camera = this.cameras.get(deviceId);
-    if (!camera) return [];
-    return camera.analyticsProvider.getCameraStatus(deviceId);
-  }
-  getOrCreateCamera(deviceId) {
-    const existing = this.cameras.get(deviceId);
-    if (existing) return existing;
-    const tracker = new SortTracker(this.config.tracker);
-    const stateAnalyzer = new StateAnalyzer(this.config.stateAnalyzer);
-    const zoneEvaluator = new ZoneEvaluator();
-    const eventEmitter = new DetectionEventEmitter(this.config.eventFilter);
-    const trackStore = new TrackStore();
-    const liveStateManager = new LiveStateManager();
-    const heatmapAggregator = new HeatmapAggregator(
-      this.config.defaultFrameWidth,
-      this.config.defaultFrameHeight,
-      this.config.heatmapGridSize
-    );
-    const analyticsProvider = new AnalyticsProvider(liveStateManager, trackStore);
-    const snapshotManager = new SnapshotManager({
-      ...DEFAULT_SNAPSHOT_CONFIG,
-      ...this.config.snapshot
-    });
-    const cameraState = {
-      tracker,
-      stateAnalyzer,
-      zoneEvaluator,
-      eventEmitter,
-      trackStore,
-      liveStateManager,
-      heatmapAggregator,
-      analyticsProvider,
-      snapshotManager,
-      zones: [],
-      lastLiveState: null
-    };
-    this.cameras.set(deviceId, cameraState);
-    return cameraState;
-  }
-  extractDetections(pipelineResult) {
-    const detections = [];
-    for (const stepResult of pipelineResult.results) {
-      if (stepResult.slot === "detector") {
-        const output = stepResult.output;
-        if (output.detections) {
-          detections.push(...output.detections);
+      config;
+      cameras = /* @__PURE__ */ new Map();
+      knownFaces = [];
+      knownPlates = [];
+      listeners = /* @__PURE__ */ new Map();
+      /** Optional callback: server orchestrator can hook in to persist finished tracks */
+      onTrackFinished;
+      constructor(config = {}) {
+        this.config = {
+          tracker: config.tracker ?? {},
+          stateAnalyzer: config.stateAnalyzer ?? {},
+          eventFilter: config.eventFilter ?? {},
+          snapshot: config.snapshot ?? {},
+          heatmapGridSize: config.heatmapGridSize ?? 32,
+          defaultFrameWidth: config.defaultFrameWidth ?? 1920,
+          defaultFrameHeight: config.defaultFrameHeight ?? 1080
+        };
+      }
+      async initialize(_ctx) {
+      }
+      async shutdown() {
+        this.cameras.clear();
+        this.listeners.clear();
+      }
+      async processFrame(deviceId, frame, pipelineResult) {
+        const camera = this.getOrCreateCamera(deviceId);
+        const frameWidth = frame.width > 0 ? frame.width : this.config.defaultFrameWidth;
+        const frameHeight = frame.height > 0 ? frame.height : this.config.defaultFrameHeight;
+        const timestamp = frame.timestamp;
+        const detections = pipelineResult ? this.extractDetections(pipelineResult) : [];
+        const tracked = camera.tracker.update(detections, timestamp);
+        const states = camera.stateAnalyzer.analyze(tracked, timestamp);
+        const zoneEvents = camera.zoneEvaluator.evaluate(tracked, camera.zones, frameWidth, frameHeight, timestamp);
+        const classificationsByTrack = pipelineResult ? this.matchClassifications(pipelineResult, tracked.map((t) => t.trackId)) : [];
+        camera.trackStore.update(tracked, states, zoneEvents, classificationsByTrack);
+        const events = camera.eventEmitter.emit(tracked, states, zoneEvents, classificationsByTrack, deviceId);
+        for (const event of events) {
+          const snapshot = await camera.snapshotManager.capture(frame, event.detection, tracked, event.id);
+          if (snapshot) {
+            ;
+            event.snapshot = snapshot;
+          }
+          camera.trackStore.addEvent(event.detection.trackId, event);
+        }
+        for (const track of tracked) {
+          const cx = (track.bbox.x + track.bbox.w / 2) / frameWidth;
+          const cy = (track.bbox.y + track.bbox.h / 2) / frameHeight;
+          camera.heatmapAggregator.addPoint(cx, cy);
+        }
+        for (const lostTrack of camera.tracker.getLostTracks()) {
+          const detail = camera.trackStore.finishTrack(lostTrack.trackId);
+          if (detail && this.onTrackFinished) {
+            this.onTrackFinished(deviceId, detail);
+          }
+        }
+        const pipelineMs = pipelineResult?.totalMs ?? 0;
+        const pipelineStatus = [];
+        const liveState = camera.liveStateManager.buildState(deviceId, tracked, states, camera.zoneEvaluator.getTrackZones(), pipelineStatus, pipelineMs, events[events.length - 1], timestamp);
+        camera.lastLiveState = liveState;
+        camera.analyticsProvider.updateLiveState(liveState);
+        const cameraListeners = this.listeners.get(deviceId);
+        if (cameraListeners) {
+          for (const cb of cameraListeners) {
+            cb(liveState);
+          }
         }
+        return events;
       }
-    }
-    return detections;
-  }
-  matchClassifications(pipelineResult, trackIds) {
-    const classifierResults = [];
-    for (const stepResult of pipelineResult.results) {
-      if (stepResult.slot === "classifier") {
-        const output = stepResult.output;
-        if (output.classifications) {
-          classifierResults.push([...output.classifications]);
+      setCameraPipeline(deviceId, _config) {
+        this.getOrCreateCamera(deviceId);
+      }
+      setCameraZones(deviceId, zones) {
+        const camera = this.getOrCreateCamera(deviceId);
+        camera.zones = [...zones];
+        camera.liveStateManager.setZones(zones);
+      }
+      setKnownFaces(faces) {
+        this.knownFaces = [...faces];
+      }
+      setKnownPlates(plates) {
+        this.knownPlates = [...plates];
+      }
+      onLiveStateChange(deviceId, callback) {
+        if (!this.listeners.has(deviceId)) {
+          this.listeners.set(deviceId, /* @__PURE__ */ new Set());
         }
+        this.listeners.get(deviceId).add(callback);
+        return () => {
+          this.listeners.get(deviceId)?.delete(callback);
+        };
       }
-    }
-    return trackIds.slice(0, classifierResults.length).map((trackId, i) => ({
-      trackId,
-      classifications: classifierResults[i] ?? []
-    }));
+      // ICameraAnalyticsProvider delegates to per-camera AnalyticsProvider
+      getLiveState(deviceId) {
+        return this.cameras.get(deviceId)?.lastLiveState ?? null;
+      }
+      getTracks(deviceId, filter) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera)
+          return [];
+        return camera.analyticsProvider.getTracks(deviceId, filter);
+      }
+      getZoneState(deviceId, zoneId) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera)
+          return null;
+        return camera.analyticsProvider.getZoneState(deviceId, zoneId);
+      }
+      async getZoneHistory(deviceId, zoneId, options) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera)
+          return [];
+        return camera.analyticsProvider.getZoneHistory(deviceId, zoneId, options);
+      }
+      async getHeatmap(deviceId, options) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera) {
+          const gridSize = options.resolution;
+          return {
+            width: this.config.defaultFrameWidth,
+            height: this.config.defaultFrameHeight,
+            gridSize,
+            cells: new Float32Array(gridSize * gridSize),
+            maxCount: 0
+          };
+        }
+        return camera.heatmapAggregator.getHeatmap();
+      }
+      getTrackDetail(deviceId, trackId) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera)
+          return null;
+        return camera.trackStore.getTrackDetail(trackId);
+      }
+      getCameraStatus(deviceId) {
+        const camera = this.cameras.get(deviceId);
+        if (!camera)
+          return [];
+        return camera.analyticsProvider.getCameraStatus(deviceId);
+      }
+      getOrCreateCamera(deviceId) {
+        const existing = this.cameras.get(deviceId);
+        if (existing)
+          return existing;
+        const tracker = new sort_tracker_js_1.SortTracker(this.config.tracker);
+        const stateAnalyzer = new state_analyzer_js_1.StateAnalyzer(this.config.stateAnalyzer);
+        const zoneEvaluator = new zone_evaluator_js_1.ZoneEvaluator();
+        const eventEmitter = new event_emitter_js_1.DetectionEventEmitter(this.config.eventFilter);
+        const trackStore = new track_store_js_1.TrackStore();
+        const liveStateManager = new live_state_manager_js_1.LiveStateManager();
+        const heatmapAggregator = new heatmap_aggregator_js_1.HeatmapAggregator(this.config.defaultFrameWidth, this.config.defaultFrameHeight, this.config.heatmapGridSize);
+        const analyticsProvider = new analytics_provider_js_1.AnalyticsProvider(liveStateManager, trackStore);
+        const snapshotManager = new snapshot_manager_js_1.SnapshotManager({
+          ...snapshot_manager_js_1.DEFAULT_SNAPSHOT_CONFIG,
+          ...this.config.snapshot
+        });
+        const cameraState = {
+          tracker,
+          stateAnalyzer,
+          zoneEvaluator,
+          eventEmitter,
+          trackStore,
+          liveStateManager,
+          heatmapAggregator,
+          analyticsProvider,
+          snapshotManager,
+          zones: [],
+          lastLiveState: null
+        };
+        this.cameras.set(deviceId, cameraState);
+        return cameraState;
+      }
+      extractDetections(pipelineResult) {
+        const detections = [];
+        for (const stepResult of pipelineResult.results) {
+          if (stepResult.slot === "detector") {
+            const output = stepResult.output;
+            if (output.detections) {
+              detections.push(...output.detections);
+            }
+          }
+        }
+        return detections;
+      }
+      matchClassifications(pipelineResult, trackIds) {
+        const classifierResults = [];
+        for (const stepResult of pipelineResult.results) {
+          if (stepResult.slot === "classifier") {
+            const output = stepResult.output;
+            if (output.classifications) {
+              classifierResults.push([...output.classifications]);
+            }
+          }
+        }
+        return trackIds.slice(0, classifierResults.length).map((trackId, i) => ({
+          trackId,
+          classifications: classifierResults[i] ?? []
+        }));
+      }
+    };
+    exports.AnalysisPipeline = AnalysisPipeline2;
   }
-};
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnalysisPipeline: () => import_analysis_pipeline.AnalysisPipeline,
+  AnalyticsProvider: () => import_analytics_provider.AnalyticsProvider,
+  DEFAULT_EVENT_FILTER_CONFIG: () => import_event_filters.DEFAULT_EVENT_FILTER_CONFIG,
+  DEFAULT_SNAPSHOT_CONFIG: () => import_snapshot_manager.DEFAULT_SNAPSHOT_CONFIG,
+  DEFAULT_STATE_ANALYZER_CONFIG: () => import_state_analyzer.DEFAULT_STATE_ANALYZER_CONFIG,
+  DEFAULT_TRACKER_CONFIG: () => import_sort_tracker.DEFAULT_TRACKER_CONFIG,
+  DetectionEventEmitter: () => import_event_emitter.DetectionEventEmitter,
+  EventFilter: () => import_event_filters.EventFilter,
+  HeatmapAggregator: () => import_heatmap_aggregator.HeatmapAggregator,
+  LiveStateManager: () => import_live_state_manager.LiveStateManager,
+  SnapshotManager: () => import_snapshot_manager.SnapshotManager,
+  SortTracker: () => import_sort_tracker.SortTracker,
+  StateAnalyzer: () => import_state_analyzer.StateAnalyzer,
+  TrackStore: () => import_track_store.TrackStore,
+  ZoneEvaluator: () => import_zone_evaluator.ZoneEvaluator,
+  greedyAssignment: () => import_hungarian.greedyAssignment
+});
+__reExport(src_exports, __toESM(require_geometry()));
+var import_sort_tracker = __toESM(require_sort_tracker());
+var import_hungarian = __toESM(require_hungarian());
+var import_state_analyzer = __toESM(require_state_analyzer());
+var import_zone_evaluator = __toESM(require_zone_evaluator());
+var import_event_filters = __toESM(require_event_filters());
+var import_event_emitter = __toESM(require_event_emitter());
+var import_track_store = __toESM(require_track_store());
+var import_live_state_manager = __toESM(require_live_state_manager());
+var import_heatmap_aggregator = __toESM(require_heatmap_aggregator());
+var import_analytics_provider = __toESM(require_analytics_provider());
+var import_snapshot_manager = __toESM(require_snapshot_manager());
+var import_analysis_pipeline = __toESM(require_analysis_pipeline());
+var export_AnalysisPipeline = import_analysis_pipeline.AnalysisPipeline;
+var export_AnalyticsProvider = import_analytics_provider.AnalyticsProvider;
+var export_DEFAULT_EVENT_FILTER_CONFIG = import_event_filters.DEFAULT_EVENT_FILTER_CONFIG;
+var export_DEFAULT_SNAPSHOT_CONFIG = import_snapshot_manager.DEFAULT_SNAPSHOT_CONFIG;
+var export_DEFAULT_STATE_ANALYZER_CONFIG = import_state_analyzer.DEFAULT_STATE_ANALYZER_CONFIG;
+var export_DEFAULT_TRACKER_CONFIG = import_sort_tracker.DEFAULT_TRACKER_CONFIG;
+var export_DetectionEventEmitter = import_event_emitter.DetectionEventEmitter;
+var export_EventFilter = import_event_filters.EventFilter;
+var export_HeatmapAggregator = import_heatmap_aggregator.HeatmapAggregator;
+var export_LiveStateManager = import_live_state_manager.LiveStateManager;
+var export_SnapshotManager = import_snapshot_manager.SnapshotManager;
+var export_SortTracker = import_sort_tracker.SortTracker;
+var export_StateAnalyzer = import_state_analyzer.StateAnalyzer;
+var export_TrackStore = import_track_store.TrackStore;
+var export_ZoneEvaluator = import_zone_evaluator.ZoneEvaluator;
+var export_greedyAssignment = import_hungarian.greedyAssignment;
 export {
-  AnalysisPipeline,
-  AnalyticsProvider,
-  DEFAULT_EVENT_FILTER_CONFIG,
-  DEFAULT_SNAPSHOT_CONFIG,
-  DEFAULT_STATE_ANALYZER_CONFIG,
-  DEFAULT_TRACKER_CONFIG,
-  DetectionEventEmitter,
-  EventFilter,
-  HeatmapAggregator,
-  LiveStateManager,
-  SnapshotManager,
-  SortTracker,
-  StateAnalyzer,
-  TrackStore,
-  ZoneEvaluator,
-  bboxCentroid,
-  greedyAssignment,
-  lineIntersection,
-  normalizeToPixel,
-  pointInPolygon,
-  tripwireCrossing
+  export_AnalysisPipeline as AnalysisPipeline,
+  export_AnalyticsProvider as AnalyticsProvider,
+  export_DEFAULT_EVENT_FILTER_CONFIG as DEFAULT_EVENT_FILTER_CONFIG,
+  export_DEFAULT_SNAPSHOT_CONFIG as DEFAULT_SNAPSHOT_CONFIG,
+  export_DEFAULT_STATE_ANALYZER_CONFIG as DEFAULT_STATE_ANALYZER_CONFIG,
+  export_DEFAULT_TRACKER_CONFIG as DEFAULT_TRACKER_CONFIG,
+  export_DetectionEventEmitter as DetectionEventEmitter,
+  export_EventFilter as EventFilter,
+  export_HeatmapAggregator as HeatmapAggregator,
+  export_LiveStateManager as LiveStateManager,
+  export_SnapshotManager as SnapshotManager,
+  export_SortTracker as SortTracker,
+  export_StateAnalyzer as StateAnalyzer,
+  export_TrackStore as TrackStore,
+  export_ZoneEvaluator as ZoneEvaluator,
+  export_greedyAssignment as greedyAssignment
 };
 //# sourceMappingURL=index.mjs.map