@camstack/addon-post-analysis 0.1.18 → 0.1.20

package/dist/pipeline-analytics/index.js

@@ -1,6 +1,8 @@
 "use strict";
-const index = require("../index-DafwGlkQ.js");
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../index-B0RhVv1c.js");
 const node_crypto = require("node:crypto");
+const sharp = require("sharp");
 function pointInPolygon(point, polygon) {
   if (polygon.length < 3) return false;
   let inside = false;
@@ -891,7 +893,7 @@ class MediaStore {
     const key = buildKey(params);
     const path = buildPath(params);
     try {
-      await this.storage.write({ location: "data", relativePath: path, data: params.data });
+      await this.storage.write({ location: "eventMedia", relativePath: path, data: params.data });
       await this.store.insert.mutate({
         collection: MEDIA_COLLECTION,
         record: {
@@ -926,7 +928,7 @@ class MediaStore {
       const sizeBytes = Number(data["sizeBytes"]);
       const kind = String(data["kind"]);
       try {
-        const buf = await this.storage.read({ location: "data", relativePath: path });
+        const buf = await this.storage.read({ location: "eventMedia", relativePath: path });
         files.push({
           key: row.id,
           kind,
@@ -942,6 +944,32 @@ class MediaStore {
     }
     return files;
   }
+  /** Delete ALL media (rows + blobs) owned by the given events. Called when the
+   *  events are evicted at retention so a thumbnail never outlives its event.
+   *  Returns number of blobs removed. Best-effort per row. */
+  async deleteForEvents(eventIds) {
+    let removed = 0;
+    for (const eventId of eventIds) {
+      const rows = await this.store.query.query({
+        collection: MEDIA_COLLECTION,
+        filter: { where: { ownerKind: "event", ownerId: eventId } }
+      });
+      for (const row of rows) {
+        const path = String(row.data["path"] ?? "");
+        try {
+          if (path) await this.storage.delete({ location: "eventMedia", relativePath: path });
+        } catch {
+        }
+        try {
+          await this.store.delete.mutate({ collection: MEDIA_COLLECTION, key: row.id });
+          removed++;
+        } catch (err) {
+          this.logger.debug("media delete-for-event failed", { meta: { key: row.id, error: String(err) } });
+        }
+      }
+    }
+    return removed;
+  }
   /** Retention sweep: delete any media row + blob older than cutoff.
    *  Returns number of entries removed. */
   async evictBefore(cutoffMs) {
@@ -953,7 +981,7 @@ class MediaStore {
     for (const row of rows) {
       const path = String(row.data["path"] ?? "");
       try {
-        if (path) await this.storage.delete({ location: "data", relativePath: path });
+        if (path) await this.storage.delete({ location: "eventMedia", relativePath: path });
       } catch {
       }
       try {
@@ -971,6 +999,7 @@ class MediaStore {
 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 PRUNE_PAGE_SIZE = 500;
 const COMMON_BASE_COLUMNS = [
   { name: "id", type: "TEXT", primaryKey: true, notNull: true },
   { name: "deviceId", type: "INTEGER", notNull: true },
@@ -1081,6 +1110,9 @@ class EventStore {
       collection: MOTION_EVENTS_COLLECTION,
       filter: this.buildFilter(q)
     });
+    if (q.projection === "slim") {
+      return rows.map((r) => slimMotion(r.id, stripNulls(r.data)));
+    }
     return rows.map((r) => {
       const ev = { id: r.id, kind: "motion", ...stripNulls(r.data) };
       return ev;
@@ -1096,6 +1128,9 @@ class EventStore {
       collection: OBJECT_EVENTS_COLLECTION,
       filter
     });
+    if (q.projection === "slim") {
+      return rows.map((r) => slimObject(r.id, stripNulls(r.data)));
+    }
     return rows.map((r) => {
       const ev = { id: r.id, kind: "object", ...stripNulls(r.data) };
       return ev;
@@ -1106,35 +1141,193 @@ class EventStore {
       collection: AUDIO_EVENTS_COLLECTION,
       filter: this.buildFilter(q)
     });
+    if (q.projection === "slim") {
+      return rows.map((r) => slimAudio(r.id, stripNulls(r.data)));
+    }
     return rows.map((r) => {
       const ev = { id: r.id, kind: "audio", ...stripNulls(r.data) };
       return ev;
     });
   }
+  // ── Density (histogram aggregation) ─────────────────────────────
+  /**
+   * Return per-kind event counts in equal-width time buckets.
+   *
+   * Each bucket maps to a `bucketStart = since + i * bucketMs`.
+   * Empty buckets (motion + object + audio all zero) are omitted so the
+   * UI only processes non-trivial data points.
+   *
+   * All three collections are queried in parallel via `histogram` to
+   * minimise latency.
+   */
+  async densityByKind(q) {
+    const run = async (collection) => {
+      const rows = await this.store.histogram.query({
+        collection,
+        field: "timestamp",
+        bucketSize: q.bucketMs,
+        origin: q.since,
+        filter: {
+          where: { deviceId: q.deviceId },
+          whereBetween: { timestamp: [q.since, q.until] }
+        }
+      });
+      return new Map(rows.map((r) => [r.bucket, r.count]));
+    };
+    const [motionMap, objectMap, audioMap] = await Promise.all([
+      run(MOTION_EVENTS_COLLECTION),
+      run(OBJECT_EVENTS_COLLECTION),
+      run(AUDIO_EVENTS_COLLECTION)
+    ]);
+    const buckets = Math.max(0, Math.ceil((q.until - q.since) / q.bucketMs));
+    const out = [];
+    for (let i = 0; i < buckets; i++) {
+      const m = motionMap.get(i) ?? 0;
+      const o = objectMap.get(i) ?? 0;
+      const a = audioMap.get(i) ?? 0;
+      if (m + o + a === 0) continue;
+      out.push({ bucketStart: q.since + i * q.bucketMs, motion: m, object: o, audio: a });
+    }
+    return out;
+  }
   // ── Retention ────────────────────────────────────────────────────
   // (helper below)
+  /**
+   * Delete events older than the per-kind cutoffs and RETURN the deleted ids so
+   * the caller can delete each event's media in lockstep (a thumbnail must never
+   * outlive — nor predecease — its event). Batched (≤500/kind/sweep).
+   */
   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;
+      const ids = [];
       for (const row of rows) {
+        const id = row.id;
+        if (typeof id !== "string") continue;
         try {
-          await this.store.delete.mutate({ collection, key: row.id });
-          count++;
+          await this.store.delete.mutate({ collection, key: id });
+          ids.push(id);
         } catch {
         }
       }
-      return count;
+      return ids;
+    };
+    return {
+      motion: await batch(MOTION_EVENTS_COLLECTION, params.motionCutoffMs),
+      object: await batch(OBJECT_EVENTS_COLLECTION, params.objectCutoffMs),
+      audio: await batch(AUDIO_EVENTS_COLLECTION, params.audioCutoffMs)
+    };
+  }
+  /**
+   * Delete all events for a specific device with `timestamp < cutoffMs`
+   * (exclusive upper bound) across all three kinds, returning the per-kind
+   * deleted counts and the flattened list of deleted ids (so the caller can
+   * delete thumbnails in lockstep via `MediaStore.deleteForEvents`).
+   *
+   * Filter shape: `where: { deviceId }` + `whereBetween: { timestamp: [0, cutoffMs - 1] }`
+   * mirrors the inclusive `[lo, hi]` range the settings-store backend uses,
+   * making `cutoffMs - 1` the last timestamp that qualifies (i.e. strictly < cutoffMs).
+   *
+   * The underlying settings-store `query` cap applies a default row limit
+   * (~500). This method loops per kind — repeatedly querying up to
+   * `PRUNE_PAGE_SIZE` rows and deleting them — until a page returns 0 rows,
+   * so ALL matching rows are deleted regardless of total count.
+   */
+  async pruneBefore(input) {
+    const allForDevice = async (collection) => {
+      const ids = [];
+      for (; ; ) {
+        const rows = await this.store.query.query({
+          collection,
+          filter: {
+            where: { deviceId: input.deviceId },
+            // inclusive [0, cutoffMs - 1] → selects timestamps strictly < cutoffMs
+            whereBetween: { timestamp: [0, input.cutoffMs - 1] },
+            limit: PRUNE_PAGE_SIZE
+          }
+        });
+        if (rows.length === 0) break;
+        let deletedInPage = 0;
+        for (const row of rows) {
+          const id = row.id;
+          if (typeof id !== "string") continue;
+          try {
+            await this.store.delete.mutate({ collection, key: id });
+            ids.push(id);
+            deletedInPage++;
+          } catch {
+          }
+        }
+        if (deletedInPage === 0) break;
+      }
+      return ids;
+    };
+    const [motionIds, objectIds, audioIds] = await Promise.all([
+      allForDevice(MOTION_EVENTS_COLLECTION),
+      allForDevice(OBJECT_EVENTS_COLLECTION),
+      allForDevice(AUDIO_EVENTS_COLLECTION)
+    ]);
+    return {
+      counts: {
+        motion: motionIds.length,
+        object: objectIds.length,
+        audio: audioIds.length
+      },
+      ids: [...motionIds, ...objectIds, ...audioIds]
+    };
+  }
+}
+function slimMotion(id, data) {
+  return {
+    id,
+    kind: "motion",
+    deviceId: data["deviceId"],
+    timestamp: data["timestamp"],
+    regionCount: data["regionCount"]
+    // regions / frameWidth / frameHeight intentionally omitted (slim)
+    // mediaUrl left unset — B5 will populate
+  };
+}
+function slimObject(id, data) {
+  const base = {
+    id,
+    kind: "object",
+    deviceId: data["deviceId"],
+    timestamp: data["timestamp"],
+    className: data["className"]
+    // trackId / confidence / bbox / zones / state intentionally omitted (slim)
+    // mediaUrl left unset — B5 will populate
+  };
+  if (typeof data["label"] === "string") {
+    return { ...base, label: data["label"] };
+  }
+  return base;
+}
+function slimAudio(id, data) {
+  const base = {
+    id,
+    kind: "audio",
+    deviceId: data["deviceId"],
+    timestamp: data["timestamp"],
+    rms: data["rms"],
+    dbfs: data["dbfs"]
+    // mediaUrl left unset — B5 will populate
+  };
+  if (data["classification"] !== null && data["classification"] !== void 0) {
+    const c = data["classification"];
+    return {
+      ...base,
+      classification: {
+        className: c.className,
+        score: c.score,
+        ...typeof c.originalClass === "string" ? { originalClass: c.originalClass } : {}
+      }
     };
-    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;
   }
+  return base;
 }
 function stripNulls(data) {
   const out = {};
@@ -1143,6 +1336,41 @@ function stripNulls(data) {
   }
   return out;
 }
+const THUMB_MAX_WIDTH = 360;
+const THUMB_QUALITY = 70;
+class EventThumbnailer {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Thumbnail one event. */
+  async capture(deviceId, target) {
+    await this.captureMany(deviceId, [target]);
+  }
+  /** Thumbnail several events that share a moment (e.g. multiple object events
+   *  from one inference frame) with a single snapshot fetch + encode. */
+  async captureMany(deviceId, targets) {
+    if (targets.length === 0) return;
+    try {
+      const snap = await this.deps.getSnapshot(deviceId);
+      if (!snap?.base64) return;
+      const jpeg = await sharp(Buffer.from(snap.base64, "base64")).rotate().resize({ width: THUMB_MAX_WIDTH, withoutEnlargement: true }).jpeg({ quality: THUMB_QUALITY }).toBuffer();
+      for (const t of targets) {
+        await this.deps.mediaStore.put({
+          deviceId,
+          ownerKind: "event",
+          ownerId: t.eventId,
+          kind: "thumbnail",
+          timestamp: t.timestamp,
+          data: jpeg
+        });
+      }
+    } catch (err) {
+      this.deps.logger.warn("event thumbnail capture failed", {
+        meta: { deviceId, count: targets.length, error: err instanceof Error ? err.message : String(err) }
+      });
+    }
+  }
+}
 class SliceThrottler {
   opts;
   lastWrittenAt = /* @__PURE__ */ new Map();
@@ -1710,15 +1938,128 @@ function computeAudioSnapshot(ts, s, windowSec, scoreThreshold) {
     byClass
   };
 }
+const AudioDetectionSettingsSchema = index.object({
+  classificationMinScore: index.number().min(0).max(1).default(0.6),
+  levelDeviationDb: index.number().positive().default(10),
+  levelWindowSec: index.number().positive().default(10),
+  levelMaxWaitSec: index.number().positive().default(20)
+});
+const AUDIO_DETECTION_DEFAULTS = AudioDetectionSettingsSchema.parse({});
+function resolveAudioDetectionSettings(raw) {
+  const pick = (key) => {
+    const field = AudioDetectionSettingsSchema.shape[key];
+    const parsed = field.safeParse(raw[key]);
+    return parsed.success ? parsed.data : AUDIO_DETECTION_DEFAULTS[key];
+  };
+  return {
+    classificationMinScore: pick("classificationMinScore"),
+    levelDeviationDb: pick("levelDeviationDb"),
+    levelWindowSec: pick("levelWindowSec"),
+    levelMaxWaitSec: pick("levelMaxWaitSec")
+  };
+}
+function emptyLevelState() {
+  return { samples: [], lastEmitMs: null, lastPeakMs: null };
+}
+function observeLevel(state, sample, cfg) {
+  const cutoff = sample.timestampMs - cfg.windowMs;
+  const kept = state.samples.filter((s) => s.timestampMs >= cutoff);
+  const windowSamples = [...kept, sample];
+  const mean = windowSamples.reduce((acc, s) => acc + s.dbfs, 0) / windowSamples.length;
+  const audible = sample.dbfs > cfg.silenceFloorDbfs;
+  if (!audible) {
+    return {
+      emit: false,
+      reason: null,
+      mean,
+      nextState: { samples: windowSamples, lastEmitMs: state.lastEmitMs, lastPeakMs: state.lastPeakMs }
+    };
+  }
+  const priorMean = kept.length > 0 ? kept.reduce((acc, s) => acc + s.dbfs, 0) / kept.length : mean;
+  const isPeak = sample.dbfs >= priorMean + cfg.deviationDb;
+  const sincePeak = state.lastPeakMs === null ? Number.POSITIVE_INFINITY : sample.timestampMs - state.lastPeakMs;
+  const peakCooldownOk = sincePeak >= cfg.maxWaitMs;
+  const sinceLastEmit = state.lastEmitMs === null ? Number.POSITIVE_INFINITY : sample.timestampMs - state.lastEmitMs;
+  const heartbeatCooldownOk = sinceLastEmit >= cfg.maxWaitMs;
+  let reason = null;
+  if (isPeak && peakCooldownOk) reason = "peak";
+  else if (!isPeak && heartbeatCooldownOk) reason = "heartbeat";
+  const emit = reason !== null;
+  const nextLastEmitMs = emit ? sample.timestampMs : state.lastEmitMs;
+  const nextLastPeakMs = reason === "peak" ? sample.timestampMs : state.lastPeakMs;
+  return {
+    emit,
+    reason,
+    mean,
+    nextState: { samples: windowSamples, lastEmitMs: nextLastEmitMs, lastPeakMs: nextLastPeakMs }
+  };
+}
+function classifyAudioFrame(top, cfg) {
+  if (top && top.className !== "silence" && top.score >= cfg.classificationMinScore) {
+    return { kind: "classification", className: top.className, score: top.score };
+  }
+  return { kind: "level" };
+}
+const CACHE_CONTROL = "public, max-age=31536000, immutable";
+function createEventMediaHandler(deps) {
+  return async (req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { allow: "GET, HEAD" }).end();
+      return;
+    }
+    const rawPath = (req.url ?? "/").split("?")[0] ?? "/";
+    const eventId = rawPath.replace(/^\/+/, "");
+    if (!eventId || eventId.includes("/")) {
+      res.writeHead(404).end();
+      return;
+    }
+    let media = null;
+    try {
+      media = await deps.getMedia(eventId);
+    } catch {
+      const body = "Internal server error";
+      res.writeHead(500, { "content-type": "text/plain", "content-length": String(Buffer.byteLength(body)) });
+      if (req.method !== "HEAD") res.end(body);
+      else res.end();
+      return;
+    }
+    if (media === null) {
+      res.writeHead(404).end();
+      return;
+    }
+    const etag = '"' + media.key + '"';
+    if (req.headers["if-none-match"] === etag) {
+      res.writeHead(304, { etag, "cache-control": CACHE_CONTROL }).end();
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": "image/jpeg",
+      "cache-control": CACHE_CONTROL,
+      etag,
+      "content-length": String(media.bytes.byteLength)
+    });
+    if (req.method === "HEAD") {
+      res.end();
+    } else {
+      res.end(Buffer.from(media.bytes));
+    }
+  };
+}
 const TTL_SWEEP_INTERVAL_MS = 5e3;
+const SETTINGS_CACHE_TTL_MS = 5e3;
+const SILENCE_FLOOR_DBFS = -55;
 const RETENTION_SWEEP_INTERVAL_MS = 5 * 6e4;
 const AUDIO_EVENT_HEARTBEAT_MS = 5e3;
 const MOTION_EVENT_HEARTBEAT_MS = 5e3;
+function toAnalyticsDeviceSections(sections) {
+  return sections.map((s) => ({ ...s, tab: s.tab ?? "Analytics", location: "top-tab" }));
+}
 class PipelineAnalyticsAddon extends index.BaseAddon {
   processors = /* @__PURE__ */ new Map();
   trackStore = null;
   mediaStore = null;
   eventStore = null;
+  thumbnailer = null;
   bindingCache = null;
   zoneAnalytics = null;
   audioMetrics = null;
@@ -1741,6 +2082,12 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
   unsubDeviceUnreg = null;
   ttlSweepTimer = null;
   retentionSweepTimer = null;
+  /** Handle for the event-media data-plane listener (dispose on shutdown). */
+  eventMediaDataPlane = null;
+  /** Public base URL for event thumbnails: `/addon/<addonId>/event-media`.
+   *  Set once the data-plane is registered; null until then (e.g. no
+   *  dataPlane facility in the current environment). */
+  eventMediaBaseUrl = null;
   // Current tracked-state snapshot per active track. Used so
   // TrackStarted/TrackEnded fire exactly once per lifecycle transition.
   lastActiveTrackIds = /* @__PURE__ */ new Map();
@@ -1751,6 +2098,12 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
   // 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();
+  // Per-device rolling-window loudness detector state. Updated on every audio
+  // frame that falls to the level path (non-confident / silence classification).
+  levelStateByDevice = /* @__PURE__ */ new Map();
+  // Per-device settings cache: avoids a store read every ~30 Hz audio frame.
+  // Each entry expires after SETTINGS_CACHE_TTL_MS.
+  settingsCacheByDevice = /* @__PURE__ */ new Map();
   shuttingDown = false;
   constructor() {
     super({});
@@ -1771,6 +2124,17 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
       logger: logger.child("MediaStore")
     });
     this.eventStore = new EventStore({ store: api.settingsStore, logger: logger.child("EventStore") });
+    this.thumbnailer = new EventThumbnailer({
+      getSnapshot: async (deviceId) => {
+        try {
+          return await api.snapshot.getSnapshot.query({ deviceId });
+        } catch {
+          return null;
+        }
+      },
+      mediaStore: this.mediaStore,
+      logger: logger.child("EventThumbnailer")
+    });
     this.bindingCache = new BindingCache({ api, logger: logger.child("BindingCache") });
     this.zoneAnalytics = new ZoneAnalyticsProvider({
       logger: logger.child("ZoneAnalytics"),
@@ -1791,6 +2155,25 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
         return { enabled, thresholdDb };
       }
     });
+    try {
+      const handler = createEventMediaHandler({
+        getMedia: async (id) => {
+          try {
+            return await this.readEventThumbnail(id);
+          } catch (err) {
+            this.ctx.logger.warn("readEventThumbnail failed", { meta: { eventId: id, error: index.errMsg(err) } });
+            throw err;
+          }
+        }
+      });
+      this.eventMediaDataPlane = await this.ctx.dataPlane?.serve({ prefix: "event-media", access: "admin", handler }) ?? null;
+      this.eventMediaBaseUrl = this.eventMediaDataPlane !== null ? `/addon/${this.ctx.id}/event-media` : null;
+      this.ctx.logger.info("event-media data-plane served", {
+        meta: { baseUrl: this.eventMediaBaseUrl ?? "(no dataPlane facility)" }
+      });
+    } catch (err) {
+      this.ctx.logger.warn("event-media data-plane failed to serve", { meta: { error: index.errMsg(err) } });
+    }
     this.unsubInference = this.ctx.eventBus.subscribe(
       { category: index.EventCategory.PipelineInferenceResult },
       (ev) => {
@@ -1829,6 +2212,8 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
           this.trackStore?.clearDevice(data.deviceId);
           this.processors.delete(data.deviceId);
           this.lastActiveTrackIds.delete(data.deviceId);
+          this.levelStateByDevice.delete(data.deviceId);
+          this.settingsCacheByDevice.delete(data.deviceId);
         }
       }
     );
@@ -1839,6 +2224,8 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
         this.trackStore?.clearDevice(deviceId);
         this.processors.delete(deviceId);
         this.lastActiveTrackIds.delete(deviceId);
+        this.levelStateByDevice.delete(deviceId);
+        this.settingsCacheByDevice.delete(deviceId);
         this.bindingCache?.invalidate(deviceId);
         this.zoneAnalytics?.forgetDevice(deviceId);
         this.audioMetrics?.forgetDevice(deviceId);
@@ -2042,8 +2429,13 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     this.audioMetrics?.destroy();
     this.processors.clear();
     this.lastActiveTrackIds.clear();
+    this.levelStateByDevice.clear();
+    this.settingsCacheByDevice.clear();
     this.trackStore?.clearAll();
     this.bindingCache?.clearAll();
+    await this.eventMediaDataPlane?.dispose();
+    this.eventMediaDataPlane = null;
+    this.eventMediaBaseUrl = null;
   }
   // ── Subscriber handlers ──────────────────────────────────────────────
   async handleInferenceResult(data) {
@@ -2107,6 +2499,12 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     }
     this.lastActiveTrackIds.set(deviceId, currentTrackIds);
     await Promise.all(result.objectEvents.map((e) => this.eventStore.insertObject(e)));
+    if (result.objectEvents.length > 0) {
+      void this.thumbnailer?.captureMany(
+        deviceId,
+        result.objectEvents.map((e) => ({ eventId: e.id, timestamp: e.timestamp }))
+      );
+    }
     for (const e of result.objectEvents) {
       this.ctx.eventBus.emit({
         id: `pa-${e.id}`,
@@ -2130,6 +2528,19 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
       }
     });
   }
+  /**
+   * Read per-device audio-detection settings with a TTL cache so the store
+   * is not hit on every ~30 Hz audio frame.
+   */
+  async resolveDeviceAudioSettings(deviceId) {
+    const now = Date.now();
+    const cached = this.settingsCacheByDevice.get(deviceId);
+    if (cached && now < cached.expiresAt) return cached.settings;
+    const raw = await this.ctx?.settings?.readDeviceStore(deviceId) ?? {};
+    const settings = resolveAudioDetectionSettings(raw);
+    this.settingsCacheByDevice.set(deviceId, { settings, expiresAt: now + SETTINGS_CACHE_TTL_MS });
+    return settings;
+  }
   async handleAudioResult(data) {
     if (this.shuttingDown) return;
     const { deviceId, frame } = data;
@@ -2149,33 +2560,67 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
         }
       } : {}
     });
-    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 settings = await this.resolveDeviceAudioSettings(deviceId);
+    const topForRouter = topClassification ? { className: topClassification.macroClass, score: topClassification.score } : void 0;
+    const route = classifyAudioFrame(topForRouter, { classificationMinScore: settings.classificationMinScore });
+    if (route.kind === "classification") {
+      if (!topClassification) {
+        this.ctx.logger.warn("classifyAudioFrame returned classification but topClassification is null", { meta: { deviceId } });
+        return;
+      }
+      const last = this.lastAudioInsertByDevice.get(deviceId);
+      const sameClass = last?.className === route.className;
+      const heartbeatDue = !last || timestamp - last.atMs >= AUDIO_EVENT_HEARTBEAT_MS;
+      if (sameClass && !heartbeatDue) return;
+      const ev2 = {
+        id: node_crypto.randomUUID(),
+        deviceId,
+        timestamp,
+        kind: "audio",
+        rms: level?.rms ?? 0,
+        dbfs: level?.dbfs ?? 0,
+        classification: {
+          className: topClassification.macroClass,
+          ...topClassification.debug?.originalClass !== void 0 ? { originalClass: topClassification.debug.originalClass } : {},
+          score: topClassification.score
+        }
+      };
+      this.lastAudioInsertByDevice.set(deviceId, { className: route.className, atMs: timestamp });
+      await this.eventStore.insertAudio(ev2);
+      void this.thumbnailer?.capture(ev2.deviceId, { eventId: ev2.id, timestamp: ev2.timestamp });
+      this.ctx.eventBus.emit({
+        id: `pa-${ev2.id}`,
+        timestamp: new Date(ev2.timestamp),
+        source: { type: "addon", id: "pipeline-analytics", addonId: "pipeline-analytics" },
+        category: index.EventCategory.PipelineAnalyticsDetectionEvent,
+        data: { deviceId, kind: "audio", eventId: ev2.id, timestamp: ev2.timestamp }
+      });
+      return;
+    }
+    const st = this.levelStateByDevice.get(deviceId) ?? emptyLevelState();
+    const res = observeLevel(
+      st,
+      { timestampMs: timestamp, dbfs: level?.dbfs ?? -Infinity },
+      {
+        windowMs: settings.levelWindowSec * 1e3,
+        deviationDb: settings.levelDeviationDb,
+        maxWaitMs: settings.levelMaxWaitSec * 1e3,
+        silenceFloorDbfs: SILENCE_FLOOR_DBFS
+      }
+    );
+    this.levelStateByDevice.set(deviceId, res.nextState);
+    if (!res.emit) 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
-        }
-      } : {}
+      dbfs: level?.dbfs ?? 0
     };
