@camstack/addon-pipeline-analysis 0.1.2 → 0.1.4

package/dist/index.mjs

@@ -1,940 +1,22 @@
-// src/zones/geometry.ts
-function pointInPolygon(point, polygon) {
-  if (polygon.length < 3) return false;
-  let inside = false;
-  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-    const xi = polygon[i].x, yi = polygon[i].y;
-    const xj = polygon[j].x, yj = polygon[j].y;
-    const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.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 t = ((b.p1.x - a.p1.x) * dy2 - (b.p1.y - a.p1.y) * dx2) / denom;
-  const u = ((b.p1.x - a.p1.x) * dy1 - (b.p1.y - a.p1.y) * 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, wire) {
-  const movement = { p1: prev, p2: curr };
-  const intersection = lineIntersection(movement, wire);
-  if (!intersection) return null;
-  const cross = (curr.x - prev.x) * (wire.p2.y - wire.p1.y) - (curr.y - prev.y) * (wire.p2.x - wire.p1.x);
-  return { crossed: true, direction: cross > 0 ? "right" : "left" };
-}
-function bboxCentroid(bbox) {
-  return { x: bbox.x + bbox.w / 2, y: bbox.y + bbox.h / 2 };
-}
-function normalizeToPixel(p, width, height) {
-  return { x: p.x * width, y: p.y * height };
-}
-
-// src/tracker/sort-tracker.ts
-var DEFAULT_TRACKER_CONFIG = {
-  iouThreshold: 0.3,
-  maxMissedFrames: 30,
-  minHits: 3
-};
-var MAX_PATH_LENGTH = 300;
-var nextTrackId = 1;
-function iou(a, b) {
-  const ax1 = a.x, ay1 = a.y, ax2 = a.x + a.w, ay2 = a.y + a.h;
-  const bx1 = b.x, by1 = b.y, bx2 = b.x + b.w, by2 = b.y + b.h;
-  const ix1 = Math.max(ax1, bx1), iy1 = Math.max(ay1, by1);
-  const ix2 = Math.min(ax2, bx2), iy2 = Math.min(ay2, by2);
-  const iw = Math.max(0, ix2 - ix1), ih = Math.max(0, iy2 - iy1);
-  const interArea = iw * ih;
-  const aArea = a.w * a.h;
-  const bArea = b.w * b.h;
-  const unionArea = aArea + bArea - interArea;
-  return unionArea > 0 ? interArea / unionArea : 0;
-}
-var SortTracker = class {
-  config;
-  tracks = [];
-  lostTracks = [];
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_TRACKER_CONFIG, ...config };
-  }
-  update(detections, timestamp) {
-    const used = /* @__PURE__ */ new Set();
-    const matchedTracks = /* @__PURE__ */ new Set();
-    const matched = /* @__PURE__ */ new Map();
-    const pairs = [];
-    for (const track of this.tracks) {
-      for (let di = 0; di < detections.length; di++) {
-        const score = iou(track.bbox, detections[di].bbox);
-        if (score >= this.config.iouThreshold) {
-          pairs.push({ track, detIdx: di, score });
-        }
-      }
-    }
-    pairs.sort((a, b) => b.score - a.score);
-    for (const pair of pairs) {
-      if (matchedTracks.has(pair.track) || used.has(pair.detIdx)) continue;
-      matched.set(pair.track, detections[pair.detIdx]);
-      matchedTracks.add(pair.track);
-      used.add(pair.detIdx);
-    }
-    for (const [track, det] of matched) {
-      const prevCenter = bboxCentroid({ x: track.bbox.x, y: track.bbox.y, w: track.bbox.w, h: track.bbox.h });
-      const newCenter = bboxCentroid({ x: det.bbox.x, y: det.bbox.y, w: det.bbox.w, h: det.bbox.h });
-      track.bbox = det.bbox;
-      track.class = det.class;
-      track.originalClass = det.originalClass;
-      track.score = det.score;
-      track.age = 0;
-      track.hits++;
-      track.lastSeen = timestamp;
-      track.velocity = { dx: newCenter.x - prevCenter.x, dy: newCenter.y - prevCenter.y };
-      track.path.push(det.bbox);
-      if (track.path.length > MAX_PATH_LENGTH) track.path.shift();
-    }
-    const surviving = [];
-    for (const track of this.tracks) {
-      if (matchedTracks.has(track)) {
-        surviving.push(track);
-      } else {
-        track.age++;
-        if (track.age > this.config.maxMissedFrames) {
-          track.lost = true;
-          this.lostTracks.push(track);
-        } else {
-          surviving.push(track);
-        }
-      }
-    }
-    for (let di = 0; di < detections.length; di++) {
-      if (used.has(di)) continue;
-      const det = detections[di];
-      surviving.push({
-        id: `track-${nextTrackId++}`,
-        bbox: det.bbox,
-        class: det.class,
-        originalClass: det.originalClass,
-        score: det.score,
-        age: 0,
-        hits: 1,
-        path: [det.bbox],
-        firstSeen: timestamp,
-        lastSeen: timestamp,
-        velocity: { dx: 0, dy: 0 },
-        lost: false
-      });
-    }
-    this.tracks = surviving;
-    return this.tracks.filter((t) => t.hits >= this.config.minHits).map((t) => ({
-      class: t.class,
-      originalClass: t.originalClass,
-      score: t.score,
-      bbox: t.bbox,
-      trackId: t.id,
-      trackAge: t.hits,
-      velocity: t.velocity,
-      path: [...t.path]
-    }));
-  }
-  getActiveTracks() {
-    return this.tracks;
-  }
-  getLostTracks() {
-    return this.lostTracks;
-  }
-  reset() {
-    this.tracks = [];
-    this.lostTracks = [];
-  }
-};
-
-// src/tracker/state-analyzer.ts
-var DEFAULT_STATE_ANALYZER_CONFIG = {
-  stationaryThresholdSec: 10,
-  loiteringThresholdSec: 60,
-  velocityThreshold: 2,
-  enteringFrames: 5
-};
-var StateAnalyzer = class {
-  config;
-  states = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_STATE_ANALYZER_CONFIG, ...config };
-  }
-  analyze(tracks, timestamp) {
-    const currentIds = new Set(tracks.map((t) => t.trackId));
-    const results = [];
-    for (const track of tracks) {
-      let ts = this.states.get(track.trackId);
-      const center = bboxCentroid({ x: track.bbox.x, y: track.bbox.y, w: track.bbox.w, h: track.bbox.h });
-      if (!ts) {
-        ts = {
-          enteredAt: timestamp,
-          stationarySince: void 0,
-          totalDistancePx: 0,
-          lastPosition: center,
-          frameCount: 1
-        };
-        this.states.set(track.trackId, ts);
-      } else {
-        const dx = center.x - ts.lastPosition.x;
-        const dy = center.y - ts.lastPosition.y;
-        const dist = Math.sqrt(dx * dx + dy * dy);
-        ts.totalDistancePx += dist;
-        ts.lastPosition = center;
-        ts.frameCount++;
-      }
-      const velocity = track.velocity ? Math.sqrt(track.velocity.dx ** 2 + track.velocity.dy ** 2) : 0;
-      const dwellTimeMs = timestamp - ts.enteredAt;
-      let state;
-      if (ts.frameCount <= this.config.enteringFrames) {
-        state = "entering";
-      } else if (velocity <= this.config.velocityThreshold) {
-        if (!ts.stationarySince) {
-          ts.stationarySince = timestamp;
-        }
-        const stationaryDurationSec = (timestamp - ts.stationarySince) / 1e3;
-        if (stationaryDurationSec >= this.config.loiteringThresholdSec) {
-          state = "loitering";
-        } else if (stationaryDurationSec >= this.config.stationaryThresholdSec) {
-          state = "stationary";
-        } else {
-          state = "moving";
-        }
-      } else {
-        ts.stationarySince = void 0;
-        state = "moving";
-      }
-      results.push({
-        trackId: track.trackId,
-        state,
-        stationarySince: ts.stationarySince,
-        enteredAt: ts.enteredAt,
-        totalDistancePx: ts.totalDistancePx,
-        dwellTimeMs
-      });
-    }
-    for (const [trackId, ts] of this.states) {
-      if (!currentIds.has(trackId)) {
-        results.push({
-          trackId,
-          state: "leaving",
-          stationarySince: ts.stationarySince,
-          enteredAt: ts.enteredAt,
-          totalDistancePx: ts.totalDistancePx,
-          dwellTimeMs: timestamp - ts.enteredAt
-        });
-        this.states.delete(trackId);
-      }
-    }
-    return results;
-  }
-  reset() {
-    this.states.clear();
-  }
-};
-
-// src/events/event-filter.ts
-var DEFAULT_EVENT_EMITTER_CONFIG = {
-  minTrackAge: 3,
-  cooldownSec: 5,
-  enabledTypes: [
-    "object.entering",
-    "object.leaving",
-    "object.stationary",
-    "object.loitering",
-    "zone.enter",
-    "zone.exit",
-    "tripwire.cross"
-  ]
-};
-
-// src/events/event-emitter.ts
-var STATE_TO_EVENT = {
-  entering: "object.entering",
-  leaving: "object.leaving",
-  stationary: "object.stationary",
-  loitering: "object.loitering"
-};
-var ZONE_TYPE_TO_EVENT = {
-  "zone-enter": "zone.enter",
-  "zone-exit": "zone.exit",
-  "zone-loiter": "zone.enter",
-  "tripwire-cross": "tripwire.cross"
-};
-var eventIdCounter = 0;
-var DetectionEventEmitter = class {
-  config;
-  previousStates = /* @__PURE__ */ new Map();
-  lastEmitted = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_EVENT_EMITTER_CONFIG, ...config };
-  }
-  emit(tracks, states, zoneEvents, classifications, deviceId) {
-    const events = [];
-    const now = Date.now();
-    const stateMap = new Map(states.map((s) => [s.trackId, s]));
-    const trackMap = new Map(tracks.map((t) => [t.trackId, t]));
-    for (const state of states) {
-      const track = trackMap.get(state.trackId);
-      if (!track) continue;
-      if (track.trackAge < this.config.minTrackAge) continue;
-      const eventType = STATE_TO_EVENT[state.state];
-      if (!eventType) continue;
-      if (!this.config.enabledTypes.includes(eventType)) continue;
-      const prevState = this.previousStates.get(state.trackId);
-      if (prevState === state.state) continue;
-      const cooldownKey = `${state.trackId}:${eventType}`;
-      const lastTime = this.lastEmitted.get(cooldownKey) ?? 0;
-      if ((now - lastTime) / 1e3 < this.config.cooldownSec) continue;
-      this.previousStates.set(state.trackId, state.state);
-      this.lastEmitted.set(cooldownKey, now);
-      events.push({
-        id: `evt-${++eventIdCounter}`,
-        type: eventType,
-        timestamp: now,
-        deviceId,
-        detection: track,
-        classifications,
-        objectState: state,
-        zoneEvents: zoneEvents.filter((z) => z.trackId === state.trackId),
-        trackPath: [...track.path]
-      });
-    }
-    for (const ze of zoneEvents) {
-      const eventType = ZONE_TYPE_TO_EVENT[ze.type];
-      if (!eventType) continue;
-      if (!this.config.enabledTypes.includes(eventType)) continue;
-      const track = trackMap.get(ze.trackId);
-      if (!track || track.trackAge < this.config.minTrackAge) continue;
-      const state = stateMap.get(ze.trackId);
-      events.push({
-        id: `evt-${++eventIdCounter}`,
-        type: eventType,
-        timestamp: now,
-        deviceId,
-        detection: track,
-        classifications,
-        objectState: state ?? {
-          trackId: ze.trackId,
-          state: "moving",
-          enteredAt: now,
-          totalDistancePx: 0,
-          dwellTimeMs: 0
-        },
-        zoneEvents: [ze],
-        trackPath: [...track.path]
-      });
-    }
-    for (const state of states) {
-      if (state.state === "leaving") {
-        this.previousStates.delete(state.trackId);
-      }
-    }
-    return events;
-  }
-  reset() {
-    this.previousStates.clear();
-    this.lastEmitted.clear();
-  }
-};
-
-// src/zones/overlap.ts
-function bboxPolygonOverlap(bbox, polygon) {
-  const area = bbox.w * bbox.h;
-  if (area <= 0) return 0;
-  const gridSize = 8;
-  let inside = 0;
-  const total = gridSize * gridSize;
-  for (let row = 0; row < gridSize; row++) {
-    for (let col = 0; col < gridSize; col++) {
-      const px = bbox.x + (col + 0.5) * (bbox.w / gridSize);
-      const py = bbox.y + (row + 0.5) * (bbox.h / gridSize);
-      if (pointInPolygon({ x: px, y: py }, polygon)) {
-        inside++;
-      }
-    }
-  }
-  return inside / total;
-}
-function maskPolygonOverlap(mask, maskWidth, maskHeight, bbox, polygon, _frameWidth, _frameHeight) {
-  let totalMaskPixels = 0;
-  let insidePolygon = 0;
-  for (let my = 0; my < maskHeight; my++) {
-    for (let mx = 0; mx < maskWidth; mx++) {
-      if (mask[my * maskWidth + mx] === 0) continue;
-      totalMaskPixels++;
-      const frameX = bbox.x + mx / maskWidth * bbox.w;
-      const frameY = bbox.y + my / maskHeight * bbox.h;
-      if (pointInPolygon({ x: frameX, y: frameY }, polygon)) {
-        insidePolygon++;
-      }
-    }
-  }
-  if (totalMaskPixels === 0) return 0;
-  return insidePolygon / totalMaskPixels;
-}
-
-// src/zones/zone-engine.ts
-var ZoneEngine = class {
-  /**
-   * Annotate a single detection with its zone memberships.
-   * Returns zones where the detection overlaps above threshold.
-   */
-  annotateDetection(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight, className) {
-    const memberships = [];
-    for (const zone of zones) {
-      if (zone.classFilter && zone.classFilter.length > 0 && className) {
-        if (!zone.classFilter.includes(className)) continue;
-      }
-      const pixelPolygon = zone.polygon.map((p) => normalizeToPixel(p, frameWidth, frameHeight));
-      let overlap;
-      if (zone.preferMask && mask && maskWidth && maskHeight) {
-        overlap = maskPolygonOverlap(mask, maskWidth, maskHeight, bbox, pixelPolygon, frameWidth, frameHeight);
-      } else {
-        overlap = bboxPolygonOverlap(bbox, pixelPolygon);
-      }
-      if (overlap >= zone.overlapThreshold) {
-        memberships.push({
-          zoneId: zone.id,
-          zoneName: zone.name,
-          overlap,
-          mode: zone.detectionMode
-        });
-      }
-    }
-    return memberships;
-  }
-  /**
-   * Filter detections based on zone include/exclude/monitor logic for a given stage.
-   */
-  filterDetections(detections, zones, frameWidth, frameHeight, stage, getClassName, getMask) {
-    if (zones.length === 0) {
-      return {
-        passed: detections,
-        excluded: [],
-        annotations: new Map(detections.map((d) => [d, []]))
-      };
-    }
-    const modeKey = stage === "motion" ? "motionMode" : "detectionMode";
-    const hasInclude = zones.some((z) => z[modeKey] === "include");
-    const passed = [];
-    const excluded = [];
-    const annotations = /* @__PURE__ */ new Map();
-    for (const det of detections) {
-      const className = getClassName?.(det);
-      const maskInfo = getMask?.(det);
-      const memberships = this.annotateDetection(
-        det,
-        zones,
-        frameWidth,
-        frameHeight,
-        maskInfo?.mask,
-        maskInfo?.width,
-        maskInfo?.height,
-        className
-      );
-      annotations.set(det, memberships);
-      const stageMemberships = memberships.filter((m) => m.mode !== "monitor");
-      if (hasInclude) {
-        const inInclude = stageMemberships.some((m) => m.mode === "include");
-        if (inInclude) {
-          passed.push(det);
-        } else {
-          excluded.push(det);
-        }
-      } else {
-        const inExclude = stageMemberships.some((m) => m.mode === "exclude");
-        if (inExclude) {
-          excluded.push(det);
-        } else {
-          passed.push(det);
-        }
-      }
-    }
-    return { passed, excluded, annotations };
-  }
-  /**
-   * Generate an auto-border exclusion zone as a polygon with a hole.
-   */
-  generateAutoBorderZone(percent) {
-    const p = Math.max(0, Math.min(0.2, percent));
-    return {
-      id: "__auto-border-exclude",
-      name: "Auto Border Exclusion",
-      polygon: [
-        { x: 0, y: 0 },
-        { x: 0, y: 1 },
-        { x: 1, y: 1 },
-        { x: 1, y: 0 },
-        { x: p, y: p },
-        { x: 1 - p, y: p },
-        { x: 1 - p, y: 1 - p },
-        { x: p, y: 1 - p }
-      ],
-      motionMode: "exclude",
-      detectionMode: "exclude",
-      overlapThreshold: 0.1,
-      preferMask: false,
-      color: "#888888"
-    };
-  }
-};
-
-// src/analytics/track-store.ts
-var MAX_PATH_LENGTH2 = 300;
-var TrackStore = class {
-  tracks = /* @__PURE__ */ new Map();
-  update(tracked, zoneEvents, classifications, timestamp) {
-    for (const t of tracked) {
-      let at = this.tracks.get(t.trackId);
-      if (!at) {
-        at = {
-          trackId: t.trackId,
-          class: t.class,
-          originalClass: t.originalClass,
-          state: "entering",
-          firstSeen: timestamp,
-          lastSeen: timestamp,
-          path: [],
-          zoneTransitions: [],
-          events: []
-        };
-        this.tracks.set(t.trackId, at);
-      }
-      at.lastSeen = timestamp;
-      at.class = t.class;
-      at.path.push({
-        timestamp,
-        bbox: t.bbox,
-        velocity: t.velocity ?? { dx: 0, dy: 0 }
-      });
-      if (at.path.length > MAX_PATH_LENGTH2) at.path.shift();
-    }
-    for (const ze of zoneEvents) {
-      const at = this.tracks.get(ze.trackId);
-      if (!at) continue;
-      if (ze.type === "zone-enter") {
-        at.zoneTransitions.push({
-          zoneId: ze.zoneId,
-          zoneName: ze.zoneName,
-          entered: ze.timestamp,
-          dwellMs: 0
-        });
-      } else if (ze.type === "zone-exit") {
-        const transition = [...at.zoneTransitions].reverse().find(
-          (zt) => zt.zoneId === ze.zoneId && !zt.exited
-        );
-        if (transition) {
-          transition.exited = ze.timestamp;
-          transition.dwellMs = ze.timestamp - transition.entered;
-        }
-      }
-    }
-  }
-  addEvent(trackId, event) {
-    const at = this.tracks.get(trackId);
-    if (at) {
-      at.events.push(event);
-      if (!at.bestSnapshot && event.snapshot) {
-        at.bestSnapshot = event.snapshot;
-      }
-    }
-  }
-  getTrackDetail(trackId) {
-    const at = this.tracks.get(trackId);
-    if (!at) return null;
-    return this.toDetail(at);
-  }
-  finishTrack(trackId) {
-    const at = this.tracks.get(trackId);
-    if (!at) return null;
-    this.tracks.delete(trackId);
-    return this.toDetail(at);
-  }
-  getActiveTrackIds() {
-    return [...this.tracks.keys()];
-  }
-  reset() {
-    this.tracks.clear();
-  }
-  toDetail(at) {
-    return {
-      trackId: at.trackId,
-      class: at.class,
-      originalClass: at.originalClass,
-      state: at.state,
-      firstSeen: at.firstSeen,
-      lastSeen: at.lastSeen,
-      totalDwellMs: at.lastSeen - at.firstSeen,
-      path: at.path,
-      identity: at.identity,
-      plateText: at.plateText,
-      subClass: at.subClass,
-      zoneTransitions: at.zoneTransitions,
-      bestSnapshot: at.bestSnapshot,
-      events: at.events
-    };
-  }
-};
-
-// src/analytics/heatmap.ts
-var HeatmapAggregator = class {
-  gridSize;
-  cells;
-  maxCount = 0;
-  _totalPoints = 0;
-  constructor(gridSize = 32) {
-    this.gridSize = gridSize;
-    this.cells = new Float32Array(gridSize * gridSize);
-  }
-  get totalPoints() {
-    return this._totalPoints;
-  }
-  addPoint(x, y) {
-    const col = Math.min(this.gridSize - 1, Math.max(0, Math.floor(x * this.gridSize)));
-    const row = Math.min(this.gridSize - 1, Math.max(0, Math.floor(y * this.gridSize)));
-    const idx = row * this.gridSize + col;
-    this.cells[idx]++;
-    if (this.cells[idx] > this.maxCount) this.maxCount = this.cells[idx];
-    this._totalPoints++;
-  }
-  getHeatmap() {
-    return {
-      width: this.gridSize,
-      height: this.gridSize,
-      gridSize: this.gridSize,
-      cells: new Float32Array(this.cells),
-      maxCount: this.maxCount
-    };
-  }
-  reset() {
-    this.cells.fill(0);
-    this.maxCount = 0;
-    this._totalPoints = 0;
-  }
-};
-
-// src/analytics/analytics-provider.ts
-var AnalyticsProvider = class {
-  liveStates = /* @__PURE__ */ new Map();
-  trackStores = /* @__PURE__ */ new Map();
-  heatmaps = /* @__PURE__ */ new Map();
-  updateLiveState(deviceId, state) {
-    this.liveStates.set(deviceId, state);
-  }
-  getTrackStore(deviceId) {
-    let store = this.trackStores.get(deviceId);
-    if (!store) {
-      store = new TrackStore();
-      this.trackStores.set(deviceId, store);
-    }
-    return store;
-  }
-  getHeatmapAggregator(deviceId, gridSize = 32) {
-    let hm = this.heatmaps.get(deviceId);
-    if (!hm) {
-      hm = new HeatmapAggregator(gridSize);
-      this.heatmaps.set(deviceId, hm);
-    }
-    return hm;
-  }
-  getLiveState(deviceId) {
-    return this.liveStates.get(deviceId) ?? null;
-  }
-  getTracks(deviceId, filter) {
-    const state = this.liveStates.get(deviceId);
-    if (!state) return [];
-    let tracks = [...state.tracks];
-    if (filter?.class) tracks = tracks.filter((t) => filter.class.includes(t.class));
-    if (filter?.state) tracks = tracks.filter((t) => filter.state.includes(t.state));
-    if (filter?.minDwellMs) tracks = tracks.filter((t) => t.dwellTimeMs >= filter.minDwellMs);
-    return tracks;
-  }
-  getZoneState(deviceId, zoneId) {
-    const state = this.liveStates.get(deviceId);
-    return state?.zones.find((z) => z.zoneId === zoneId) ?? null;
-  }
-  async getZoneHistory(_deviceId, _zoneId, _options) {
-    return [];
-  }
-  async getHeatmap(deviceId, _options) {
-    const hm = this.heatmaps.get(deviceId);
-    return hm?.getHeatmap() ?? { width: 32, height: 32, gridSize: 32, cells: new Float32Array(32 * 32), maxCount: 0 };
-  }
-  getTrackDetail(deviceId, trackId) {
-    const store = this.trackStores.get(deviceId);
-    return store?.getTrackDetail(trackId) ?? null;
-  }
-  getCameraStatus(_deviceId) {
-    return [];
-  }
-};
-
-// src/analytics/live-state.ts
-var FPS_WINDOW_MS = 5e3;
-var LiveStateManager = class {
-  frameTimes = [];
-  pipelineTimes = [];
-  buildState(deviceId, tracks, states, pipelineStatus, timestamp, lastEvent, pipelineMs) {
-    this.frameTimes.push(timestamp);
-    const cutoff = timestamp - FPS_WINDOW_MS;
-    while (this.frameTimes.length > 0 && this.frameTimes[0] < cutoff) this.frameTimes.shift();
-    const currentFps = this.frameTimes.length > 1 ? (this.frameTimes.length - 1) / ((this.frameTimes[this.frameTimes.length - 1] - this.frameTimes[0]) / 1e3) : 0;
-    if (pipelineMs !== void 0) {
-      this.pipelineTimes.push(pipelineMs);
-      if (this.pipelineTimes.length > 100) this.pipelineTimes.shift();
-    }
-    const avgPipelineMs = this.pipelineTimes.length > 0 ? this.pipelineTimes.reduce((a, b) => a + b, 0) / this.pipelineTimes.length : 0;
-    const stateMap = new Map(states.map((s) => [s.trackId, s]));
-    const objectCounts = {};
-    let moving = 0, stationary = 0;
-    const trackSummaries = [];
-    for (const t of tracks) {
-      objectCounts[t.class] = (objectCounts[t.class] ?? 0) + 1;
-      const s = stateMap.get(t.trackId);
-      if (s?.state === "moving" || s?.state === "entering") moving++;
-      if (s?.state === "stationary" || s?.state === "loitering") stationary++;
-      trackSummaries.push({
-        trackId: t.trackId,
-        class: t.class,
-        originalClass: t.originalClass,
-        state: s?.state ?? "entering",
-        bbox: t.bbox,
-        velocity: t.velocity ?? { dx: 0, dy: 0 },
-        dwellTimeMs: s?.dwellTimeMs ?? 0,
-        inZones: []
-      });
-    }
-    return {
-      deviceId,
-      lastFrameTimestamp: timestamp,
-      activeObjects: tracks.length,
-      movingObjects: moving,
-      stationaryObjects: stationary,
-      objectCounts,
-      tracks: trackSummaries,
-      zones: [],
-      lastEvent,
-      pipelineStatus: [...pipelineStatus],
-      avgPipelineMs,
-      currentFps
-    };
-  }
-  reset() {
-    this.frameTimes.length = 0;
-    this.pipelineTimes.length = 0;
-  }
-};
-
-// src/pipeline/analysis-pipeline.ts
-var AnalysisPipeline = class {
-  manifest = {
-    id: "analysis-pipeline",
-    name: "Analysis Pipeline",
-    version: "0.1.0",
-    description: "Per-camera zone engine, tracker, event emitter and analytics",
-    capabilities: [{ name: "analysis-pipeline", mode: "singleton" }],
-    passive: true
-  };
-  cameraStates = /* @__PURE__ */ new Map();
-  analytics = new AnalyticsProvider();
-  liveStateCallbacks = /* @__PURE__ */ new Map();
-  // --------------------------------------------------------------------------
-  // ICamstackAddon
-  // --------------------------------------------------------------------------
-  async initialize(_context) {
-  }
-  async shutdown() {
-    this.cameraStates.clear();
-    this.liveStateCallbacks.clear();
-  }
-  getCapabilityProvider(name) {
-    if (name === "analysis-pipeline") {
-      return this;
-    }
-    return null;
-  }
-  // --------------------------------------------------------------------------
-  // IAnalysisAddon — configuration
-  // --------------------------------------------------------------------------
-  setCameraPipeline(deviceId, _config) {
-    this.ensureCameraState(deviceId);
-  }
-  setCameraZones(deviceId, zones) {
-    const state = this.ensureCameraState(deviceId);
-    this.cameraStates.set(deviceId, { ...state, zones });
-  }
-  setCameraMotionConfig(_deviceId, _source) {
-  }
-  setKnownFaces(_faces) {
-  }
-  setKnownPlates(_plates) {
-  }
-  onLiveStateChange(deviceId, callback) {
-    let callbacks = this.liveStateCallbacks.get(deviceId);
-    if (!callbacks) {
-      callbacks = /* @__PURE__ */ new Set();
-      this.liveStateCallbacks.set(deviceId, callbacks);
-    }
-    callbacks.add(callback);
-    return () => {
-      this.liveStateCallbacks.get(deviceId)?.delete(callback);
-    };
-  }
-  // --------------------------------------------------------------------------
-  // IAnalysisAddon — frame processing
-  // The interface declares (deviceId, frame) but callers may pass an optional
-  // PipelineRunResult as a third argument; we accept it here.
-  // --------------------------------------------------------------------------
-  async processFrame(deviceId, frame, pipelineResult) {
-    const state = this.ensureCameraState(deviceId);
-    const timestamp = frame.timestamp;
-    const frameWidth = pipelineResult?.imageWidth ?? frame.width;
-    const frameHeight = pipelineResult?.imageHeight ?? frame.height;
-    const flatDetections = pipelineResult ? pipelineResult.detections.map((det) => {
-      const bbox = this.convertBbox(det.bbox);
-      const detection = {
-        class: det.className,
-        originalClass: det.originalClass ?? det.className,
-        score: det.confidence,
-        bbox
-      };
-      return { ...bbox, detection };
-    }) : [];
-    const zoneEngine = new ZoneEngine();
-    const { passed: filteredFlat } = zoneEngine.filterDetections(
-      flatDetections,
-      state.zones,
-      frameWidth,
-      frameHeight,
-      "detection",
-      (fd) => fd.detection.class
-    );
-    const filteredDetections = filteredFlat.map((fd) => fd.detection);
-    const trackedDetections = state.tracker.update(filteredDetections, timestamp);
-    const objectStates = state.stateAnalyzer.analyze(trackedDetections, timestamp);
-    const events = state.eventEmitter.emit(
-      trackedDetections,
-      objectStates,
-      [],
-      [],
-      deviceId
-    );
-    const trackStore = this.analytics.getTrackStore(deviceId);
-    trackStore.update(trackedDetections, [], [], timestamp);
-    const heatmap = this.analytics.getHeatmapAggregator(deviceId);
-    for (const t of trackedDetections) {
-      const cx = (t.bbox.x + t.bbox.w / 2) / frameWidth;
-      const cy = (t.bbox.y + t.bbox.h / 2) / frameHeight;
-      heatmap.addPoint(cx, cy);
-    }
-    for (const event of events) {
-      trackStore.addEvent(event.detection.trackId, event);
-    }
-    const liveState = state.liveStateManager.buildState(
-      deviceId,
-      trackedDetections,
-      objectStates,
-      state.pipelineStatus,
-      timestamp,
-      events[events.length - 1],
-      pipelineResult?.totalMs
-    );
-    this.analytics.updateLiveState(deviceId, liveState);
-    const callbacks = this.liveStateCallbacks.get(deviceId);
-    if (callbacks && callbacks.size > 0) {
-      for (const cb of callbacks) {
-        cb(liveState);
-      }
-    }
-    return events;
-  }
-  // --------------------------------------------------------------------------
-  // ICameraAnalyticsProvider
-  // --------------------------------------------------------------------------
-  getLiveState(deviceId) {
-    return this.analytics.getLiveState(deviceId);
-  }
-  getTracks(deviceId, filter) {
-    return this.analytics.getTracks(deviceId, filter);
-  }
-  getZoneState(deviceId, zoneId) {
-    return this.analytics.getZoneState(deviceId, zoneId);
-  }
-  async getZoneHistory(deviceId, zoneId, options) {
-    return this.analytics.getZoneHistory(deviceId, zoneId, options);
-  }
-  async getHeatmap(deviceId, options) {
-    return this.analytics.getHeatmap(deviceId, options);
-  }
-  getTrackDetail(deviceId, trackId) {
-    return this.analytics.getTrackDetail(deviceId, trackId);
-  }
-  getCameraStatus(deviceId) {
-    return this.analytics.getCameraStatus(deviceId);
-  }
-  // --------------------------------------------------------------------------
-  // Private helpers
-  // --------------------------------------------------------------------------
-  ensureCameraState(deviceId) {
-    let state = this.cameraStates.get(deviceId);
-    if (!state) {
-      state = {
-        tracker: new SortTracker(),
-        stateAnalyzer: new StateAnalyzer(),
-        eventEmitter: new DetectionEventEmitter(),
-        liveStateManager: new LiveStateManager(),
-        zones: [],
-        pipelineStatus: []
-      };
-      this.cameraStates.set(deviceId, state);
-    }
-    return state;
-  }
-  /**
-   * Convert PipelineDetection bbox [x1, y1, x2, y2] to BoundingBox {x, y, w, h}.
-   * Pipeline bboxes are in pixel coordinates.
-   */
-  convertBbox(bbox) {
-    const [x1, y1, x2, y2] = bbox;
-    return { x: x1, y: y1, w: x2 - x1, h: y2 - y1 };
-  }
-};
-
-// src/addon.ts
-var AnalysisPipelineAddon = class {
-  manifest = {
-    id: "pipeline-analysis",
-    name: "Pipeline Analysis",
-    version: "0.1.0",
-    description: "Zone engine, object tracker, and analytics for detection pipeline",
-    capabilities: [
-      { name: "analysis-pipeline", mode: "singleton" }
-    ]
-  };
-  pipeline = null;
-  async initialize(context) {
-    this.pipeline = new AnalysisPipeline();
-    await this.pipeline.initialize(context);
-    context.logger.info("Pipeline Analysis addon initialized");
-  }
-  async shutdown() {
-    await this.pipeline?.shutdown();
-    this.pipeline = null;
-  }
-  getCapabilityProvider(name) {
-    if (name === "analysis-pipeline") {
-      return this.pipeline;
-    }
-    return null;
-  }
-};
+import {
+  AnalysisPipeline,
+  AnalysisPipelineAddon,
+  DEFAULT_STATE_ANALYZER_CONFIG,
+  DEFAULT_TRACKER_CONFIG,
+  DetectionEventEmitter,
+  HeatmapAggregator,
+  SortTracker,
+  StateAnalyzer,
+  TrackStore,
+  ZoneEngine,
+  bboxCentroid,
+  bboxPolygonOverlap,
+  lineIntersection,
+  maskPolygonOverlap,
+  normalizeToPixel,
+  pointInPolygon,
+  tripwireCrossing
+} from "./chunk-QMP6KSXZ.mjs";
 export {
   AnalysisPipeline,
   AnalysisPipelineAddon,