@camstack/addon-post-analysis 0.1.1

package/dist/pipeline-analytics/index.js

@@ -0,0 +1,2563 @@
+"use strict";
+const types = require("@camstack/types");
+const node_crypto = require("node:crypto");
+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 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 };
+}
+const DEFAULT_TRACKER_CONFIG = {
+  iouThreshold: 0.3,
+  maxMissedFrames: 30,
+  minHits: 3
+};
+const MAX_PATH_LENGTH = 300;
+let 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;
+}
+class SortTracker {
+  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 = [];
+  }
+}
+const DEFAULT_STATE_ANALYZER_CONFIG = {
+  stationaryThresholdSec: 10,
+  loiteringThresholdSec: 60,
+  velocityThreshold: 2,
+  enteringFrames: 5
+};
+class StateAnalyzer {
+  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();
+  }
+}
+const DEFAULT_EVENT_EMITTER_CONFIG = {
+  minTrackAge: 3,
+  cooldownSec: 5,
+  enabledTypes: [
+    "object.entering",
+    "object.leaving",
+    "object.stationary",
+    "object.loitering",
+    "zone.enter",
+    "zone.exit",
+    "tripwire.cross"
+  ]
+};
+const STATE_TO_EVENT = {
+  entering: "object.entering",
+  leaving: "object.leaving",
+  stationary: "object.stationary",
+  loitering: "object.loitering"
+};
+const ZONE_TYPE_TO_EVENT = {
+  "zone-enter": "zone.enter",
+  "zone-exit": "zone.exit",
+  "zone-loiter": "zone.enter",
+  "tripwire-cross": "tripwire.cross"
+};
+let eventIdCounter = 0;
+class DetectionEventEmitter {
+  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();
+  }
+}
+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;
+}
+const DEFAULT_OVERLAP_THRESHOLD = 0.85;
+function resolveRuleThreshold(rule) {
+  if (typeof rule.bboxInclusionPct === "number") return rule.bboxInclusionPct / 100;
+  if (typeof rule.overlapThreshold === "number") return rule.overlapThreshold;
+  return DEFAULT_OVERLAP_THRESHOLD;
+}
+class ZoneEngine {
+  /**
+   * Annotate a single detection with its zone memberships.
+   * Returns zones where the detection overlaps above any active
+   * rule's threshold (or the engine default if no rule sets one).
+   */
+  annotateDetection(bbox, zones, frameWidth, frameHeight, mask, maskWidth, maskHeight) {
+    const memberships = [];
+    for (const zone of zones) {
+      const pixelPolygon = zone.polygon.map((p) => normalizeToPixel(p, frameWidth, frameHeight));
+      const overlap = mask && maskWidth && maskHeight ? maskPolygonOverlap(mask, maskWidth, maskHeight, bbox, pixelPolygon) : bboxPolygonOverlap(bbox, pixelPolygon);
+      if (overlap >= DEFAULT_OVERLAP_THRESHOLD) {
+        memberships.push({ zoneId: zone.id, zoneName: zone.name, overlap });
+      }
+    }
+    return memberships;
+  }
+  /**
+   * Filter detections through a zone-rule set. `zones` provides the
+   * geometry catalogue; `rules` decides include / exclude behaviour.
+   * Pass an empty `rules` array to short-circuit (everything passes).
+   */
+  filterDetections(detections, zones, rules, frameWidth, frameHeight, getClassName, getMask) {
+    const annotations = /* @__PURE__ */ new Map();
+    if (rules.length === 0 || zones.length === 0) {
+      for (const det of detections) {
+        annotations.set(det, this.annotateDetection(
+          det,
+          zones,
+          frameWidth,
+          frameHeight
+        ));
+      }
+      return { passed: detections, excluded: [], annotations };
+    }
+    const zonesById = new Map(zones.map((z) => [z.id, z]));
+    const activeRules = rules.filter((r) => r.enabled !== false).map((rule) => ({
+      rule,
+      threshold: resolveRuleThreshold(rule),
+      zonesById
+    }));
+    const includeRules = activeRules.filter((r) => r.rule.mode === "include");
+    const excludeRules = activeRules.filter((r) => r.rule.mode === "exclude");
+    const whitelistMode = includeRules.length > 0;
+    const passed = [];
+    const excluded = [];
+    for (const det of detections) {
+      const memberships = this.annotateDetection(det, zones, frameWidth, frameHeight);
+      annotations.set(det, memberships);
+      const className = getClassName?.(det);
+      const maskInfo = getMask?.(det);
+      const inIncludeRule = includeRules.some(
+        (r) => ruleApplies(r, det, className, maskInfo, zones, frameWidth, frameHeight)
+      );
+      const inExcludeRule = excludeRules.some(
+        (r) => ruleApplies(r, det, className, maskInfo, zones, frameWidth, frameHeight)
+      );
+      if (whitelistMode) {
+        if (inIncludeRule && !inExcludeRule) {
+          passed.push(det);
+        } else {
+          excluded.push(det);
+        }
+      } else {
+        if (inExcludeRule) {
+          excluded.push(det);
+        } else {
+          passed.push(det);
+        }
+      }
+    }
+    return { passed, excluded, annotations };
+  }
+}
+function ruleApplies(resolved, det, className, maskInfo, _zones, frameWidth, frameHeight) {
+  const { rule, threshold, zonesById } = resolved;
+  if (rule.classFilter && rule.classFilter.length > 0) {
+    if (!className || !rule.classFilter.includes(className)) return false;
+  }
+  for (const zoneId of rule.zoneIds) {
+    const zone = zonesById.get(zoneId);
+    if (!zone) continue;
+    const pixelPolygon = zone.polygon.map((p) => normalizeToPixel(p, frameWidth, frameHeight));
+    const overlap = rule.preferMask && maskInfo ? maskPolygonOverlap(maskInfo.mask, maskInfo.width, maskInfo.height, det, pixelPolygon) : bboxPolygonOverlap(det, pixelPolygon);
+    if (overlap >= threshold) return true;
+  }
+  return false;
+}
+function mapObjectStateToTrackState(s) {
+  switch (s) {
+    case "entering":
+      return "entered";
+    case "leaving":
+      return "left";
+    case "stationary":
+    case "loitering":
+      return "idle";
+    case "moving":
+      return "moving";
+    default:
+      return "new";
+  }
+}
+class FrameProcessor {
+  deviceId;
+  tracker;
+  stateAnalyzer;
+  eventEmitter;
+  zones;
+  /**
+   * Detection-stage rules — applied as a safety-net post-pipeline
+   * filter. When motion-wasm + pipeline-executor land their own
+   * runtime gating (Phase 2b) the upstream pipeline already drops
+   * filtered detections; keeping the analytics-side filter as well
+   * ensures the same semantics for legacy paths and forked-worker
+   * runners that haven't picked up the new gating yet.
+   */
+  detectionRules;
+  zoneEngine = new ZoneEngine();
+  constructor(deviceId) {
+    this.deviceId = deviceId;
+    this.tracker = new SortTracker();
+    this.stateAnalyzer = new StateAnalyzer();
+    this.eventEmitter = new DetectionEventEmitter();
+    this.zones = [];
+    this.detectionRules = [];
+  }
+  setZones(zones) {
+    this.zones = zones;
+  }
+  setDetectionRules(rules) {
+    this.detectionRules = rules;
+  }
+  process(input) {
+    const { timestamp, frame } = input;
+    const frameWidth = frame.width;
+    const frameHeight = frame.height;
+    const flatDetections = frame.detections.filter((d) => d.kind === "first-level").map((det) => {
+      const bbox = {
+        x: det.bbox.x,
+        y: det.bbox.y,
+        w: det.bbox.width,
+        h: det.bbox.height
+      };
+      const detection = {
+        class: det.macroClass,
+        originalClass: det.debug?.originalClass ?? det.macroClass,
+        score: det.score,
+        bbox
+      };
+      return { ...bbox, detection, sourceId: det.id };
+    });
+    const { passed } = this.zoneEngine.filterDetections(
+      flatDetections,
+      this.zones,
+      this.detectionRules,
+      frameWidth,
+      frameHeight,
+      (fd) => fd.detection.class
+    );
+    const filteredDetections = passed.map((fd) => fd.detection);
+    const trackedDetections = this.tracker.update(filteredDetections, timestamp);
+    const objectStates = this.stateAnalyzer.analyze(trackedDetections, timestamp);
+    const rawEvents = this.eventEmitter.emit(
+      trackedDetections,
+      objectStates,
+      [],
+      [],
+      String(this.deviceId)
+    );
+    const zonesByTrack = /* @__PURE__ */ new Map();
+    for (const td of trackedDetections) {
+      const memberships = this.zoneEngine.annotateDetection(
+        td.bbox,
+        this.zones,
+        frameWidth,
+        frameHeight
+      );
+      zonesByTrack.set(td.trackId, memberships.map((m) => m.zoneId));
+    }
+    const tracked = trackedDetections.map((td) => {
+      const state = mapObjectStateToTrackState(
+        objectStates.find((o) => o.trackId === td.trackId)?.state
+      );
+      return {
+        trackId: td.trackId,
+        className: td.class,
+        confidence: td.score,
+        bbox: { ...td.bbox },
+        zones: zonesByTrack.get(td.trackId) ?? [],
+        state
+      };
+    });
+    const objectEvents = rawEvents.filter((e) => e.detection.trackId).map((e) => {
+      const td = trackedDetections.find((t) => t.trackId === e.detection.trackId);
+      const state = mapObjectStateToTrackState(
+        objectStates.find((o) => o.trackId === e.detection.trackId)?.state
+      );
+      const zones = zonesByTrack.get(e.detection.trackId) ?? [];
+      return {
+        id: node_crypto.randomUUID(),
+        deviceId: this.deviceId,
+        timestamp,
+        kind: "object",
+        trackId: e.detection.trackId,
+        className: e.detection.class,
+        confidence: e.detection.score,
+        bbox: td ? { ...td.bbox } : { x: 0, y: 0, w: 0, h: 0 },
+        zones,
+        state
+      };
+    });
+    return {
+      deviceId: this.deviceId,
+      timestamp,
+      frameWidth,
+      frameHeight,
+      tracked,
+      objectEvents,
+      rawTrackedDetections: trackedDetections
+    };
+  }
+}
+class BindingCache {
+  api;
+  logger;
+  capName;
+  state = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.api = deps.api;
+    this.logger = deps.logger;
+    this.capName = deps.capName ?? "pipeline-analytics";
+  }
+  async isActive(deviceId) {
+    const cached = this.state.get(deviceId);
+    if (cached !== void 0) return cached;
+    const pending = this.inflight.get(deviceId);
+    if (pending) return pending;
+    const promise = (async () => {
+      try {
+        const res = await this.api.deviceManager.getBindings.query({ deviceId });
+        const active = res.entries.some((e) => e.capName === this.capName);
+        this.state.set(deviceId, active);
+        return active;
+      } catch (err) {
+        this.logger.debug("BindingCache.isActive lookup failed", {
+          tags: { deviceId },
+          meta: { error: String(err) }
+        });
+        return false;
+      } finally {
+        this.inflight.delete(deviceId);
+      }
+    })();
+    this.inflight.set(deviceId, promise);
+    return promise;
+  }
+  onBindingsChanged(event) {
+    if (event.capName !== this.capName) return;
+    if (event.reason === "wrapper-activated") {
+      this.state.set(event.deviceId, true);
+      return;
+    }
+    if (event.reason === "wrapper-deactivated") {
+      this.state.set(event.deviceId, false);
+      return;
+    }
+    this.state.delete(event.deviceId);
+  }
+  invalidate(deviceId) {
+    this.state.delete(deviceId);
+  }
+  clearAll() {
+    this.state.clear();
+    this.inflight.clear();
+  }
+}
+const DEFAULT_CONFIG = {
+  ttlMs: 3e4,
+  maxPositionHistory: 300
+};
+const TRACKS_COLLECTION = "pipeline-analytics:tracks";
+const TRACKS_COLUMNS = [
+  { name: "id", type: "TEXT", primaryKey: true, notNull: true },
+  { name: "deviceId", type: "INTEGER", notNull: true },
+  { name: "className", type: "TEXT", notNull: true },
+  { name: "label", type: "TEXT" },
+  { name: "firstSeen", type: "INTEGER", notNull: true },
+  { name: "lastSeen", type: "INTEGER", notNull: true },
+  { name: "positions", type: "JSON" },
+  { name: "snapshots", type: "JSON" },
+  { name: "zonesVisited", type: "JSON" },
+  { name: "totalDistance", type: "REAL" },
+  { name: "state", type: "TEXT" }
+];
+const TRACKS_INDEXES = [
+  { name: "idx_tracks_device_lastSeen", columns: ["deviceId", "lastSeen"] },
+  { name: "idx_tracks_device_firstSeen", columns: ["deviceId", "firstSeen"] }
+];
+function cloneTrack(t) {
+  return {
+    trackId: t.trackId,
+    deviceId: t.deviceId,
+    className: t.className,
+    label: t.label,
+    firstSeen: t.firstSeen,
+    lastSeen: t.lastSeen,
+    positions: t.positions.map((p) => ({ ...p, bbox: { ...p.bbox } })),
+    snapshots: t.snapshots.map((s) => ({ ...s, position: { ...s.position, bbox: { ...s.position.bbox } } })),
+    zonesVisited: [...t.zonesVisited],
+    totalDistance: t.totalDistance,
+    state: t.state,
+    active: t.active
+  };
+}
+class TrackStore {
+  active = /* @__PURE__ */ new Map();
+  config;
+  logger;
+  store;
+  constructor(deps) {
+    this.logger = deps.logger;
+    this.store = deps.store;
+    this.config = { ...DEFAULT_CONFIG, ...deps.config };
+  }
+  /** One-time collection declaration. Call from addon onInitialize. */
+  static async declare(store) {
+    await store.declareCollection.mutate({
+      collection: TRACKS_COLLECTION,
+      columns: [...TRACKS_COLUMNS],
+      indexes: [...TRACKS_INDEXES]
+    });
+  }
+  /** Create or update the track record for a sighting in this frame. */
+  upsert(params) {
+    const existing = this.active.get(params.trackId);
+    if (existing) {
+      const last = existing.positions[existing.positions.length - 1];
+      const dist = last ? Math.sqrt((params.position.x - last.x) ** 2 + (params.position.y - last.y) ** 2) : 0;
+      existing.lastSeen = params.timestamp;
+      existing.totalDistance += dist;
+      existing.state = params.state;
+      if (existing.positions.length >= this.config.maxPositionHistory) {
+        const half = Math.floor(existing.positions.length / 2);
+        existing.positions = existing.positions.filter((_, i) => i >= half || i % 2 === 0);
+        existing.positions.push(params.position);
+      } else {
+        existing.positions.push(params.position);
+      }
+      for (const z of params.zones) {
+        if (!existing.zonesVisited.includes(z)) existing.zonesVisited.push(z);
+      }
+      return existing;
+    }
+    const fresh = {
+      trackId: params.trackId,
+      deviceId: params.deviceId,
+      className: params.className,
+      ...params.label !== void 0 ? { label: params.label } : {},
+      firstSeen: params.timestamp,
+      lastSeen: params.timestamp,
+      positions: [params.position],
+      snapshots: [],
+      zonesVisited: [...params.zones],
+      totalDistance: 0,
+      state: params.state,
+      active: true,
+      lastSnapshotAt: 0
+    };
+    this.active.set(params.trackId, fresh);
+    return fresh;
+  }
+  /** Attach a snapshot reference to an active track. */
+  addSnapshot(trackId, snapshot) {
+    const t = this.active.get(trackId);
+    if (!t) return;
+    t.snapshots.push(snapshot);
+    t.lastSnapshotAt = snapshot.timestamp;
+  }
+  lastSnapshotAt(trackId) {
+    return this.active.get(trackId)?.lastSnapshotAt ?? 0;
+  }
+  getActive(deviceId) {
+    const out = [];
+    for (const t of this.active.values()) {
+      if (t.deviceId === deviceId && t.active) out.push(cloneTrack(t));
+    }
+    return out;
+  }
+  getActiveByTrack(trackId) {
+    const t = this.active.get(trackId);
+    return t && t.active ? cloneTrack(t) : null;
+  }
+  /** Expire tracks whose `lastSeen` is older than TTL. Persists each
+   *  expired track to the declared collection and returns them. */
+  async expireStale(nowMs) {
+    const expired = [];
+    for (const [trackId, t] of this.active) {
+      if (nowMs - t.lastSeen < this.config.ttlMs) continue;
+      t.active = false;
+      const record = cloneTrack(t);
+      try {
+        await this.persistCompleted(record);
+      } catch (err) {
+        this.logger.warn("persist completed track failed", {
+          meta: { trackId, error: String(err) }
+        });
+      }
+      this.active.delete(trackId);
+      expired.push(record);
+    }
+    return expired;
+  }
+  /** Discard active tracks for a device without persisting (used on
+   *  operator clearTracks / device unregistration). */
+  clearDevice(deviceId) {
+    for (const [trackId, t] of this.active) {
+      if (t.deviceId === deviceId) this.active.delete(trackId);
+    }
+  }
+  clearAll() {
+    this.active.clear();
+  }
+  /** Historical query — hits the persisted collection. */
+  async queryHistorical(params) {
+    const filter = { where: { deviceId: params.deviceId } };
+    if (params.since !== void 0 || params.until !== void 0) {
+      filter.whereBetween = {
+        firstSeen: [params.since ?? 0, params.until ?? Date.now()]
+      };
+    }
+    const records = await this.store.query.query({
+      collection: TRACKS_COLLECTION,
+      filter: {
+        ...filter,
+        orderBy: { field: "firstSeen", direction: "desc" },
+        limit: params.limit ?? 50
+      }
+    });
+    return records.map((r) => this.rowToTrack(r.id, r.data));
+  }
+  async getPersistedByTrackId(trackId) {
+    const records = await this.store.query.query({
+      collection: TRACKS_COLLECTION,
+      filter: { where: { id: trackId }, limit: 1 }
+    });
+    if (records.length === 0) return null;
+    const row = records[0];
+    return this.rowToTrack(row.id, row.data);
+  }
+  async persistCompleted(t) {
+    await this.store.set.mutate({
+      collection: TRACKS_COLLECTION,
+      key: t.trackId,
+      value: {
+        deviceId: t.deviceId,
+        className: t.className,
+        ...t.label !== void 0 ? { label: t.label } : {},
+        firstSeen: t.firstSeen,
+        lastSeen: t.lastSeen,
+        positions: [...t.positions],
+        snapshots: [...t.snapshots],
+        zonesVisited: [...t.zonesVisited],
+        totalDistance: t.totalDistance,
+        state: t.state
+      }
+    });
+  }
+  rowToTrack(id, data) {
+    const positions = data["positions"] ?? [];
+    const snapshots = data["snapshots"] ?? [];
+    const zones = data["zonesVisited"] ?? [];
+    const label = data["label"];
+    return {
+      trackId: id,
+      deviceId: Number(data["deviceId"]),
+      className: String(data["className"]),
+      ...typeof label === "string" ? { label } : {},
+      firstSeen: Number(data["firstSeen"]),
+      lastSeen: Number(data["lastSeen"]),
+      positions,
+      snapshots,
+      zonesVisited: zones,
+      totalDistance: Number(data["totalDistance"] ?? 0),
+      state: data["state"] ?? "idle",
+      active: false
+    };
+  }
+}
+const MEDIA_COLLECTION = "pipeline-analytics:media";
+const MEDIA_COLUMNS = [
+  { name: "id", type: "TEXT", primaryKey: true, notNull: true },
+  { name: "deviceId", type: "INTEGER", notNull: true },
+  { name: "ownerKind", type: "TEXT", notNull: true },
+  { name: "ownerId", type: "TEXT", notNull: true },
+  { name: "kind", type: "TEXT", notNull: true },
+  { name: "timestamp", type: "INTEGER", notNull: true },
+  { name: "path", type: "TEXT", notNull: true },
+  { name: "sizeBytes", type: "INTEGER", notNull: true }
+];
+const MEDIA_INDEXES = [
+  { name: "idx_media_owner", columns: ["ownerKind", "ownerId"] },
+  { name: "idx_media_device_ts", columns: ["deviceId", "timestamp"] }
+];
+function buildKey(params) {
+  return `${params.ownerKind}:${params.ownerId}:${params.kind}:${params.timestamp}`;
+}
+function buildPath(params) {
+  return `pipeline-analytics/${params.deviceId}/${params.ownerKind}/${params.ownerId}/${params.kind}-${params.timestamp}.jpg`;
+}
+class MediaStore {
+  storage;
+  store;
+  logger;
+  constructor(deps) {
+    this.storage = deps.storage;
+    this.store = deps.store;
+    this.logger = deps.logger;
+  }
+  static async declare(store) {
+    await store.declareCollection.mutate({
+      collection: MEDIA_COLLECTION,
+      columns: [...MEDIA_COLUMNS],
+      indexes: [...MEDIA_INDEXES]
+    });
+  }
+  /** Persist a media blob and register its metadata row. Returns the
+   *  collection key (MediaFile.key) that callers store as reference. */
+  async put(params) {
+    const key = buildKey(params);
+    const path = buildPath(params);
+    try {
+      await this.storage.write({ location: "data", relativePath: path, data: params.data });
+      await this.store.insert.mutate({
+        collection: MEDIA_COLLECTION,
+        record: {
+          id: key,
+          data: {
+            deviceId: params.deviceId,
+            ownerKind: params.ownerKind,
+            ownerId: params.ownerId,
+            kind: params.kind,
+            timestamp: params.timestamp,
+            path,
+            sizeBytes: params.data.length
+          }
+        }
+      });
+      return key;
+    } catch (err) {
+      this.logger.warn("media put failed", { meta: { key, error: String(err) } });
+      throw err;
+    }
+  }
+  async listByOwner(ownerKind, ownerId) {
+    const rows = await this.store.query.query({
+      collection: MEDIA_COLLECTION,
+      filter: { where: { ownerKind, ownerId }, orderBy: { field: "timestamp", direction: "asc" } }
+    });
+    const files = [];
+    for (const row of rows) {
+      const data = row.data;
+      const path = String(data["path"]);
+      const timestamp = Number(data["timestamp"]);
+      const sizeBytes = Number(data["sizeBytes"]);
+      const kind = String(data["kind"]);
+      try {
+        const buf = await this.storage.read({ location: "data", relativePath: path });
+        files.push({
+          key: row.id,
+          kind,
+          base64: buf.toString("base64"),
+          sizeBytes,
+          timestamp
+        });
+      } catch (err) {
+        this.logger.debug("media read failed — row kept but blob missing", {
+          meta: { key: row.id, path, error: String(err) }
+        });
+      }
+    }
+    return files;
+  }
+  /** Retention sweep: delete any media row + blob older than cutoff.
+   *  Returns number of entries removed. */
+  async evictBefore(cutoffMs) {
+    const rows = await this.store.query.query({
+      collection: MEDIA_COLLECTION,
+      filter: { whereBetween: { timestamp: [0, cutoffMs] }, limit: 500 }
+    });
+    let removed = 0;
+    for (const row of rows) {
+      const path = String(row.data["path"] ?? "");
+      try {
+        if (path) await this.storage.delete({ location: "data", relativePath: path });
+      } catch {
+      }
+      try {
+        await this.store.delete.mutate({ collection: MEDIA_COLLECTION, key: row.id });
+        removed++;
+      } catch (err) {
+        this.logger.debug("media evict delete failed", {
+          meta: { key: row.id, error: String(err) }
+        });
+      }
+    }
+    return removed;
+  }
+}
+const MOTION_EVENTS_COLLECTION = "pipeline-analytics:motion-events";
+const OBJECT_EVENTS_COLLECTION = "pipeline-analytics:object-events";
+const AUDIO_EVENTS_COLLECTION = "pipeline-analytics:audio-events";
+const COMMON_BASE_COLUMNS = [
+  { name: "id", type: "TEXT", primaryKey: true, notNull: true },
+  { name: "deviceId", type: "INTEGER", notNull: true },
+  { name: "timestamp", type: "INTEGER", notNull: true }
+];
+const MOTION_COLUMNS = [
+  ...COMMON_BASE_COLUMNS,
+  { name: "regionCount", type: "INTEGER", notNull: true },
+  { name: "regions", type: "JSON" },
+  { name: "frameWidth", type: "INTEGER" },
+  { name: "frameHeight", type: "INTEGER" }
+];
+const OBJECT_COLUMNS = [
+  ...COMMON_BASE_COLUMNS,
+  { name: "trackId", type: "TEXT", notNull: true },
+  { name: "className", type: "TEXT", notNull: true },
+  { name: "label", type: "TEXT" },
+  { name: "confidence", type: "REAL", notNull: true },
+  { name: "bbox", type: "JSON" },
+  { name: "zones", type: "JSON" },
+  { name: "state", type: "TEXT" },
+  { name: "mediaKey", type: "TEXT" }
+];
+const AUDIO_COLUMNS = [
+  ...COMMON_BASE_COLUMNS,
+  { name: "rms", type: "REAL", notNull: true },
+  { name: "dbfs", type: "REAL", notNull: true },
+  { name: "classification", type: "JSON" }
+];
+const COMMON_INDEXES = (prefix) => [
+  { name: `idx_${prefix}_device_ts`, columns: ["deviceId", "timestamp"] }
+];
+class EventStore {
+  store;
+  logger;
+  constructor(deps) {
+    this.store = deps.store;
+    this.logger = deps.logger;
+  }
+  static async declare(store) {
+    await store.declareCollection.mutate({
+      collection: MOTION_EVENTS_COLLECTION,
+      columns: [...MOTION_COLUMNS],
+      indexes: COMMON_INDEXES("motion")
+    });
+    await store.declareCollection.mutate({
+      collection: OBJECT_EVENTS_COLLECTION,
+      columns: [...OBJECT_COLUMNS],
+      indexes: [
+        ...COMMON_INDEXES("object"),
+        { name: "idx_object_track", columns: ["trackId"] }
+      ]
+    });
+    await store.declareCollection.mutate({
+      collection: AUDIO_EVENTS_COLLECTION,
+      columns: [...AUDIO_COLUMNS],
+      indexes: COMMON_INDEXES("audio")
+    });
+  }
+  // ── Writes ────────────────────────────────────────────────────────
+  async insertMotion(ev) {
+    try {
+      const { id, ...rest } = ev;
+      await this.store.insert.mutate({
+        collection: MOTION_EVENTS_COLLECTION,
+        record: { id, data: rest }
+      });
+    } catch (err) {
+      this.logger.warn("insertMotion failed", { meta: { eventId: ev.id, error: String(err) } });
+    }
+  }
+  async insertObject(ev) {
+    try {
+      const { id, ...rest } = ev;
+      await this.store.insert.mutate({
+        collection: OBJECT_EVENTS_COLLECTION,
+        record: { id, data: rest }
+      });
+    } catch (err) {
+      this.logger.warn("insertObject failed", { meta: { eventId: ev.id, error: String(err) } });
+    }
+  }
+  async insertAudio(ev) {
+    try {
+      const { id, ...rest } = ev;
+      await this.store.insert.mutate({
+        collection: AUDIO_EVENTS_COLLECTION,
+        record: { id, data: rest }
+      });
+    } catch (err) {
+      this.logger.warn("insertAudio failed", { meta: { eventId: ev.id, error: String(err) } });
+    }
+  }
+  // ── Reads ────────────────────────────────────────────────────────
+  buildFilter(q) {
+    const filter = {
+      where: { deviceId: q.deviceId },
+      orderBy: { field: "timestamp", direction: "desc" }
+    };
+    if (q.since !== void 0 || q.until !== void 0) {
+      filter.whereBetween = { timestamp: [q.since ?? 0, q.until ?? Date.now()] };
+    }
+    if (q.limit !== void 0) filter.limit = q.limit;
+    return filter;
+  }
+  async queryMotion(q) {
+    const rows = await this.store.query.query({
+      collection: MOTION_EVENTS_COLLECTION,
+      filter: this.buildFilter(q)
+    });
+    return rows.map((r) => {
+      const ev = { id: r.id, kind: "motion", ...stripNulls(r.data) };
+      return ev;
+    });
+  }
+  async queryObject(q) {
+    const filter = this.buildFilter(q);
+    if (q.classFilter !== void 0) {
+      const where = filter.where;
+      where["className"] = q.classFilter;
+    }
+    const rows = await this.store.query.query({
+      collection: OBJECT_EVENTS_COLLECTION,
+      filter
+    });
+    return rows.map((r) => {
+      const ev = { id: r.id, kind: "object", ...stripNulls(r.data) };
+      return ev;
+    });
+  }
+  async queryAudio(q) {
+    const rows = await this.store.query.query({
+      collection: AUDIO_EVENTS_COLLECTION,
+      filter: this.buildFilter(q)
+    });
+    return rows.map((r) => {
+      const ev = { id: r.id, kind: "audio", ...stripNulls(r.data) };
+      return ev;
+    });
+  }
+  // ── Retention ────────────────────────────────────────────────────
+  // (helper below)
+  async evictBefore(params) {
+    const deletedCounts = { motion: 0, object: 0, audio: 0 };
+    const batch = async (collection, cutoffMs) => {
+      const rows = await this.store.query.query({
+        collection,
+        filter: { whereBetween: { timestamp: [0, cutoffMs] }, limit: 500 }
+      });
+      let count = 0;
+      for (const row of rows) {
+        try {
+          await this.store.delete.mutate({ collection, key: row.id });
+          count++;
+        } catch {
+        }
+      }
+      return count;
+    };
+    deletedCounts.motion = await batch(MOTION_EVENTS_COLLECTION, params.motionCutoffMs);
+    deletedCounts.object = await batch(OBJECT_EVENTS_COLLECTION, params.objectCutoffMs);
+    deletedCounts.audio = await batch(AUDIO_EVENTS_COLLECTION, params.audioCutoffMs);
+    return deletedCounts;
+  }
+}
+function stripNulls(data) {
+  const out = {};
+  for (const [k, v] of Object.entries(data)) {
+    if (v !== null) out[k] = v;
+  }
+  return out;
+}
+class SliceThrottler {
+  opts;
+  lastWrittenAt = /* @__PURE__ */ new Map();
+  lastWritten = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Record a fresh snapshot for the given device. Triggers an
+   * immediate write when the throttle window has elapsed AND the
+   * content changed; otherwise queues a trailing flush.
+   */
+  push(deviceId, snapshot) {
+    const last = this.lastWritten.get(deviceId);
+    if (this.opts.equalsIgnoringTs(last, snapshot)) {
+      const queued2 = this.pending.get(deviceId);
+      if (queued2?.scheduledTimer) clearTimeout(queued2.scheduledTimer);
+      this.pending.delete(deviceId);
+      return;
+    }
+    const now = Date.now();
+    const lastTs = this.lastWrittenAt.get(deviceId) ?? 0;
+    const elapsed = now - lastTs;
+    if (elapsed >= this.opts.intervalMs) {
+      void this.flushNow(deviceId, snapshot);
+      return;
+    }
+    const queued = this.pending.get(deviceId);
+    const remainingMs = this.opts.intervalMs - elapsed;
+    if (queued) {
+      queued.snapshot = snapshot;
+    } else {
+      const slot = { snapshot, scheduledTimer: null };
+      slot.scheduledTimer = setTimeout(() => {
+        slot.scheduledTimer = null;
+        const current = this.pending.get(deviceId);
+        if (!current) return;
+        this.pending.delete(deviceId);
+        void this.flushNow(deviceId, current.snapshot);
+      }, remainingMs);
+      this.pending.set(deviceId, slot);
+    }
+  }
+  forgetDevice(deviceId) {
+    const queued = this.pending.get(deviceId);
+    if (queued?.scheduledTimer) clearTimeout(queued.scheduledTimer);
+    this.pending.delete(deviceId);
+    this.lastWritten.delete(deviceId);
+    this.lastWrittenAt.delete(deviceId);
+  }
+  /** Drop all pending timers — call from `onShutdown`. */
+  destroy() {
+    for (const queued of this.pending.values()) {
+      if (queued.scheduledTimer) clearTimeout(queued.scheduledTimer);
+    }
+    this.pending.clear();
+    this.lastWritten.clear();
+    this.lastWrittenAt.clear();
+  }
+  async flushNow(deviceId, snapshot) {
+    this.lastWrittenAt.set(deviceId, Date.now());
+    this.lastWritten.set(deviceId, snapshot);
+    await this.opts.write(deviceId, snapshot);
+  }
+}
+function snapshotEqualsIgnoringTs(prev, next) {
+  if (!prev) return false;
+  const { ts: _prevTs, ...prevRest } = prev;
+  const { ts: _nextTs, ...nextRest } = next;
+  return JSON.stringify(prevRest) === JSON.stringify(nextRest);
+}
+const HISTORY_WINDOW_MS = 60 * 60 * 1e3;
+const ZONE_ANALYTICS_CAP_NAME = "zone-analytics";
+const RESOLUTION_MS = {
+  minute: 6e4,
+  "5min": 5 * 6e4,
+  hour: 60 * 6e4
+};
+const SLICE_WRITE_INTERVAL_MS$1 = 1e3;
+class ZoneAnalyticsProvider {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.sliceThrottle = new SliceThrottler({
+      intervalMs: SLICE_WRITE_INTERVAL_MS$1,
+      equalsIgnoringTs: snapshotEqualsIgnoringTs,
+      write: async (deviceId, snapshot) => {
+        try {
+          const dev = await this.ctx.fetchDevice(deviceId);
+          await dev.deviceState.setCapSlice({
+            capName: ZONE_ANALYTICS_CAP_NAME,
+            slice: snapshot
+          });
+        } catch (err) {
+          this.ctx.logger.debug("zone-analytics slice mirror failed", {
+            tags: { deviceId },
+            meta: { error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+      }
+    });
+  }
+  snapshots = /* @__PURE__ */ new Map();
+  /** Per-device rolling ring of frame samples. Capped by HISTORY_WINDOW_MS
+   *  on append; older entries are evicted lazily on each record. */
+  history = /* @__PURE__ */ new Map();
+  /**
+   * Coalesces slice writes to the kernel-side runtime-state mirror.
+   * Skips no-op snapshots (idle camera, zone counts unchanged) and
+   * caps the rate at 1 Hz with a trailing flush so a transient
+   * change isn't held back beyond `SLICE_WRITE_INTERVAL_MS`.
+   */
+  sliceThrottle;
+  /** Stop pending throttle timers — called from addon shutdown. */
+  destroy() {
+    this.sliceThrottle.destroy();
+  }
+  // ── Cap surface ───────────────────────────────────────────────────
+  async getCurrentSnapshot({
+    deviceId
+  }) {
+    return this.snapshots.get(deviceId) ?? null;
+  }
+  async getZoneHistory(input) {
+    return this.bucketize(input.deviceId, input.from, input.to, input.resolution, (snap) => {
+      const zone = snap.zones.find((z) => z.zoneId === input.zoneId);
+      if (!zone) return 0;
+      if (input.className === void 0) return zone.totalObjects;
+      return zone.byClass[input.className] ?? 0;
+    });
+  }
+  async getCameraHistory(input) {
+    return this.bucketize(input.deviceId, input.from, input.to, input.resolution, (snap) => {
+      if (input.className === void 0) return snap.frame.totalObjects;
+      return snap.frame.byClass[input.className] ?? 0;
+    });
+  }
+  async getUnzonedHistory(input) {
+    return this.bucketize(input.deviceId, input.from, input.to, input.resolution, (snap) => {
+      if (input.className === void 0) return snap.unzoned.totalObjects;
+      return snap.unzoned.byClass[input.className] ?? 0;
+    });
+  }
+  // ── Recording surface (called by the analytics frame handler) ─────
+  /**
+   * Compute and record a snapshot from a tracked-detection list.
+   * Called once per inference result by the analytics addon's
+   * `handleInferenceResult`. Mirrors to the `zone-occupancy`
+   * device-state slice for live UI subscribers.
+   */
+  async recordFrame(input) {
+    const snapshot = computeSnapshot(input);
+    this.snapshots.set(input.deviceId, snapshot);
+    this.appendHistory(input.deviceId, snapshot);
+    this.sliceThrottle.push(input.deviceId, snapshot);
+  }
+  /** Drop a device's snapshot + history. Called on device removal. */
+  forgetDevice(deviceId) {
+    this.snapshots.delete(deviceId);
+    this.history.delete(deviceId);
+    this.sliceThrottle.forgetDevice(deviceId);
+  }
+  // ── Internals ─────────────────────────────────────────────────────
+  appendHistory(deviceId, snapshot) {
+    const ring = this.history.get(deviceId) ?? [];
+    const cutoff = snapshot.ts - HISTORY_WINDOW_MS;
+    let trimIdx = 0;
+    while (trimIdx < ring.length && ring[trimIdx].ts < cutoff) trimIdx++;
+    const trimmed = trimIdx > 0 ? ring.slice(trimIdx) : ring;
+    trimmed.push({ ts: snapshot.ts, snapshot });
+    this.history.set(deviceId, trimmed);
+  }
+  bucketize(deviceId, from, to, resolution, extract) {
+    const ring = this.history.get(deviceId);
+    if (!ring || ring.length === 0) return [];
+    const bucketMs = RESOLUTION_MS[resolution];
+    const buckets = /* @__PURE__ */ new Map();
+    for (const sample of ring) {
+      if (sample.ts < from || sample.ts > to) continue;
+      const bucketStart = Math.floor(sample.ts / bucketMs) * bucketMs;
+      const bucket = buckets.get(bucketStart);
+      const value = extract(sample.snapshot);
+      if (bucket) {
+        bucket.sum += value;
+        bucket.count += 1;
+      } else {
+        buckets.set(bucketStart, { sum: value, count: 1 });
+      }
+    }
+    const result = [];
+    for (const [bucketStart, agg] of [...buckets.entries()].sort(([a], [b]) => a - b)) {
+      result.push({
+        ts: bucketStart + bucketMs / 2,
+        count: Math.round(agg.sum / agg.count)
+      });
+    }
+    return result;
+  }
+}
+function computeSnapshot(input) {
+  const frameByClass = {};
+  let frameTotal = 0;
+  for (const td of input.tracked) {
+    frameTotal += 1;
+    frameByClass[td.className] = (frameByClass[td.className] ?? 0) + 1;
+  }
+  const zoneAccumulators = /* @__PURE__ */ new Map();
+  for (const z of input.zones) {
+    zoneAccumulators.set(z.id, {
+      name: z.name,
+      total: 0,
+      byClass: {},
+      trackIds: []
+    });
+  }
+  let unzonedTotal = 0;
+  const unzonedByClass = {};
+  for (const td of input.tracked) {
+    if (td.zones.length === 0) {
+      unzonedTotal += 1;
+      unzonedByClass[td.className] = (unzonedByClass[td.className] ?? 0) + 1;
+      continue;
+    }
+    for (const zoneId of td.zones) {
+      const acc = zoneAccumulators.get(zoneId);
+      if (!acc) continue;
+      acc.total += 1;
+      acc.byClass[td.className] = (acc.byClass[td.className] ?? 0) + 1;
+      acc.trackIds.push(td.trackId);
+    }
+  }
+  return {
+    ts: input.timestamp,
+    frameWidth: input.frameWidth,
+    frameHeight: input.frameHeight,
+    zones: [...zoneAccumulators.entries()].map(([zoneId, acc]) => ({
+      zoneId,
+      zoneName: acc.name,
+      totalObjects: acc.total,
+      byClass: acc.byClass,
+      trackIds: acc.trackIds
+    })),
+    frame: {
+      totalObjects: frameTotal,
+      byClass: frameByClass
+    },
+    unzoned: {
+      totalObjects: unzonedTotal,
+      byClass: unzonedByClass
+    }
+  };
+}
+const AUDIO_METRICS_CAP_NAME = "audio-metrics";
+const MAX_HISTORY_POINTS_KEPT = 3600;
+const MAX_HISTORY_POINTS_RETURNED = 1024;
+const DEFAULT_HISTORY_WINDOW_SEC = 300;
+const DEFAULT_HISTORY_SAMPLE_EVERY_MS = 1e3;
+const SLICE_WRITE_INTERVAL_MS = 1e3;
+const REPORT_SETTINGS_TTL_MS = 3e4;
+const DEFAULT_REPORT_SETTINGS = {
+  enabled: true,
+  thresholdDb: 2
+};
+function audioMetricsSnapshotEquals(prev, next, thresholdDb) {
+  if (!prev) return false;
+  if (thresholdDb <= 0) return snapshotEqualsIgnoringTs(prev, next);
+  const prevClass = prev.current?.className ?? null;
+  const nextClass = next.current?.className ?? null;
+  if (prevClass !== nextClass) return false;
+  if (prev.byClass.length !== next.byClass.length) return false;
+  for (let i = 0; i < prev.byClass.length; i++) {
+    const a = prev.byClass[i];
+    const b = next.byClass[i];
+    if (a.className !== b.className || a.hits !== b.hits) return false;
+  }
+  if (Math.abs(prev.level.dbfs - next.level.dbfs) >= thresholdDb) return false;
+  if (Math.abs(prev.peakDbfs - next.peakDbfs) >= thresholdDb) return false;
+  if (Math.abs(prev.avgDbfs - next.avgDbfs) >= thresholdDb) return false;
+  return true;
+}
+class AudioMetricsProvider {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.windowMs = (ctx.windowSec ?? 60) * 1e3;
+    this.scoreThreshold = ctx.scoreThreshold ?? 0.4;
+    this.sliceThrottle = new SliceThrottler({
+      intervalMs: SLICE_WRITE_INTERVAL_MS,
+      equalsIgnoringTs: (prev, next) => audioMetricsSnapshotEquals(prev, next, this.currentThresholdDb),
+      write: async (deviceId, snapshot) => {
+        try {
+          const dev = await this.ctx.fetchDevice(deviceId);
+          await dev.deviceState.setCapSlice({
+            capName: AUDIO_METRICS_CAP_NAME,
+            slice: snapshot
+          });
+        } catch (err) {
+          this.ctx.logger.debug("audio-metrics slice mirror failed", {
+            tags: { deviceId },
+            meta: { error: err instanceof Error ? err.message : String(err) }
+          });
+        }
+      }
+    });
+  }
+  snapshots = /* @__PURE__ */ new Map();
+  state = /* @__PURE__ */ new Map();
+  /**
+   * Per-device history ring buffer. Each push appends a compact
+   * `AudioMetricsHistoryPoint` derived from the just-computed
+   * snapshot; the oldest entry is dropped once
+   * `MAX_HISTORY_POINTS_KEPT` is reached. We use a plain array
+   * (not a circular buffer) for readability — the trim cost is
+   * O(1) on `.shift()` for arrays Node/V8 keeps short, and
+   * `getHistory` doesn't have a hot-loop requirement.
+   *
+   * The ring is populated at the same cadence as the
+   * `recordAudioFrame()` calls (1 push per call), but most builds
+   * receive ~10–20 audio chunks per second. That rate is faster
+   * than what `getHistory` reports (default 1Hz spacing); the
+   * downstream subsampling step in `getHistory` averages adjacent
+   * samples back to the requested spacing, so retention covers
+   * roughly `MAX_HISTORY_POINTS_KEPT × pushIntervalMs / 1000`s of
+   * wall-clock time. At 10Hz that's ~6 minutes; at 1Hz ~1 hour.
+   */
+  history = /* @__PURE__ */ new Map();
+  windowMs;
+  scoreThreshold;
+  /**
+   * Coalesces slice writes to the kernel-side runtime-state mirror.
+   * Equality check is audio-metrics-aware: dB jitter under the
+   * per-device threshold is suppressed; class changes always pass.
+   * Trailing-flushes at most once per SLICE_WRITE_INTERVAL_MS.
+   */
+  sliceThrottle;
+  /** Per-device settings cache. Refreshed lazily inside the audio
+   *  fast path (REPORT_SETTINGS_TTL_MS). */
+  reportSettings = /* @__PURE__ */ new Map();
+  /** In-flight settings-fetch dedupe per device. */
+  settingsFetches = /* @__PURE__ */ new Map();
+  /** Working snapshot of the equality threshold while the throttler
+   *  is running its diff. Set before push(), reset to default after.
+   *  Allows the closure passed to SliceThrottler to look up the
+   *  per-device threshold without a deeper API change. */
+  currentThresholdDb = DEFAULT_REPORT_SETTINGS.thresholdDb;
+  /**
+   * Resolve per-device report settings with TTL caching. Returns
+   * the cached value synchronously when fresh; on stale or first
+   * access, kicks off an async refresh and returns the previous
+   * value (falling back to defaults). Keeps the audio fast path
+   * non-blocking — the worst case is one slightly-stale tick per
+   * camera per TTL window.
+   */
+  getReportSettings(deviceId) {
+    const cached = this.reportSettings.get(deviceId);
+    const now = Date.now();
+    if (cached && now - cached.resolvedAt < REPORT_SETTINGS_TTL_MS) {
+      return cached.value;
+    }
+    if (this.ctx.resolveReportSettings && !this.settingsFetches.has(deviceId)) {
+      const fetch = this.ctx.resolveReportSettings(deviceId).then((value) => {
+        this.reportSettings.set(deviceId, { value, resolvedAt: Date.now() });
+      }).catch((err) => {
+        this.ctx.logger.debug("audio-metrics: report settings resolve failed", {
+          tags: { deviceId },
+          meta: { error: err instanceof Error ? err.message : String(err) }
+        });
+        this.reportSettings.set(deviceId, { value: DEFAULT_REPORT_SETTINGS, resolvedAt: Date.now() });
+      }).finally(() => {
+        this.settingsFetches.delete(deviceId);
+      });
+      this.settingsFetches.set(deviceId, fetch);
+    }
+    return cached?.value ?? DEFAULT_REPORT_SETTINGS;
+  }
+  /** Stop pending throttle timers — called from addon shutdown. */
+  destroy() {
+    this.sliceThrottle.destroy();
+  }
+  // ── Cap surface ───────────────────────────────────────────────────
+  async getCurrentSnapshot({
+    deviceId
+  }) {
+    return this.snapshots.get(deviceId) ?? null;
+  }
+  async getHistory({
+    deviceId,
+    windowSec,
+    sampleEveryMs
+  }) {
+    const ring = this.history.get(deviceId);
+    if (!ring || ring.length === 0) {
+      return { points: [], effectiveSampleEveryMs: sampleEveryMs ?? DEFAULT_HISTORY_SAMPLE_EVERY_MS, windowMsActual: 0 };
+    }
+    const effectiveWindowSec = windowSec ?? DEFAULT_HISTORY_WINDOW_SEC;
+    const requestedSampleEveryMs = sampleEveryMs ?? DEFAULT_HISTORY_SAMPLE_EVERY_MS;
+    const cutoffTs = Date.now() - effectiveWindowSec * 1e3;
+    const inWindow = [];
+    for (const p of ring) {
+      if (p.ts >= cutoffTs) inWindow.push(p);
+    }
+    if (inWindow.length === 0) {
+      return { points: [], effectiveSampleEveryMs: requestedSampleEveryMs, windowMsActual: 0 };
+    }
+    const naiveBucketCount = Math.max(1, Math.ceil(effectiveWindowSec * 1e3 / requestedSampleEveryMs));
+    const targetBucketCount = Math.min(naiveBucketCount, MAX_HISTORY_POINTS_RETURNED);
+    const downsampled = downsampleHistory(inWindow, targetBucketCount);
+    const first = downsampled[0];
+    const last = downsampled[downsampled.length - 1];
+    const windowMsActual = first && last ? last.ts - first.ts : 0;
+    const effectiveSampleEveryMs = downsampled.length >= 2 ? Math.max(1, Math.round(windowMsActual / Math.max(1, downsampled.length - 1))) : requestedSampleEveryMs;
+    return {
+      points: downsampled,
+      effectiveSampleEveryMs,
+      windowMsActual
+    };
+  }
+  // ── Recording (called by the analytics addon's audio handler) ────
+  /**
+   * Record one audio window into the rolling aggregator and emit a
+   * fresh snapshot. Called once per `pipeline.audio-inference-result`
+   * event by the analytics addon. `topClassification` may be omitted
+   * for silent windows — the level still updates.
+   */
+  async recordAudioFrame(input) {
+    let s = this.state.get(input.deviceId);
+    if (!s) {
+      s = { hits: [], levels: [], lastLevel: null };
+      this.state.set(input.deviceId, s);
+    }
+    const cutoff = input.timestamp - this.windowMs;
+    while (s.hits.length > 0 && s.hits[0].ts < cutoff) s.hits.shift();
+    while (s.levels.length > 0 && s.levels[0].ts < cutoff) s.levels.shift();
+    if (input.level) {
+      s.lastLevel = { ...input.level, ts: input.timestamp };
+      s.levels.push({ ts: input.timestamp, dbfs: input.level.dbfs });
+    }
+    if (input.topClassification && input.topClassification.score >= this.scoreThreshold) {
+      s.hits.push({
+        ts: input.timestamp,
+        className: input.topClassification.className,
+        score: input.topClassification.score
+      });
+    }
+    const snapshot = computeAudioSnapshot(input.timestamp, s, this.windowMs / 1e3, this.scoreThreshold);
+    this.snapshots.set(input.deviceId, snapshot);
+    const point = snapshotToHistoryPoint(snapshot);
+    let ring = this.history.get(input.deviceId);
+    if (!ring) {
+      ring = [];
+      this.history.set(input.deviceId, ring);
+    }
+    ring.push(point);
+    if (ring.length > MAX_HISTORY_POINTS_KEPT) {
+      ring.shift();
+    }
+    const settings = this.getReportSettings(input.deviceId);
+    if (!settings.enabled) return;
+    this.currentThresholdDb = settings.thresholdDb;
+    this.sliceThrottle.push(input.deviceId, snapshot);
+    this.currentThresholdDb = DEFAULT_REPORT_SETTINGS.thresholdDb;
+  }
+  /** Drop a device's audio state. Called on device removal. */
+  forgetDevice(deviceId) {
+    this.snapshots.delete(deviceId);
+    this.state.delete(deviceId);
+    this.history.delete(deviceId);
+    this.sliceThrottle.forgetDevice(deviceId);
+    this.reportSettings.delete(deviceId);
+  }
+}
+function snapshotToHistoryPoint(snapshot) {
+  return {
+    ts: snapshot.ts,
+    dbfs: Number.isFinite(snapshot.level.dbfs) ? snapshot.level.dbfs : null,
+    peakDbfs: snapshot.peakDbfs,
+    avgDbfs: snapshot.avgDbfs,
+    topClass: snapshot.current?.className ?? null,
+    topScore: snapshot.current?.score ?? null
+  };
+}
+function downsampleHistory(source, targetCount) {
+  if (source.length === 0) return [];
+  if (targetCount >= source.length) return [...source];
+  const out = [];
+  const bucketSize = Math.max(1, Math.floor(source.length / targetCount));
+  for (let bucketStart = 0; bucketStart < source.length; bucketStart += bucketSize) {
+    const bucketEnd = Math.min(source.length, bucketStart + bucketSize);
+    let dbfsSum = 0;
+    let dbfsCount = 0;
+    let peakDbfs = -Infinity;
+    let avgDbfsSum = 0;
+    let peakBucketScore = -Infinity;
+    let peakBucketClass = null;
+    const classCounts = /* @__PURE__ */ new Map();
+    let lastTs = source[bucketStart].ts;
+    for (let i = bucketStart; i < bucketEnd; i++) {
+      const p = source[i];
+      if (p.dbfs !== null) {
+        dbfsSum += p.dbfs;
+        dbfsCount += 1;
+      }
+      if (p.peakDbfs > peakDbfs) peakDbfs = p.peakDbfs;
+      avgDbfsSum += p.avgDbfs;
+      if (p.topClass !== null) {
+        classCounts.set(p.topClass, (classCounts.get(p.topClass) ?? 0) + 1);
+        if (p.topScore !== null && p.topScore > peakBucketScore) {
+          peakBucketScore = p.topScore;
+          peakBucketClass = p.topClass;
+        }
+      }
+      lastTs = p.ts;
+    }
+    let dominantClass = null;
+    let dominantCount = 0;
+    for (const [cls, count] of classCounts) {
+      if (count > dominantCount) {
+        dominantClass = cls;
+        dominantCount = count;
+      }
+    }
+    const topClass = dominantClass ?? peakBucketClass;
+    const topScore = topClass !== null && peakBucketScore !== -Infinity ? peakBucketScore : null;
+    out.push({
+      ts: lastTs,
+      dbfs: dbfsCount > 0 ? dbfsSum / dbfsCount : null,
+      peakDbfs: Number.isFinite(peakDbfs) ? peakDbfs : 0,
+      avgDbfs: avgDbfsSum / Math.max(1, bucketEnd - bucketStart),
+      topClass,
+      topScore
+    });
+  }
+  return out;
+}
+function computeAudioSnapshot(ts, s, windowSec, scoreThreshold) {
+  const byClassMap = /* @__PURE__ */ new Map();
+  for (const h of s.hits) {
+    const acc = byClassMap.get(h.className) ?? { hits: 0, sum: 0, peak: 0 };
+    acc.hits += 1;
+    acc.sum += h.score;
+    if (h.score > acc.peak) acc.peak = h.score;
+    byClassMap.set(h.className, acc);
+  }
+  const byClass = [...byClassMap.entries()].map(([className, agg]) => ({
+    className,
+    hits: agg.hits,
+    avgScore: agg.hits > 0 ? agg.sum / agg.hits : 0,
+    peakScore: agg.peak
+  })).sort((a, b) => b.hits - a.hits || b.peakScore - a.peakScore);
+  let peakDbfs = -Infinity;
+  let sumDbfs = 0;
+  for (const l of s.levels) {
+    if (l.dbfs > peakDbfs) peakDbfs = l.dbfs;
+    sumDbfs += l.dbfs;
+  }
+  const avgDbfs = s.levels.length > 0 ? sumDbfs / s.levels.length : 0;
+  const lastHit = s.hits.length > 0 ? s.hits[s.hits.length - 1] : null;
+  const current = lastHit ? { className: lastHit.className, score: lastHit.score, timestamp: lastHit.ts } : null;
+  return {
+    ts,
+    windowSec,
+    level: s.lastLevel ? { rms: s.lastLevel.rms, dbfs: s.lastLevel.dbfs } : { rms: 0, dbfs: -Infinity },
+    peakDbfs: Number.isFinite(peakDbfs) ? peakDbfs : 0,
+    avgDbfs,
+    current,
+    byClass
+  };
+}
+const TTL_SWEEP_INTERVAL_MS = 5e3;
+const RETENTION_SWEEP_INTERVAL_MS = 5 * 6e4;
+const AUDIO_EVENT_HEARTBEAT_MS = 5e3;
+const MOTION_EVENT_HEARTBEAT_MS = 5e3;
+class PipelineAnalyticsAddon extends types.BaseAddon {
+  processors = /* @__PURE__ */ new Map();
+  trackStore = null;
+  mediaStore = null;
+  eventStore = null;
+  bindingCache = null;
+  zoneAnalytics = null;
+  audioMetrics = null;
+  /**
+   * Per-device {@link DeviceProxy} used to read live zones +
+   * detection rules off the kernel runtime-state mirror. Replaces
+   * the manual DeviceStateChanged subscription + per-cap-name caches
+   * — `proxy.state.zones.value` and `proxy.state.zoneRules.value`
+   * stay warm as long as the slice handles are subscribed.
+   */
+  proxies = /* @__PURE__ */ new Map();
+  /** Slice subscription pins for cache warmth + pushed updates into
+   *  the per-device FrameProcessor. */
+  proxyUnsubs = /* @__PURE__ */ new Map();
+  unsubInference = null;
+  unsubAudio = null;
+  unsubMotion = null;
+  unsubMotionOnboard = null;
+  unsubBindings = null;
+  unsubDeviceUnreg = null;
+  ttlSweepTimer = null;
+  retentionSweepTimer = null;
+  // Current tracked-state snapshot per active track. Used so
+  // TrackStarted/TrackEnded fire exactly once per lifecycle transition.
+  lastActiveTrackIds = /* @__PURE__ */ new Map();
+  // Throttle state for audio event inserts. Without this every AAC
+  // chunk (~30 Hz) becomes a row, blowing the analytics DB to 1M+
+  // rows in a single day on one camera.
+  lastAudioInsertByDevice = /* @__PURE__ */ new Map();
+  // Same throttle for motion: one row per heartbeat while detected stays
+  // true; immediate insert on off→on transition. Off→off skipped.
+  lastMotionInsertByDevice = /* @__PURE__ */ new Map();
+  shuttingDown = false;
+  constructor() {
+    super({});
+  }
+  async onInitialize() {
+    const api = this.ctx.api;
+    if (!api) throw new Error("pipeline-analytics requires ctx.api (device-manager + settings-store)");
+    await TrackStore.declare(api.settingsStore);
+    await MediaStore.declare(api.settingsStore);
+    await EventStore.declare(api.settingsStore);
+    const logger = this.ctx.logger;
+    const storage = this.ctx.kernel.storage;
+    if (!storage) throw new Error("pipeline-analytics requires ctx.kernel.storage");
+    this.trackStore = new TrackStore({ store: api.settingsStore, logger: logger.child("TrackStore") });
+    this.mediaStore = new MediaStore({
+      storage,
+      store: api.settingsStore,
+      logger: logger.child("MediaStore")
+    });
+    this.eventStore = new EventStore({ store: api.settingsStore, logger: logger.child("EventStore") });
+    this.bindingCache = new BindingCache({ api, logger: logger.child("BindingCache") });
+    this.zoneAnalytics = new ZoneAnalyticsProvider({
+      logger: logger.child("ZoneAnalytics"),
+      fetchDevice: (deviceId) => this.ctx.fetchDevice(deviceId)
+    });
+    this.audioMetrics = new AudioMetricsProvider({
+      logger: logger.child("AudioMetrics"),
+      fetchDevice: (deviceId) => this.ctx.fetchDevice(deviceId),
+      // Per-camera report knobs — operator tunes via the
+      // device-settings panel ("Audio metrics reporting" section).
+      // Cascade is global default → device override; raw read goes
+      // straight through ctx.settings, no kernel round-trip.
+      resolveReportSettings: async (deviceId) => {
+        const raw = await this.ctx?.settings?.readDeviceStore(deviceId) ?? {};
+        const enabled = typeof raw["audioMetricsReportEnabled"] === "boolean" ? raw["audioMetricsReportEnabled"] : true;
+        const thresholdRaw = raw["audioMetricsReportThresholdDb"];
+        const thresholdDb = typeof thresholdRaw === "number" && Number.isFinite(thresholdRaw) ? Math.max(0, Math.min(10, thresholdRaw)) : 2;
+        return { enabled, thresholdDb };
+      }
+    });
+    this.unsubInference = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.PipelineInferenceResult },
+      (ev) => {
+        void this.handleInferenceResult(ev.data);
+      }
+    );
+    this.unsubAudio = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.PipelineAudioInferenceResult },
+      (ev) => {
+        void this.handleAudioResult(ev.data);
+      }
+    );
+    this.unsubMotion = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.MotionAnalysis },
+      (ev) => {
+        const src = ev.source;
+        if (src?.type !== "device" || typeof src.deviceId !== "number") return;
+        void this.handleMotionAnalysis(src.deviceId, ev.data, ev.timestamp instanceof Date ? ev.timestamp.getTime() : Date.now());
+      }
+    );
+    this.unsubMotionOnboard = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.MotionOnMotionChanged },
+      (ev) => {
+        const data = ev.data;
+        if (data.source === "analyzer") return;
+        const timestamp = typeof data.timestamp === "number" ? data.timestamp : ev.timestamp instanceof Date ? ev.timestamp.getTime() : Date.now();
+        void this.handleOnboardMotion(data.deviceId, data, timestamp);
+      }
+    );
+    this.unsubBindings = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.DeviceBindingsChanged },
+      (ev) => {
+        const data = ev.data;
+        this.bindingCache?.onBindingsChanged(data);
+        if (data.capName === "pipeline-analytics" && data.reason === "wrapper-deactivated") {
+          this.trackStore?.clearDevice(data.deviceId);
+          this.processors.delete(data.deviceId);
+          this.lastActiveTrackIds.delete(data.deviceId);
+        }
+      }
+    );
+    this.unsubDeviceUnreg = this.ctx.eventBus.subscribe(
+      { category: types.EventCategory.DeviceUnregistered },
+      (ev) => {
+        const { deviceId } = ev.data;
+        this.trackStore?.clearDevice(deviceId);
+        this.processors.delete(deviceId);
+        this.lastActiveTrackIds.delete(deviceId);
+        this.bindingCache?.invalidate(deviceId);
+        this.zoneAnalytics?.forgetDevice(deviceId);
+        this.audioMetrics?.forgetDevice(deviceId);
+        this.releaseProxy(deviceId);
+      }
+    );
+    this.ttlSweepTimer = setInterval(() => {
+      void this.sweepExpiredTracks();
+    }, TTL_SWEEP_INTERVAL_MS);
+    this.retentionSweepTimer = setInterval(() => {
+      void this.sweepRetention();
+    }, RETENTION_SWEEP_INTERVAL_MS);
+    this.ctx.logger.info("pipeline-analytics subscribers installed");
+    const widgetsProvider = {
+      listWidgets: async () => [
+        {
+          stableId: "audio-history-chart",
+          label: "Audio Level History",
+          description: "Sparkline of audio dBFS over a configurable window with class hits.",
+          icon: "activity",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "lg",
+          allowedSizes: ["md", "lg", "xl"],
+          defaultColumns: 12,
+          defaultRows: 2
+        },
+        {
+          stableId: "audio-metrics-panel",
+          label: "Audio Metrics",
+          description: "Live dBFS + dominant class + per-class summary card.",
+          icon: "mic",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "md",
+          allowedSizes: ["sm", "md", "lg"],
+          defaultColumns: 6,
+          defaultRows: 2
+        },
+        {
+          stableId: "occupancy-history-chart",
+          label: "Occupancy History",
+          description: "Frame-wide tracked-object count over time.",
+          icon: "users",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "lg",
+          allowedSizes: ["md", "lg", "xl"],
+          defaultColumns: 12,
+          defaultRows: 2
+        },
+        {
+          stableId: "motion-history-chart",
+          label: "Motion History",
+          description: "Histogram of motion events over a configurable window.",
+          icon: "activity",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "lg",
+          allowedSizes: ["md", "lg", "xl"],
+          defaultColumns: 12,
+          defaultRows: 2
+        },
+        {
+          stableId: "detection-history-chart",
+          label: "Detection History",
+          description: "Stacked-by-class histogram of object detections.",
+          icon: "eye",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "lg",
+          allowedSizes: ["md", "lg", "xl"],
+          defaultColumns: 12,
+          defaultRows: 2
+        },
+        {
+          stableId: "live-occupancy-panel",
+          label: "Live Occupancy",
+          description: "Per-zone breakdown + frame-wide aggregate (no polling).",
+          icon: "layers",
+          remoteName: "addon_pipeline_analytics_widgets",
+          bundle: "remoteEntry.js",
+          hosts: ["device-tab", "dashboard"],
+          requires: { deviceContext: true, integrationContext: false },
+          defaultSize: "md",
+          allowedSizes: ["sm", "md", "lg"],
+          defaultColumns: 6,
+          defaultRows: 2
+        }
+      ]
+    };
+    return [
+      {
+        capability: types.pipelineAnalyticsCapability,
+        provider: this,
+        kind: "wrapper",
+        defaultActive: true
+      },
+      {
+        capability: types.zoneAnalyticsCapability,
+        provider: this.zoneAnalytics
+      },
+      {
+        capability: types.audioMetricsCapability,
+        provider: this.audioMetrics
+      },
+      {
+        capability: types.addonWidgetsSourceCapability,
+        provider: widgetsProvider
+      }
+    ];
+  }
+  async onShutdown() {
+    this.shuttingDown = true;
+    this.unsubInference?.();
+    this.unsubInference = null;
+    this.unsubAudio?.();
+    this.unsubAudio = null;
+    this.unsubMotion?.();
+    this.unsubMotion = null;
+    this.unsubMotionOnboard?.();
+    this.unsubMotionOnboard = null;
+    this.unsubBindings?.();
+    this.unsubBindings = null;
+    this.unsubDeviceUnreg?.();
+    this.unsubDeviceUnreg = null;
+    for (const id of this.proxies.keys()) this.releaseProxy(id);
+    if (this.ttlSweepTimer) {
+      clearInterval(this.ttlSweepTimer);
+      this.ttlSweepTimer = null;
+    }
+    if (this.retentionSweepTimer) {
+      clearInterval(this.retentionSweepTimer);
+      this.retentionSweepTimer = null;
+    }
+    this.zoneAnalytics?.destroy();
+    this.audioMetrics?.destroy();
+    this.processors.clear();
+    this.lastActiveTrackIds.clear();
+    this.trackStore?.clearAll();
+    this.bindingCache?.clearAll();
+  }
+  // ── Subscriber handlers ──────────────────────────────────────────────
+  async handleInferenceResult(data) {
+    if (this.shuttingDown) return;
+    const { deviceId, frame } = data;
+    const active = await this.bindingCache.isActive(deviceId);
+    if (!active) return;
+    const processor = this.getOrCreateProcessor(deviceId);
+    const proxy = await this.ensureProxy(deviceId);
+    const liveZones = proxy?.state.zones.value?.zones ?? [];
+    const liveRules = proxy?.state.zoneRules.value?.detection ?? [];
+    processor.setZones(liveZones);
+    processor.setDetectionRules(liveRules);
+    const result = processor.process({ timestamp: frame.timestamp, frame });
+    void this.zoneAnalytics?.recordFrame({
+      deviceId,
+      timestamp: result.timestamp,
+      frameWidth: result.frameWidth,
+      frameHeight: result.frameHeight,
+      tracked: result.tracked,
+      zones: liveZones
+    });
+    const currentTrackIds = /* @__PURE__ */ new Set();
+    for (const t of result.tracked) {
+      currentTrackIds.add(t.trackId);
+      const center = {
+        x: t.bbox.x + t.bbox.w / 2,
+        y: t.bbox.y + t.bbox.h / 2
+      };
+      const raw = result.rawTrackedDetections.find((r) => r.trackId === t.trackId);
+      this.trackStore.upsert({
+        trackId: t.trackId,
+        deviceId,
+        className: t.className,
+        ...raw?.originalClass && raw.originalClass !== t.className ? { label: raw.originalClass } : {},
+        timestamp: result.timestamp,
+        position: {
+          x: center.x,
+          y: center.y,
+          timestamp: result.timestamp,
+          bbox: { ...t.bbox }
+        },
+        zones: t.zones,
+        state: t.state
+      });
+    }
+    const prevIds = this.lastActiveTrackIds.get(deviceId) ?? /* @__PURE__ */ new Set();
+    for (const id of currentTrackIds) {
+      if (!prevIds.has(id)) {
+        const t = result.tracked.find((x) => x.trackId === id);
+        if (t) {
+          this.ctx.eventBus.emit({
+            id: `pa-${node_crypto.randomUUID()}`,
+            timestamp: new Date(result.timestamp),
+            source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+            category: types.EventCategory.PipelineAnalyticsTrackStarted,
+            data: { deviceId, trackId: id, className: t.className }
+          });
+        }
+      }
+    }
+    this.lastActiveTrackIds.set(deviceId, currentTrackIds);
+    await Promise.all(result.objectEvents.map((e) => this.eventStore.insertObject(e)));
+    for (const e of result.objectEvents) {
+      this.ctx.eventBus.emit({
+        id: `pa-${e.id}`,
+        timestamp: new Date(e.timestamp),
+        source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+        category: types.EventCategory.PipelineAnalyticsDetectionEvent,
+        data: { deviceId, kind: "object", eventId: e.id, timestamp: e.timestamp }
+      });
+    }
+    this.ctx.eventBus.emit({
+      id: `pa-${node_crypto.randomUUID()}`,
+      timestamp: new Date(result.timestamp),
+      source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+      category: types.EventCategory.PipelineAnalyticsFrameTracked,
+      data: {
+        deviceId,
+        timestamp: result.timestamp,
+        frameWidth: result.frameWidth,
+        frameHeight: result.frameHeight,
+        detections: result.tracked
+      }
+    });
+  }
+  async handleAudioResult(data) {
+    if (this.shuttingDown) return;
+    const { deviceId, frame } = data;
+    const active = await this.bindingCache.isActive(deviceId);
+    if (!active) return;
+    const level = frame.level;
+    const timestamp = frame.timestamp ?? Date.now();
+    const topClassification = frame.detections && frame.detections.length > 0 ? frame.detections[0] : void 0;
+    void this.audioMetrics?.recordAudioFrame({
+      deviceId,
+      timestamp,
+      ...level ? { level } : {},
+      ...topClassification ? {
+        topClassification: {
+          className: topClassification.macroClass,
+          score: topClassification.score
+        }
+      } : {}
+    });
+    const className = topClassification?.macroClass;
+    const scoreFloor = 0.4;
+    const hasMeaningfulClassification = className !== void 0 && (topClassification?.score ?? 0) >= scoreFloor;
+    const dbfsFloor = -55;
+    const aboveSilence = (level?.dbfs ?? -Infinity) > dbfsFloor;
+    if (!hasMeaningfulClassification && !aboveSilence) return;
+    const last = this.lastAudioInsertByDevice.get(deviceId);
+    const sameClass = last?.className === className;
+    const heartbeatDue = !last || timestamp - last.atMs >= AUDIO_EVENT_HEARTBEAT_MS;
+    if (sameClass && !heartbeatDue) return;
+    const ev = {
+      id: node_crypto.randomUUID(),
+      deviceId,
+      timestamp,
+      kind: "audio",
+      rms: level?.rms ?? 0,
+      dbfs: level?.dbfs ?? 0,
+      ...topClassification ? {
+        classification: {
+          className: topClassification.macroClass,
+          ...topClassification.debug?.originalClass !== void 0 ? { originalClass: topClassification.debug.originalClass } : {},
+          score: topClassification.score
+        }
+      } : {}
+    };
+    this.lastAudioInsertByDevice.set(deviceId, { className, atMs: timestamp });
+    await this.eventStore.insertAudio(ev);
+    this.ctx.eventBus.emit({
+      id: `pa-${ev.id}`,
+      timestamp: new Date(ev.timestamp),
+      source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+      category: types.EventCategory.PipelineAnalyticsDetectionEvent,
+      data: { deviceId, kind: "audio", eventId: ev.id, timestamp: ev.timestamp }
+    });
+  }
+  /**
+   * Persist motion-analysis bus events. Mirrors `handleAudioResult`'s
+   * coalescing strategy: emit one row on off→on transition, then one
+   * per `MOTION_EVENT_HEARTBEAT_MS` while motion stays detected. No
+   * row on off→off (silence) or while heartbeat hasn't elapsed.
+   *
+   * Gated on the same `pipeline-analytics` wrapper binding as the
+   * inference + audio handlers so toggling the wrapper off for a
+   * camera stops every kind of event persistence at once.
+   */
+  async handleMotionAnalysis(deviceId, payload, timestamp) {
+    if (this.shuttingDown) return;
+    const active = await this.bindingCache.isActive(deviceId);
+    if (!active) return;
+    const detected = payload.detected === true;
+    const last = this.lastMotionInsertByDevice.get(deviceId);
+    const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
+    const transitionedOn = detected && (last === void 0 || last.detected === false);
+    if (!detected) return;
+    if (!transitionedOn && !heartbeatDue) return;
+    const ev = {
+      id: node_crypto.randomUUID(),
+      deviceId,
+      timestamp,
+      kind: "motion",
+      regionCount: payload.regionCount,
+      regions: payload.regions.map((r) => ({
+        bbox: { x: r.bbox.x, y: r.bbox.y, w: r.bbox.w, h: r.bbox.h },
+        pixelCount: r.pixelCount,
+        intensity: r.intensity
+      })),
+      frameWidth: payload.frameWidth,
+      frameHeight: payload.frameHeight
+    };
+    this.lastMotionInsertByDevice.set(deviceId, { detected, atMs: timestamp });
+    await this.eventStore.insertMotion(ev);
+    this.ctx.eventBus.emit({
+      id: `pa-${ev.id}`,
+      timestamp: new Date(ev.timestamp),
+      source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+      category: types.EventCategory.PipelineAnalyticsDetectionEvent,
+      data: { deviceId, kind: "motion", eventId: ev.id, timestamp: ev.timestamp }
+    });
+  }
+  /**
+   * Persist firmware-driven (onboard) motion events. Mirrors
+   * {@link handleMotionAnalysis}'s coalescing — one row on off→on
+   * transition, then one per `MOTION_EVENT_HEARTBEAT_MS` while motion
+   * stays detected — but reads from the {@link MotionOnMotionChangedPayload}
+   * shape which lacks frame dimensions and pixel-level region details
+   * (firmware reports a binary detected flag plus, on rare devices, a
+   * coarse bbox via the optional `regions` field).
+   *
+   * The same `lastMotionInsertByDevice` map is shared with the analyzer
+   * path so a camera that briefly switches `motionSources` between
+   * `onboard` and `analyzer` gets consistent throttling — both paths
+   * are mutually exclusive at the event-emit layer (the runner only
+   * fires `MotionAnalysis` when its analyzer runs; onboard providers
+   * never fire `MotionAnalysis`), so there's no double-count risk.
+   */
+  async handleOnboardMotion(deviceId, payload, timestamp) {
+    if (this.shuttingDown) return;
+    const active = await this.bindingCache.isActive(deviceId);
+    if (!active) return;
+    const detected = payload.detected === true;
+    const last = this.lastMotionInsertByDevice.get(deviceId);
+    const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
+    const transitionedOn = detected && (last === void 0 || last.detected === false);
+    if (!detected) return;
+    if (!transitionedOn && !heartbeatDue) return;
+    const regions = payload.regions ?? [];
+    const ev = {
+      id: node_crypto.randomUUID(),
+      deviceId,
+      timestamp,
+      kind: "motion",
+      regionCount: regions.length,
+      regions: regions.map((r) => ({
+        bbox: { x: r.bbox.x, y: r.bbox.y, w: r.bbox.w, h: r.bbox.h },
+        pixelCount: r.pixelCount,
+        intensity: r.intensity
+      })),
+      frameWidth: 0,
+      frameHeight: 0
+    };
+    this.lastMotionInsertByDevice.set(deviceId, { detected, atMs: timestamp });
+    await this.eventStore.insertMotion(ev);
+    this.ctx.eventBus.emit({
+      id: `pa-${ev.id}`,
+      timestamp: new Date(ev.timestamp),
+      source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+      category: types.EventCategory.PipelineAnalyticsDetectionEvent,
+      data: { deviceId, kind: "motion", eventId: ev.id, timestamp: ev.timestamp }
+    });
+  }
+  // ── Housekeeping ─────────────────────────────────────────────────────
+  async sweepExpiredTracks() {
+    if (this.shuttingDown || !this.trackStore) return;
+    try {
+      const expired = await this.trackStore.expireStale(Date.now());
+      for (const t of expired) {
+        const duration = t.lastSeen - t.firstSeen;
+        this.ctx.eventBus.emit({
+          id: `pa-end-${t.trackId}`,
+          timestamp: new Date(t.lastSeen),
+          source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+          category: types.EventCategory.PipelineAnalyticsTrackEnded,
+          data: {
+            deviceId: t.deviceId,
+            trackId: t.trackId,
+            className: t.className,
+            durationMs: duration
+          }
+        });
+      }
+    } catch (err) {
+      if (this.shuttingDown) return;
+      this.ctx.logger.debug("sweepExpiredTracks failed", { meta: { error: String(err) } });
+    }
+  }
+  async sweepRetention() {
+    if (this.shuttingDown || !this.eventStore || !this.mediaStore) return;
+    const now = Date.now();
+    const day = 24 * 60 * 60 * 1e3;
+    try {
+      await this.eventStore.evictBefore({
+        motionCutoffMs: now - 14 * day,
+        objectCutoffMs: now - 30 * day,
+        audioCutoffMs: now - 7 * day
+      });
+      await this.mediaStore.evictBefore(now - 14 * day);
+    } catch (err) {
+      this.ctx.logger.debug("sweepRetention failed", { meta: { error: String(err) } });
+    }
+  }
+  getOrCreateProcessor(deviceId) {
+    let p = this.processors.get(deviceId);
+    if (!p) {
+      p = new FrameProcessor(deviceId);
+      this.processors.set(deviceId, p);
+    }
+    return p;
+  }
+  /**
+   * Resolve and cache a {@link DeviceProxy} for a device. Pins the
+   * `state.zones` + `state.zoneRules` slice handles so `.value` stays
+   * warm via the kernel runtime-state mirror. Slice subscribers also
+   * forward updates to the per-device FrameProcessor so a rule change
+   * applies to the very next frame even when frames stop briefly
+   * (e.g. during binding flips).
+   */
+  async ensureProxy(deviceId) {
+    const cached = this.proxies.get(deviceId);
+    if (cached) return cached;
+    try {
+      const proxy = await this.ctx.api.deviceManager ? await this.ctx.fetchDevice(deviceId) : null;
+      if (!proxy) return null;
+      this.proxies.set(deviceId, proxy);
+      const unsubs = [
+        proxy.state.zones.subscribe((slice) => {
+          const zones = slice?.zones ?? [];
+          this.processors.get(deviceId)?.setZones(zones);
+        }),
+        proxy.state.zoneRules.subscribe((slice) => {
+          const rules = slice?.detection ?? [];
+          this.processors.get(deviceId)?.setDetectionRules(rules);
+        })
+      ];
+      this.proxyUnsubs.set(deviceId, unsubs);
+      return proxy;
+    } catch (err) {
+      this.ctx.logger.debug("analytics ensureProxy failed", {
+        tags: { deviceId },
+        meta: { error: err instanceof Error ? err.message : String(err) }
+      });
+      return null;
+    }
+  }
+  releaseProxy(deviceId) {
+    const unsubs = this.proxyUnsubs.get(deviceId);
+    if (unsubs) {
+      for (const u of unsubs) {
+        try {
+          u();
+        } catch {
+        }
+      }
+    }
+    this.proxyUnsubs.delete(deviceId);
+    this.proxies.delete(deviceId);
+  }
+  // ── Cap query methods ────────────────────────────────────────────────
+  async getActiveTracks(input) {
+    return this.trackStore?.getActive(input.deviceId) ?? [];
+  }
+  async getTrack(input) {
+    const active = this.trackStore?.getActiveByTrack(input.trackId);
+    if (active) return active;
+    return await this.trackStore?.getPersistedByTrackId(input.trackId) ?? null;
+  }
+  async listTracks(input) {
+    return this.trackStore?.queryHistorical(input) ?? [];
+  }
+  async clearTracks(input) {
+    this.trackStore?.clearDevice(input.deviceId);
+    this.lastActiveTrackIds.delete(input.deviceId);
+  }
+  async getMotionEvents(input) {
+    return this.eventStore?.queryMotion(input) ?? [];
+  }
+  async getObjectEvents(input) {
+    return this.eventStore?.queryObject(input) ?? [];
+  }
+  async getAudioEvents(input) {
+    return this.eventStore?.queryAudio(input) ?? [];
+  }
+  async getEventMedia(input) {
+    return this.mediaStore?.listByOwner("event", input.eventId) ?? [];
+  }
+  async getTrackMedia(input) {
+    return this.mediaStore?.listByOwner("track", input.trackId) ?? [];
+  }
+  // ── Global + per-device settings (P8) ─────────────────────────────
+  //
+  // Cascade: global defaults live on this addon's global settings
+  // (getGlobalSettings); per-device overrides live on the device
+  // settings aggregator (getDeviceSettingsContribution → BindingsTab's
+  // device panel). A missing device override falls back to the global
+  // default — same pattern pipeline-orchestrator uses.
+  globalSettingsSchema() {
+    return this.schema({
+      sections: [
+        {
+          id: "tracking-core",
+          title: "Tracking",
+          description: "Default track lifecycle + history knobs. Per-device overrides on each camera.",
+          columns: 2,
+          fields: [
+            {
+              type: "slider",
+              key: "trackTtlMs",
+              label: "Track TTL",
+              description: "Milliseconds without a sighting before a track is finalized and promoted to history.",
+              min: 5e3,
+              max: 12e4,
+              step: 1e3,
+              default: 3e4,
+              showValue: true,
+              unit: "s",
+              displayScale: 1e3
+            },
+            {
+              type: "slider",
+              key: "maxPositionHistory",
+              label: "Max positions per track",
+              description: "Positions retained in memory; older entries get first-half downsampled.",
+              min: 50,
+              max: 1e3,
+              step: 50,
+              default: 300,
+              showValue: true
+            }
+          ]
+        },
+        {
+          id: "media-policy",
+          title: "Snapshots & media",
+          columns: 2,
+          fields: [
+            {
+              type: "boolean",
+              key: "saveThumbnails",
+              label: "Save track thumbnails",
+              description: "Periodic snapshot crops attached to tracks for timeline review.",
+              default: true
+            },
+            {
+              type: "slider",
+              key: "snapshotIntervalMs",
+              label: "Snapshot interval",
+              description: "How often a snapshot is persisted per active track.",
+              min: 500,
+              max: 6e4,
+              step: 500,
+              default: 2e3,
+              showValue: true,
+              unit: "s",
+              displayScale: 1e3
+            },
+            {
+              type: "select",
+              key: "mediaAttachPolicy",
+              label: "Attach media to events",
+              description: "Which events get a persisted crop.",
+              default: "motion",
+              options: [
+                { value: "always", label: "Every event" },
+                { value: "motion", label: "Only while motion is active" },
+                { value: "never", label: "Never" }
+              ]
+            }
+          ]
+        },
+        {
+          id: "audio-metrics-report",
+          title: "Audio metrics reporting",
+          description: "Coalesce audio-metrics state updates so the events tab + bus aren't flooded by per-second dBFS jitter on idle scenes. Per-camera override.",
+          columns: 2,
+          fields: [
+            {
+              type: "boolean",
+              key: "audioMetricsReportEnabled",
+              label: "Mirror to device-state",
+              description: "When off, the audio classifier still runs (the live AUDIO METRICS panel reads through the cap method), but the periodic state-changed events are suppressed. Use for cameras where audio is informational only.",
+              default: true
+            },
+            {
+              type: "slider",
+              key: "audioMetricsReportThresholdDb",
+              label: "Report threshold",
+              description: "Minimum dBFS delta between consecutive snapshots to trigger an emit. 2dB means quiet noise jitter (±1dB) is suppressed; class changes always emit regardless. Lower = more updates.",
+              min: 0,
+              max: 10,
+              step: 1,
+              default: 2,
+              showValue: true,
+              unit: "dB"
+            }
+          ]
+        },
+        {
+          id: "retention",
+          title: "Retention",
+          description: "How long each event kind is kept in the SQL store. Media files follow the minimum of these.",
+          columns: 3,
+          fields: [
+            {
+              type: "number",
+              key: "retentionMotionDays",
+              label: "Motion events",
+              min: 1,
+              max: 365,
+              step: 1,
+              default: 14,
+              unit: "days"
+            },
+            {
+              type: "number",
+              key: "retentionObjectDays",
+              label: "Object events",
+              min: 1,
+              max: 365,
+              step: 1,
+              default: 30,
+              unit: "days"
+            },
+            {
+              type: "number",
+              key: "retentionAudioDays",
+              label: "Audio events",
+              min: 1,
+              max: 365,
+              step: 1,
+              default: 7,
+              unit: "days"
+            }
+          ]
+        }
+      ]
+    });
+  }
+  async getDeviceSettingsContribution(input) {
+    if (!await this.isCameraDevice(input.deviceId)) return null;
+    const schema = this.globalSettingsSchema();
+    const raw = await this.ctx?.settings?.readDeviceStore(input.deviceId) ?? {};
+    const baseSections = schema ? types.hydrateSchema(
+      {
+        ...schema,
+        sections: schema.sections.map((s) => ({ ...s, tab: s.tab ?? "Analytics" }))
+      },
+      raw
+    ).sections : [];
+    const liveStatsSection = {
+      id: "live-stats",
+      title: "Live Stats",
+      tab: "live-stats",
+      location: "top-tab",
+      columns: 1,
+      order: 0,
+      fields: [
+        {
+          type: "live-stats",
+          key: "liveStats",
+          label: "Live Stats",
+          span: 1,
+          // Renderer resolves `deviceId` via `useDeviceContext`; the
+          // hydrated value is unused — kept for the form runtime
+          // which requires a value field on every entry.
+          value: void 0
+        }
+      ]
+    };
+    return { sections: [...baseSections, liveStatsSection] };
+  }
+  async getDeviceLiveContribution(_input) {
+    return null;
+  }
+  async applyDeviceSettingsPatch(input) {
+    await this.updateDeviceSettings(input.deviceId, input.patch);
+    return { success: true };
+  }
+  /**
+   * Best-effort camera-type check. Used to short-circuit the settings
+   * contribution on non-camera devices. Returns `true` on lookup
+   * failure so a transient device-manager hiccup never silently hides
+   * legitimate camera sections.
+   */
+  async isCameraDevice(deviceId) {
+    const api = this.ctx?.api;
+    if (!api) return true;
+    try {
+      const dev = await api.deviceManager.getDevice.query({ deviceId });
+      if (!dev) return true;
+      return dev.type === types.DeviceType.Camera;
+    } catch {
+      return true;
+    }
+  }
+}
+module.exports = PipelineAnalyticsAddon;
+//# sourceMappingURL=index.js.map