-    this.lastAudioInsertByDevice.set(deviceId, { className, atMs: timestamp });
+    this.lastAudioInsertByDevice.set(deviceId, { className: void 0, atMs: timestamp });
     await this.eventStore.insertAudio(ev);
+    void this.thumbnailer?.capture(ev.deviceId, { eventId: ev.id, timestamp: ev.timestamp });
     this.ctx.eventBus.emit({
       id: `pa-${ev.id}`,
       timestamp: new Date(ev.timestamp),
@@ -2220,6 +2665,7 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     };
     this.lastMotionInsertByDevice.set(deviceId, { detected, atMs: timestamp });
     await this.eventStore.insertMotion(ev);
+    void this.thumbnailer?.capture(ev.deviceId, { eventId: ev.id, timestamp: ev.timestamp });
     this.ctx.eventBus.emit({
       id: `pa-${ev.id}`,
       timestamp: new Date(ev.timestamp),
@@ -2271,6 +2717,7 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     };
     this.lastMotionInsertByDevice.set(deviceId, { detected, atMs: timestamp });
     await this.eventStore.insertMotion(ev);
+    void this.thumbnailer?.capture(ev.deviceId, { eventId: ev.id, timestamp: ev.timestamp });
     this.ctx.eventBus.emit({
       id: `pa-${ev.id}`,
       timestamp: new Date(ev.timestamp),
@@ -2308,13 +2755,31 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     if (this.shuttingDown || !this.eventStore || !this.mediaStore) return;
     const now = Date.now();
     const day = 24 * 60 * 60 * 1e3;
+    const OBJECT_RETENTION_DAYS = 30;
+    const motionCutoffMs = now - 14 * day;
+    const objectCutoffMs = now - OBJECT_RETENTION_DAYS * day;
+    const audioCutoffMs = now - 7 * day;
     try {
-      await this.eventStore.evictBefore({
-        motionCutoffMs: now - 14 * day,
-        objectCutoffMs: now - 30 * day,
-        audioCutoffMs: now - 7 * day
+      const evicted = await this.eventStore.evictBefore({
+        motionCutoffMs,
+        objectCutoffMs,
+        audioCutoffMs
       });
-      await this.mediaStore.evictBefore(now - 14 * day);
+      const evictedIds = [...evicted.motion, ...evicted.object, ...evicted.audio];
+      if (evictedIds.length > 0) {
+        await this.mediaStore.deleteForEvents(evictedIds);
+        this.ctx.logger.info("analytics event eviction (age sweep)", {
+          meta: {
+            motion: evicted.motion.length,
+            object: evicted.object.length,
+            audio: evicted.audio.length,
+            motionCutoffMs,
+            objectCutoffMs,
+            audioCutoffMs
+          }
+        });
+      }
+      await this.mediaStore.evictBefore(now - (OBJECT_RETENTION_DAYS + 1) * day);
     } catch (err) {
       this.ctx.logger.debug("sweepRetention failed", { meta: { error: String(err) } });
     }
@@ -2392,13 +2857,22 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     this.lastActiveTrackIds.delete(input.deviceId);
   }
   async getMotionEvents(input) {
-    return this.eventStore?.queryMotion(input) ?? [];
+    const events = await (this.eventStore?.queryMotion(input) ?? Promise.resolve([]));
+    if (input.projection !== "slim" || this.eventMediaBaseUrl === null) return events;
+    return this.withMediaUrl(events);
+  }
+  async getEventDensity(input) {
+    return this.eventStore?.densityByKind(input) ?? [];
   }
   async getObjectEvents(input) {
-    return this.eventStore?.queryObject(input) ?? [];
+    const events = await (this.eventStore?.queryObject(input) ?? Promise.resolve([]));
+    if (input.projection !== "slim" || this.eventMediaBaseUrl === null) return events;
+    return this.withMediaUrl(events);
   }
   async getAudioEvents(input) {
-    return this.eventStore?.queryAudio(input) ?? [];
+    const events = await (this.eventStore?.queryAudio(input) ?? Promise.resolve([]));
+    if (input.projection !== "slim" || this.eventMediaBaseUrl === null) return events;
+    return this.withMediaUrl(events);
   }
   async getEventMedia(input) {
     return this.mediaStore?.listByOwner("event", input.eventId) ?? [];
@@ -2406,6 +2880,45 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
   async getTrackMedia(input) {
     return this.mediaStore?.listByOwner("track", input.trackId) ?? [];
   }
+  async pruneEventsBefore(input) {
+    if (!this.eventStore) return { motion: 0, object: 0, audio: 0 };
+    const { counts, ids } = await this.eventStore.pruneBefore(input);
+    if (ids.length > 0 && this.mediaStore) {
+      await this.mediaStore.deleteForEvents([...ids]);
+    }
+    const { motion, object, audio } = counts;
+    if (motion + object + audio > 0) {
+      this.ctx.logger.info("analytics event eviction (floor)", {
+        meta: { deviceId: input.deviceId, cutoffMs: input.cutoffMs, motion, object, audio }
+      });
+    }
+    return counts;
+  }
+  // ── Data-plane helpers ────────────────────────────────────────────────
+  /**
+   * Decode a stored event thumbnail into `EventMedia` for the data-plane
+   * handler. Prefers the `thumbnail` kind; falls back to the first file
+   * if no thumbnail is present. Returns `null` if the event has no media.
+   */
+  async readEventThumbnail(eventId) {
+    const files = await (this.mediaStore?.listByOwner("event", eventId) ?? Promise.resolve([]));
+    const thumbnail = files.find((f) => f.kind === "thumbnail") ?? files[0];
+    if (!thumbnail) return null;
+    const bytes = Buffer.from(thumbnail.base64, "base64");
+    return { bytes, key: thumbnail.key };
+  }
+  /**
+   * Return a new array where each event gets a `mediaUrl` stamp pointing
+   * to its thumbnail on the event-media data-plane.
+   *
+   * Only called when `this.eventMediaBaseUrl` is non-null (guard sits in
+   * the callers), so the template literal is safe.
+   */
+  withMediaUrl(events) {
+    const base = this.eventMediaBaseUrl;
+    if (base === null) return events;
+    return events.map((e) => ({ ...e, mediaUrl: `${base}/${e.id}` }));
+  }
   // ── Global + per-device settings (P8) ─────────────────────────────
   //
   // Cascade: global defaults live on this addon's global settings
@@ -2551,6 +3064,54 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
               unit: "days"
             }
           ]
+        },
+        {
+          id: "audio-detection",
+          title: "Audio detection",
+          description: "Thresholds for audio-level and classification events. Per-device override.",
+          columns: 2,
+          fields: [
+            {
+              type: "number",
+              key: "classificationMinScore",
+              label: "Classification min score",
+              description: "Minimum confidence (0–1) for a classification result to be accepted.",
+              min: 0,
+              max: 1,
+              step: 0.05,
+              default: AUDIO_DETECTION_DEFAULTS.classificationMinScore
+            },
+            {
+              type: "number",
+              key: "levelDeviationDb",
+              label: "Level deviation",
+              description: "dB above the rolling mean required to trigger a peak event.",
+              min: 1,
+              step: 1,
+              default: AUDIO_DETECTION_DEFAULTS.levelDeviationDb,
+              unit: "dB"
+            },
+            {
+              type: "number",
+              key: "levelWindowSec",
+              label: "Level window",
+              description: "Rolling baseline window length for peak detection.",
+              min: 1,
+              step: 1,
+              default: AUDIO_DETECTION_DEFAULTS.levelWindowSec,
+              unit: "s"
+            },
+            {
+              type: "number",
+              key: "levelMaxWaitSec",
+              label: "Level max wait",
+              description: "Maximum silence between events before a heartbeat sample is emitted.",
+              min: 1,
+              step: 1,
+              default: AUDIO_DETECTION_DEFAULTS.levelMaxWaitSec,
+              unit: "s"
+            }
+          ]
         }
       ]
     });
@@ -2562,7 +3123,7 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     const baseSections = schema ? index.hydrateSchema(
       {
         ...schema,
-        sections: schema.sections.map((s) => ({ ...s, tab: s.tab ?? "Analytics" }))
+        sections: toAnalyticsDeviceSections(schema.sections)
       },
       raw
     ).sections : [];
@@ -2590,6 +3151,7 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
   }
   async applyDeviceSettingsPatch(input) {
     await this.updateDeviceSettings(input.deviceId, input.patch);
+    this.settingsCacheByDevice.delete(input.deviceId);
     return { success: true };
   }
   /**
@@ -2610,5 +3172,6 @@ class PipelineAnalyticsAddon extends index.BaseAddon {
     }
   }
 }
-module.exports = PipelineAnalyticsAddon;
+exports.default = PipelineAnalyticsAddon;
+exports.toAnalyticsDeviceSections = toAnalyticsDeviceSections;
 //# sourceMappingURL=index.js.map