@camstack/lib-pipeline-analysis 0.1.7 → 0.1.10

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  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 });
@@ -20,7 +17,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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-
@@ -31,1479 +27,1288 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/zones/geometry.js
-var require_geometry = __commonJS({
-  "src/zones/geometry.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.pointInPolygon = pointInPolygon;
-    exports2.lineIntersection = lineIntersection;
-    exports2.tripwireCrossing = tripwireCrossing;
-    exports2.bboxCentroid = bboxCentroid;
-    exports2.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 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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnalysisPipeline: () => AnalysisPipeline,
+  AnalyticsProvider: () => AnalyticsProvider,
+  DEFAULT_EVENT_FILTER_CONFIG: () => DEFAULT_EVENT_FILTER_CONFIG,
+  DEFAULT_SNAPSHOT_CONFIG: () => DEFAULT_SNAPSHOT_CONFIG,
+  DEFAULT_STATE_ANALYZER_CONFIG: () => DEFAULT_STATE_ANALYZER_CONFIG,
+  DEFAULT_TRACKER_CONFIG: () => DEFAULT_TRACKER_CONFIG,
+  DetectionEventEmitter: () => DetectionEventEmitter,
+  EventFilter: () => EventFilter,
+  HeatmapAggregator: () => HeatmapAggregator,
+  LiveStateManager: () => LiveStateManager,
+  SnapshotManager: () => SnapshotManager,
+  SortTracker: () => SortTracker,
+  StateAnalyzer: () => StateAnalyzer,
+  TrackStore: () => TrackStore,
+  ZoneEvaluator: () => ZoneEvaluator,
+  bboxCentroid: () => bboxCentroid,
+  greedyAssignment: () => greedyAssignment,
+  lineIntersection: () => lineIntersection,
+  normalizeToPixel: () => normalizeToPixel,
+  pointInPolygon: () => pointInPolygon,
+  tripwireCrossing: () => tripwireCrossing
 });
+module.exports = __toCommonJS(src_exports);
 
-// src/tracker/hungarian.js
-var require_hungarian = __commonJS({
-  "src/tracker/hungarian.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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 });
-          }
-        }
-      }
-      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);
+// 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 });
       }
-      return { matches, unmatchedTracks, unmatchedDetections };
     }
   }
-});
+  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.js
-var require_sort_tracker = __commonJS({
-  "src/tracker/sort-tracker.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.SortTracker = exports2.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;
+// 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 SortTracker = class {
+  tracks = [];
+  lostTracks = [];
+  nextTrackId = 1;
+  config;
+  constructor(config = {}) {
+    this.config = { ...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();
     }
-    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()
-      };
+    if (detections.length === 0) {
+      this.ageTracksAndPruneLost(frameTimestamp);
+      return this.getConfirmedTracks();
     }
-    function pushToRingBuffer(buffer, item, maxLength) {
-      if (buffer.length >= maxLength) {
-        buffer.shift();
-      }
-      buffer.push(item);
+    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 };
     }
-    exports2.DEFAULT_TRACKER_CONFIG = {
-      maxAge: 30,
-      minHits: 3,
-      iouThreshold: 0.3
-    };
-    var SortTracker2 = class {
-      tracks = [];
-      lostTracks = [];
-      nextTrackId = 1;
-      config;
-      constructor(config = {}) {
-        this.config = { ...exports2.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 (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);
-          }
-        }
-        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);
-          }
-        }
-        this.tracks = survived;
-        void frameTimestamp;
+    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);
       }
-    };
-    exports2.SortTracker = SortTracker2;
+    }
+    this.tracks = survived;
+    for (const detIdx of unmatchedDetections) {
+      const det = detections[detIdx];
+      this.createTrack(det, frameTimestamp);
+    }
+    return this.getConfirmedTracks();
   }
