@camstack/lib-pipeline-analysis 0.1.0

package/dist/index.js

@@ -0,0 +1,1336 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/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/zones/geometry.ts
+function pointInPolygon(point, polygon) {
+  if (polygon.length < 3) return false;
+  let inside = false;
+  const { x, y } = point;
+  const n = polygon.length;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const xi = polygon[i].x;
+    const yi = polygon[i].y;
+    const xj = polygon[j].x;
+    const yj = polygon[j].y;
+    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+function lineIntersection(a, b) {
+  const dx1 = a.p2.x - a.p1.x;
+  const dy1 = a.p2.y - a.p1.y;
+  const dx2 = b.p2.x - b.p1.x;
+  const dy2 = b.p2.y - b.p1.y;
+  const denom = dx1 * dy2 - dy1 * dx2;
+  if (Math.abs(denom) < 1e-10) return null;
+  const dx3 = b.p1.x - a.p1.x;
+  const dy3 = b.p1.y - a.p1.y;
+  const t = (dx3 * dy2 - dy3 * dx2) / denom;
+  const u = (dx3 * dy1 - dy3 * dx1) / denom;
+  if (t < 0 || t > 1 || u < 0 || u > 1) return null;
+  return {
+    x: a.p1.x + t * dx1,
+    y: a.p1.y + t * dy1
+  };
+}
+function tripwireCrossing(prev, curr, tripwire) {
+  const movement = { p1: prev, p2: curr };
+  const intersection = lineIntersection(movement, tripwire);
+  if (intersection === null) return null;
+  const twDx = tripwire.p2.x - tripwire.p1.x;
+  const twDy = tripwire.p2.y - tripwire.p1.y;
+  const movDx = curr.x - prev.x;
+  const movDy = curr.y - prev.y;
+  const cross = twDx * movDy - twDy * movDx;
+  const direction = cross > 0 ? "left" : "right";
+  return { crossed: true, direction };
+}
+function bboxCentroid(bbox) {
+  return {
+    x: bbox.x + bbox.w / 2,
+    y: bbox.y + bbox.h / 2
+  };
+}
+function normalizeToPixel(point, imageWidth, imageHeight) {
+  return {
+    x: point.x * imageWidth,
+    y: point.y * imageHeight
+  };
+}
+
+// src/tracker/hungarian.ts
+function greedyAssignment(costMatrix, threshold) {
+  const numTracks = costMatrix.length;
+  const numDetections = numTracks > 0 ? costMatrix[0]?.length ?? 0 : 0;
+  const candidates = [];
+  for (let t = 0; t < numTracks; t++) {
+    for (let d = 0; d < numDetections; d++) {
+      const iou2 = costMatrix[t][d] ?? 0;
+      if (iou2 >= threshold) {
+        candidates.push({ iou: iou2, trackIdx: t, detIdx: d });
+      }
+    }
+  }
+  candidates.sort((a, b) => b.iou - a.iou);
+  const assignedTracks = /* @__PURE__ */ new Set();
+  const assignedDets = /* @__PURE__ */ new Set();
+  const matches = [];
+  for (const { trackIdx, detIdx } of candidates) {
+    if (assignedTracks.has(trackIdx) || assignedDets.has(detIdx)) continue;
+    matches.push([trackIdx, detIdx]);
+    assignedTracks.add(trackIdx);
+    assignedDets.add(detIdx);
+  }
+  const unmatchedTracks = [];
+  for (let t = 0; t < numTracks; t++) {
+    if (!assignedTracks.has(t)) unmatchedTracks.push(t);
+  }
+  const unmatchedDetections = [];
+  for (let d = 0; d < numDetections; d++) {
+    if (!assignedDets.has(d)) unmatchedDetections.push(d);
+  }
+  return { matches, unmatchedTracks, unmatchedDetections };
+}
+
+// src/tracker/sort-tracker.ts
+var MAX_PATH_LENGTH = 300;
+function iou(a, b) {
+  const ax1 = a.x;
+  const ay1 = a.y;
+  const ax2 = a.x + a.w;
+  const ay2 = a.y + a.h;
+  const bx1 = b.x;
+  const by1 = b.y;
+  const bx2 = b.x + b.w;
+  const by2 = b.y + b.h;
+  const interX1 = Math.max(ax1, bx1);
+  const interY1 = Math.max(ay1, by1);
+  const interX2 = Math.min(ax2, bx2);
+  const interY2 = Math.min(ay2, by2);
+  const interW = Math.max(0, interX2 - interX1);
+  const interH = Math.max(0, interY2 - interY1);
+  const interArea = interW * interH;
+  if (interArea === 0) return 0;
+  const aArea = a.w * a.h;
+  const bArea = b.w * b.h;
+  const unionArea = aArea + bArea - interArea;
+  return unionArea <= 0 ? 0 : interArea / unionArea;
+}
+function trackToTrackedDetection(track) {
+  return {
+    class: track.class,
+    originalClass: track.originalClass,
+    score: track.score,
+    bbox: track.bbox,
+    landmarks: track.landmarks,
+    trackId: track.id,
+    trackAge: track.hits,
+    velocity: track.velocity,
+    path: track.path.slice()
+  };
+}
+function pushToRingBuffer(buffer, item, maxLength) {
+  if (buffer.length >= maxLength) {
+    buffer.shift();
+  }
+  buffer.push(item);
+}
+var DEFAULT_TRACKER_CONFIG = {
+  maxAge: 30,
+  minHits: 3,
+  iouThreshold: 0.3
+};
+var 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();
+    }
+    if (detections.length === 0) {
+      this.ageTracksAndPruneLost(frameTimestamp);
+      return this.getConfirmedTracks();
+    }
+    const costMatrix = this.tracks.map(
+      (track) => detections.map((det) => iou(track.bbox, det.bbox))
+    );
+    const { matches, unmatchedTracks, unmatchedDetections } = greedyAssignment(
+      costMatrix,
+      this.config.iouThreshold
+    );
+    for (const [trackIdx, detIdx] of matches) {
+      const track = this.tracks[trackIdx];
+      const det = detections[detIdx];
+      const prevCx = track.bbox.x + track.bbox.w / 2;
+      const prevCy = track.bbox.y + track.bbox.h / 2;
+      const newCx = det.bbox.x + det.bbox.w / 2;
+      const newCy = det.bbox.y + det.bbox.h / 2;
+      pushToRingBuffer(track.path, track.bbox, MAX_PATH_LENGTH);
+      track.bbox = det.bbox;
+      track.class = det.class;
+      track.originalClass = det.originalClass;
+      track.score = det.score;
+      track.landmarks = det.landmarks;
+      track.age = 0;
+      track.hits++;
+      track.lastSeen = frameTimestamp;
+      track.velocity = { dx: newCx - prevCx, dy: newCy - prevCy };
+    }
+    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;
+  }
+};
+
+// 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;
+        }
+      }
+      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";
+  }
+};
+
+// 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;
+        }
+        if (zone.type === "polygon") {
+          const pixelPoints = zone.points.map((p) => normalizeToPixel(p, imageWidth, imageHeight));
+          const inside = pointInPolygon(centroid, pixelPoints);
+          if (inside) {
+            currZones.add(zone.id);
+          }
+          if (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 = 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
+            });
+          }
+        }
+      }
+      this.trackZoneState.set(track.trackId, currZones);
+    }
+    for (const trackId of this.trackZoneState.keys()) {
+      if (!activeTrackIds.has(trackId)) {
+        this.trackZoneState.delete(trackId);
+      }
+    }
+    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);
+      }
+    }
+  }
+  /** 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);
+      }
+    }
+    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/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 };
+        }
+      }
+    }
+    for (const ze of zoneEvents) {
+      const acc = this.activeTracks.get(ze.trackId);
+      if (!acc) continue;
+      if (ze.type === "zone-enter") {
+        acc.zoneTransitions.push({
+          zoneId: ze.zoneId,
+          zoneName: ze.zoneName,
+          entered: ze.timestamp,
+          dwellMs: 0
+        });
+      } else if (ze.type === "zone-exit") {
+        let openIdx = -1;
+        for (let i = acc.zoneTransitions.length - 1; i >= 0; i--) {
+          const t = acc.zoneTransitions[i];
+          if (t.zoneId === ze.zoneId && t.exited === void 0) {
+            openIdx = i;
+            break;
+          }
+        }
+        if (openIdx >= 0) {
+          const open = acc.zoneTransitions[openIdx];
+          acc.zoneTransitions[openIdx] = {
+            ...open,
+            exited: ze.timestamp,
+            dwellMs: ze.timestamp - open.entered
+          };
+        }
+      }
+    }
+  }
+  /** Attach a DetectionEvent to its associated track accumulator */
+  addEvent(trackId, event) {
+    const acc = this.activeTracks.get(trackId);
+    if (!acc) return;
+    acc.events.push(event);
+    if (event.snapshot && !acc.bestSnapshot) {
+      acc.bestSnapshot = event.snapshot;
+    }
+  }
+  /** Get accumulated detail for an active track */
+  getTrackDetail(trackId) {
+    const acc = this.activeTracks.get(trackId);
+    if (!acc) return null;
+    return this.buildTrackDetail(acc);
+  }
+  /** Called when a track ends — returns complete TrackDetail and removes from active set */
+  finishTrack(trackId) {
+    const acc = this.activeTracks.get(trackId);
+    if (!acc) return null;
+    const detail = this.buildTrackDetail(acc);
+    this.activeTracks.delete(trackId);
+    return detail;
+  }
+  /** Get all active track IDs */
+  getActiveTrackIds() {
+    return Array.from(this.activeTracks.keys());
+  }
+  /** Clear all accumulated state */
+  reset() {
+    this.activeTracks.clear();
+  }
+  buildTrackDetail(acc) {
+    return {
+      trackId: acc.trackId,
+      class: acc.class,
+      originalClass: acc.originalClass,
+      state: acc.state,
+      firstSeen: acc.firstSeen,
+      lastSeen: acc.lastSeen,
+      totalDwellMs: acc.lastSeen - acc.firstSeen,
+      path: acc.path,
+      identity: acc.identity,
+      plateText: acc.plateText,
+      subClass: acc.subClass,
+      zoneTransitions: acc.zoneTransitions,
+      bestSnapshot: acc.bestSnapshot,
+      events: acc.events
+    };
+  }
+};
+
+// 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()
+    };
+  }
+  reset() {
+    this.pipelineMsHistory.length = 0;
+  }
+};
+
+// src/analytics/heatmap-aggregator.ts
+var HeatmapAggregator = class {
+  constructor(width, height, gridSize) {
+    this.width = width;
+    this.height = height;
+    this.gridSize = gridSize;
+    if (gridSize <= 0) throw new Error("gridSize must be > 0");
+    this.grid = new Float32Array(gridSize * gridSize);
+  }
+  grid;
+  maxCount = 0;
+  /**
+   * Add a normalized point (0–1 range) to the heatmap.
+   * Points outside [0, 1] are clamped to the grid boundary.
+   */
+  addPoint(x, y) {
+    const col = Math.min(Math.floor(x * this.gridSize), this.gridSize - 1);
+    const row = Math.min(Math.floor(y * this.gridSize), this.gridSize - 1);
+    const idx = row * this.gridSize + col;
+    this.grid[idx] += 1;
+    if (this.grid[idx] > this.maxCount) {
+      this.maxCount = this.grid[idx];
+    }
+  }
+  /** Add a pixel-coordinate point. Normalizes against the configured width/height. */
+  addPixelPoint(px, py) {
+    this.addPoint(px / this.width, py / this.height);
+  }
+  getHeatmap() {
+    return {
+      width: this.width,
+      height: this.height,
+      gridSize: this.gridSize,
+      cells: new Float32Array(this.grid),
+      maxCount: this.maxCount
+    };
+  }
+  reset() {
+    this.grid.fill(0);
+    this.maxCount = 0;
+  }
+  /** Total number of points accumulated */
+  get totalPoints() {
+    let total = 0;
+    for (let i = 0; i < this.grid.length; i++) {
+      total += this.grid[i];
+    }
+    return total;
+  }
+};
+
+// src/analytics/analytics-provider.ts
+var AnalyticsProvider = class {
+  constructor(liveStateManager, trackStore, getZoneHistoryCb, getHeatmapCb, lastLiveState = null) {
+    this.liveStateManager = liveStateManager;
+    this.trackStore = trackStore;
+    this.getZoneHistoryCb = getZoneHistoryCb;
+    this.getHeatmapCb = getHeatmapCb;
+    this.lastLiveState = lastLiveState;
+  }
+  /** Called by the orchestrator each frame to update the cached live state */
+  updateLiveState(state) {
+    this.lastLiveState = state;
+  }
+  getLiveState(_deviceId) {
+    return this.lastLiveState;
+  }
+  getTracks(_deviceId, filter) {
+    const tracks = this.lastLiveState?.tracks ?? [];
+    if (!filter) return [...tracks];
+    return tracks.filter((t) => {
+      if (filter.class && !filter.class.includes(t.class)) return false;
+      if (filter.state && !filter.state.includes(t.state)) return false;
+      if (filter.inZone && !t.inZones.includes(filter.inZone)) return false;
+      if (filter.minDwellMs !== void 0 && t.dwellTimeMs < filter.minDwellMs) return false;
+      return true;
+    });
+  }
+  getZoneState(_deviceId, zoneId) {
+    return this.lastLiveState?.zones.find((z) => z.zoneId === zoneId) ?? null;
+  }
+  async getZoneHistory(deviceId, zoneId, options) {
+    if (this.getZoneHistoryCb) {
+      return this.getZoneHistoryCb(deviceId, zoneId, options);
+    }
+    return [];
+  }
+  async getHeatmap(deviceId, options) {
+    if (this.getHeatmapCb) {
+      return this.getHeatmapCb(deviceId, options);
+    }
+    const gridSize = options.resolution;
+    return {
+      width: 1920,
+      height: 1080,
+      gridSize,
+      cells: new Float32Array(gridSize * gridSize),
+      maxCount: 0
+    };
+  }
+  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 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
+      }
+    };
+  }
+  async ensureOutputDir() {
+    if (this.config.outputDir) {
+      const { mkdir } = await import("fs/promises");
+      await mkdir(this.config.outputDir, { recursive: true });
+    }
+  }
+};
+
+// src/pipeline/analysis-pipeline.ts
+var AnalysisPipeline = class {
+  id = "pipeline-analysis";
+  manifest = {
+    id: "pipeline-analysis",
+    name: "Pipeline Analysis",
+    version: "0.1.0",
+    description: "Object tracking, state analysis, zone evaluation, and event emission",
+    packageName: "@camstack/lib-pipeline-analysis"
+  };
+  config;
+  cameras = /* @__PURE__ */ new Map();
+  knownFaces = [];
+  knownPlates = [];
+  listeners = /* @__PURE__ */ new Map();
+  /** Optional callback: server orchestrator can hook in to persist finished tracks */
+  onTrackFinished;
+  constructor(config = {}) {
+    this.config = {
+      tracker: config.tracker ?? {},
+      stateAnalyzer: config.stateAnalyzer ?? {},
+      eventFilter: config.eventFilter ?? {},
+      snapshot: config.snapshot ?? {},
+      heatmapGridSize: config.heatmapGridSize ?? 32,
+      defaultFrameWidth: config.defaultFrameWidth ?? 1920,
+      defaultFrameHeight: config.defaultFrameHeight ?? 1080
+    };
+  }
+  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);
+  }
+  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 trackIds.slice(0, classifierResults.length).map((trackId, i) => ({
+      trackId,
+      classifications: classifierResults[i] ?? []
+    }));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnalysisPipeline,
+  AnalyticsProvider,
+  DEFAULT_EVENT_FILTER_CONFIG,
+  DEFAULT_SNAPSHOT_CONFIG,
+  DEFAULT_STATE_ANALYZER_CONFIG,
+  DEFAULT_TRACKER_CONFIG,
+  DetectionEventEmitter,
+  EventFilter,
+  HeatmapAggregator,
+  LiveStateManager,
+  SnapshotManager,
+  SortTracker,
+  StateAnalyzer,
+  TrackStore,
+  ZoneEvaluator,
+  bboxCentroid,
+  greedyAssignment,
+  lineIntersection,
+  normalizeToPixel,
+  pointInPolygon,
+  tripwireCrossing
+});
+//# sourceMappingURL=index.js.map