-});
-
-// src/state/state-analyzer.js
-var require_state_analyzer = __commonJS({
-  "src/state/state-analyzer.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.StateAnalyzer = exports2.DEFAULT_STATE_ANALYZER_CONFIG = void 0;
-    exports2.DEFAULT_STATE_ANALYZER_CONFIG = {
-      stationaryThresholdSec: 10,
-      loiteringThresholdSec: 60,
-      velocityThreshold: 2,
-      enteringFrames: 5
+  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
     };
-    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 = { ...exports2.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;
-            }
-          }
-          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);
-          }
-        }
-        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";
-          }
-          if (stationaryDurationSec >= this.config.stationaryThresholdSec) {
-            return "stationary";
-          }
-        }
-        if (speed > this.config.velocityThreshold) {
-          return "moving";
-        }
-        return "moving";
+    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);
       }
-    };
-    exports2.StateAnalyzer = StateAnalyzer2;
+    }
+    this.tracks = survived;
+    void frameTimestamp;
   }
-});
+};
 
-// src/zones/zone-evaluator.js
-var require_zone_evaluator = __commonJS({
-  "src/zones/zone-evaluator.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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);
-          }
+// 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;
         }
-        return events;
       }
-      /** Returns a snapshot of the current track → zones mapping */
-      getTrackZones() {
-        return new Map(this.trackZoneState);
+      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);
       }
-    };
-    exports2.ZoneEvaluator = ZoneEvaluator2;
+    }
+    return results;
   }
-});
-
-// src/events/event-filters.js
-var require_event_filters = __commonJS({
-  "src/events/event-filters.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.EventFilter = exports2.DEFAULT_EVENT_FILTER_CONFIG = void 0;
-    exports2.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;
-      }
-      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);
-          }
-        }
+  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";
       }
-      /** Reset all cooldown state */
-      reset() {
-        this.lastEmitted.clear();
+      if (stationaryDurationSec >= this.config.stationaryThresholdSec) {
+        return "stationary";
       }
-    };
-    exports2.EventFilter = EventFilter2;
+    }
+    if (speed > this.config.velocityThreshold) {
+      return "moving";
+    }
+    return "moving";
   }
-});
+};
 
-// src/events/event-emitter.js
-var require_event_emitter = __commonJS({
-  "src/events/event-emitter.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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 });
-      }
-      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/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;
         }
-        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";
+        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);
           }
-          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();
-      }
-    };
-    exports2.DetectionEventEmitter = DetectionEventEmitter2;
-  }
-});
-
-// src/analytics/track-store.js
-var require_track_store = __commonJS({
-  "src/analytics/track-store.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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 = {
+          if (inside && !prevZones.has(zone.id)) {
+            events.push({
+              type: "zone-enter",
+              zoneId: zone.id,
+              zoneName: zone.name,
               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();
+              detection: track,
+              timestamp
+            });
           }
-          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 };
-            }
+          if (!inside && prevZones.has(zone.id)) {
+            events.push({
+              type: "zone-exit",
+              zoneId: zone.id,
+              zoneName: zone.name,
+              trackId: track.trackId,
+              detection: track,
+              timestamp
+            });
           }
-        }
-        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 (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 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
             });
-          } 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());
+      this.trackZoneState.set(track.trackId, currZones);
+    }
+    for (const trackId of this.trackZoneState.keys()) {
+      if (!activeTrackIds.has(trackId)) {
+        this.trackZoneState.delete(trackId);
       }
-      /** Clear all accumulated state */
-      reset() {
-        this.activeTracks.clear();
+    }
+    return events;
+  }
+  /** Returns a snapshot of the current track → zones mapping */
+  getTrackZones() {
+    return new Map(this.trackZoneState);
+  }
+};
+
+// 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);
       }
-      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
-        };
+    }
+  }
+  /** Reset all cooldown state */
+  reset() {
+    this.lastEmitted.clear();
+  }
+};
+
+// src/events/event-emitter.ts
+var import_node_crypto = require("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);
       }
-    };
-    exports2.TrackStore = TrackStore2;
+    }
+    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, import_node_crypto.randomUUID)(),
+      type: eventType,
+      timestamp,
+      deviceId,
+      detection: track,
+      classifications,
+      objectState: state,
+      zoneEvents,
+      trackPath: track.path
+    });
+  }
+  reset() {
+    this.previousStates.clear();
+    this.filter.reset();
+  }
+};
 
-// src/analytics/live-state-manager.js
-var require_live_state_manager = __commonJS({
-  "src/analytics/live-state-manager.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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();
+// 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 };
         }
       }
-      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 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
-          };
+    }
+    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
         });
-        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);
+      } 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;
           }
-          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
+        }
+        if (openIdx >= 0) {
+          const open = acc.zoneTransitions[openIdx];
+          acc.zoneTransitions[openIdx] = {
+            ...open,
+            exited: ze.timestamp,
+            dwellMs: ze.timestamp - open.entered
           };
-        });
-        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;
+        }
       }
+    }
+  }
+  /** 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
     };
-    exports2.LiveStateManager = LiveStateManager2;
   }
-});
+};
 
-// src/analytics/heatmap-aggregator.js
-var require_heatmap_aggregator = __commonJS({
-  "src/analytics/heatmap-aggregator.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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;
-      }
+// 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()
     };
-    exports2.HeatmapAggregator = HeatmapAggregator2;
   }
-});
+  reset() {
+    this.pipelineMsHistory.length = 0;
+  }
+};
 
-// src/analytics/analytics-provider.js
-var require_analytics_provider = __commonJS({
-  "src/analytics/analytics-provider.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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] : [];
-      }
+// 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
     };
-    exports2.AnalyticsProvider = AnalyticsProvider2;
   }
-});
+  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/snapshots/snapshot-manager.js
-var require_snapshot_manager = __commonJS({
-  "src/snapshots/snapshot-manager.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
+// 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;
     });
-    var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
-    exports2.SnapshotManager = exports2.DEFAULT_SNAPSHOT_CONFIG = void 0;
-    exports2.DEFAULT_SNAPSHOT_CONFIG = {
-      enabled: false,
-      saveThumbnail: true,
-      saveAnnotatedFrame: false,
-      saveDebugThumbnails: false
+  }
+  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 SnapshotManager2 = class {
-      config;
-      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 ?? ""
-        };
-      }
-      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"/>
+  }
+  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 ?? ""
+    };
+  }
+  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 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 });
-        }
+    }).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
       }
     };
-    exports2.SnapshotManager = SnapshotManager2;
   }
-});
+  async ensureOutputDir() {
+    if (this.config.outputDir) {
+      const { mkdir } = await import("fs/promises");
+      await mkdir(this.config.outputDir, { recursive: true });
+    }
+  }
+};
 
-// src/pipeline/analysis-pipeline.js
-var require_analysis_pipeline = __commonJS({
-  "src/pipeline/analysis-pipeline.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.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"
-      };
-      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;
-      }
-      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);
-        };
-      }
-      // 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);
+// 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
+    };
+  }
+  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);
       }
-      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;
+    }
+    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);
       }
-      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 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);
+    };
+  }
+  // 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 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);
         }
-        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 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] ?? []
-        }));
       }
-    };
-    exports2.AnalysisPipeline = AnalysisPipeline2;
+    }
+    return trackIds.slice(0, classifierResults.length).map((trackId, i) => ({
+      trackId,
+      classifications: classifierResults[i] ?? []
+    }));
   }
-});
-
-// 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
-});
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, __toESM(require_geometry()), module.exports);
-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());
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnalysisPipeline,
@@ -1521,6 +1326,11 @@ var import_analysis_pipeline = __toESM(require_analysis_pipeline());
   StateAnalyzer,
   TrackStore,
   ZoneEvaluator,
-  greedyAssignment
+  bboxCentroid,
+  greedyAssignment,
+  lineIntersection,
+  normalizeToPixel,
+  pointInPolygon,
+  tripwireCrossing
 });
 //# sourceMappingURL=index.js.map