@camstack/addon-post-analysis 0.1.1

package/dist/enrichment-engine/index.mjs

@@ -0,0 +1,774 @@
+import { EventCategory, createEvent, BaseAddon, asJsonObject } from "@camstack/types";
+import sharp from "sharp";
+import { z } from "zod";
+const DEFAULT_ENRICHMENT_CONFIG = {
+  enabled: false,
+  embedding: {
+    enabled: false,
+    modelId: "clip-vit-b32",
+    agentId: "local",
+    runtime: "node",
+    backend: "cpu",
+    classes: [],
+    minConfidence: 0.5,
+    maxPerSecPerCamera: 1,
+    cropStrategy: "first",
+    retentionDays: 30
+  },
+  sceneMonitor: {
+    enabled: false,
+    modelId: "clip-vit-b32",
+    pollIntervalSec: 10,
+    hysteresisCount: 3
+  },
+  activitySummary: {
+    enabled: false,
+    intervalSec: 60,
+    activityThresholds: {
+      low: 2,
+      medium: 10,
+      high: 30
+    }
+  }
+};
+async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
+  const rawLeft = Math.round(bbox.x * frameWidth);
+  const rawTop = Math.round(bbox.y * frameHeight);
+  const rawWidth = Math.round(bbox.w * frameWidth);
+  const rawHeight = Math.round(bbox.h * frameHeight);
+  const left = Math.max(0, Math.min(rawLeft, frameWidth - 1));
+  const top = Math.max(0, Math.min(rawTop, frameHeight - 1));
+  const width = Math.max(1, Math.min(rawWidth, frameWidth - left));
+  const height = Math.max(1, Math.min(rawHeight, frameHeight - top));
+  const crop = await sharp(frameData, {
+    raw: { width: frameWidth, height: frameHeight, channels: 3 }
+  }).extract({ left, top, width, height }).jpeg({ quality: 90 }).toBuffer();
+  return { crop, width, height };
+}
+class EmbeddingDispatcher {
+  config;
+  encoders;
+  eventBus;
+  logger;
+  lastEmbedTime = /* @__PURE__ */ new Map();
+  pendingCrops = /* @__PURE__ */ new Map();
+  flushTimer = null;
+  unsubscribe = null;
+  _processedCount = 0;
+  _totalInferenceMs = 0;
+  _encoderIndex = 0;
+  constructor(deps) {
+    this.config = deps.config;
+    this.encoders = deps.encoders;
+    this.eventBus = deps.eventBus;
+    this.logger = deps.logger;
+  }
+  async start() {
+    if (!this.config.enabled) {
+      this.logger.info("EmbeddingDispatcher disabled");
+      return;
+    }
+    this.unsubscribe = this.eventBus.subscribe(
+      { category: EventCategory.DetectionResult },
+      (event) => {
+        void this.handleDetectionResult(event);
+      }
+    );
+    if (this.config.cropStrategy === "best-confidence") {
+      this.flushTimer = setInterval(() => {
+        void this.flushPending();
+      }, 1e3);
+    }
+    this.logger.info("EmbeddingDispatcher started", { meta: { strategy: this.config.cropStrategy, maxPerSec: this.config.maxPerSecPerCamera } });
+  }
+  async stop() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushPending();
+  }
+  get processedCount() {
+    return this._processedCount;
+  }
+  get avgInferenceMs() {
+    return this._processedCount > 0 ? this._totalInferenceMs / this._processedCount : 0;
+  }
+  get queueDepth() {
+    return this.pendingCrops.size;
+  }
+  async handleDetectionResult(event) {
+    const data = event.data;
+    const deviceId = event.source.id !== void 0 ? String(event.source.id) : "";
+    if (!deviceId) return;
+    const detections = data.analysisResults ?? [];
+    const pipelineResult = data.pipelineResult;
+    for (const det of detections) {
+      const detection = det.detection;
+      if (!detection) continue;
+      if (this.config.classes.length > 0 && !this.config.classes.includes(detection.class)) continue;
+      if (detection.score < this.config.minConfidence) continue;
+      const now = Date.now();
+      const minInterval = 1e3 / this.config.maxPerSecPerCamera;
+      const lastTime = this.lastEmbedTime.get(deviceId) ?? 0;
+      if (now - lastTime < minInterval) continue;
+      const trackId = detection.trackId ?? `${deviceId}-${now}`;
+      const frameData = pipelineResult.frameData;
+      const frameWidth = pipelineResult.imageWidth;
+      const frameHeight = pipelineResult.imageHeight;
+      if (!frameData || !frameWidth || !frameHeight) continue;
+      const pending = {
+        trackId,
+        deviceId,
+        class: detection.class,
+        confidence: detection.score,
+        frameData,
+        frameWidth,
+        frameHeight,
+        bbox: detection.bbox,
+        receivedAt: now
+      };
+      switch (this.config.cropStrategy) {
+        case "first": {
+          if (!this.pendingCrops.has(trackId)) {
+            this.pendingCrops.set(trackId, pending);
+            void this.processOne(pending);
+          }
+          break;
+        }
+        case "best-confidence": {
+          const existing = this.pendingCrops.get(trackId);
+          if (!existing || pending.confidence > existing.confidence) {
+            this.pendingCrops.set(trackId, pending);
+          }
+          break;
+        }
+        case "track-end": {
+          const state = det.objectState?.state;
+          if (state === "leaving") {
+            this.pendingCrops.set(trackId, pending);
+            void this.processOne(pending);
+          } else {
+            const existing = this.pendingCrops.get(trackId);
+            if (!existing || pending.confidence > existing.confidence) {
+              this.pendingCrops.set(trackId, pending);
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  async flushPending() {
+    const now = Date.now();
+    const toFlush = [];
+    for (const [trackId, pending] of this.pendingCrops) {
+      if (now - pending.receivedAt > 3e3) {
+        toFlush.push(pending);
+        this.pendingCrops.delete(trackId);
+      }
+    }
+    await Promise.all(toFlush.map((p) => this.processOne(p)));
+  }
+  async processOne(pending) {
+    if (this.encoders.length === 0) return;
+    try {
+      const { crop, width, height } = await extractCrop(
+        pending.frameData,
+        pending.frameWidth,
+        pending.frameHeight,
+        pending.bbox
+      );
+      const encoder = this.encoders[this._encoderIndex % this.encoders.length];
+      this._encoderIndex++;
+      const { embedding: _embedding, inferenceMs } = await encoder.encode(crop, width, height);
+      const info = encoder.getInfo();
+      this._processedCount++;
+      this._totalInferenceMs += inferenceMs;
+      this.lastEmbedTime.set(pending.deviceId, Date.now());
+      this.pendingCrops.delete(pending.trackId);
+      const embeddingId = `${pending.deviceId}/${pending.trackId}/${Date.now()}`;
+      const payload = {
+        deviceId: Number(pending.deviceId),
+        trackId: pending.trackId,
+        class: pending.class,
+        embeddingId,
+        modelId: info.modelId,
+        embeddingDim: info.embeddingDim,
+        inferenceMs,
+        timestamp: Date.now()
+      };
+      this.eventBus.emit(createEvent(
+        EventCategory.EnrichmentEmbeddingStored,
+        { type: "addon", id: "enrichment-engine" },
+        payload
+      ));
+      this.logger.debug("Embedded track", {
+        tags: { deviceId: Number(pending.deviceId) },
+        meta: { class: pending.class, trackId: pending.trackId, inferenceMs: Number(inferenceMs.toFixed(1)) }
+      });
+    } catch (err) {
+      this.logger.warn("Failed to embed track", {
+        tags: { deviceId: Number(pending.deviceId) },
+        meta: { trackId: pending.trackId, error: String(err) }
+      });
+    }
+  }
+}
+const TrackPositionSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  timestamp: z.number(),
+  bbox: z.tuple([z.number(), z.number(), z.number(), z.number()])
+});
+const TrackSnapshotSchema = z.object({
+  timestamp: z.number(),
+  position: TrackPositionSchema,
+  thumbnailPath: z.string()
+});
+z.object({
+  trackId: z.string(),
+  deviceId: z.string(),
+  className: z.string(),
+  label: z.string().optional(),
+  firstSeen: z.number(),
+  lastSeen: z.number(),
+  positions: z.array(TrackPositionSchema),
+  snapshots: z.array(TrackSnapshotSchema),
+  totalDistance: z.number(),
+  zonesVisited: z.array(z.string()),
+  active: z.boolean()
+});
+const SceneMonitorConfigSchema = z.object({
+  monitors: z.array(z.object({
+    id: z.string(),
+    label: z.string(),
+    roi: z.object({ x: z.number(), y: z.number(), w: z.number(), h: z.number() }),
+    enabled: z.boolean(),
+    states: z.array(z.object({
+      id: z.string(),
+      label: z.string(),
+      prompt: z.string().optional(),
+      textPrompts: z.array(z.string()).optional(),
+      referenceEmbeddings: z.array(z.array(z.number())).optional(),
+      threshold: z.number().optional(),
+      notify: z.boolean().optional(),
+      severity: z.enum(["info", "warning", "alert"]).optional()
+    }))
+  }))
+});
+class TextEmbeddingCache {
+  cache = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, embedding) {
+    this.cache.set(key, embedding);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * Deletes all entries whose key starts with `${monitorId}:`.
+   * Used when a scene monitor's text prompts are updated.
+   */
+  invalidateMonitor(monitorId) {
+    const prefix = `${monitorId}:`;
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+class SceneStateWorker {
+  config;
+  encoders;
+  eventBus;
+  store;
+  streamBrokerRegistry;
+  logger;
+  textCache = new TextEmbeddingCache();
+  monitorStates = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  _activeCount = 0;
+  constructor(deps) {
+    this.config = deps.config;
+    this.encoders = deps.encoders;
+    this.eventBus = deps.eventBus;
+    this.store = deps.store;
+    this.streamBrokerRegistry = deps.streamBrokerRegistry;
+    this.logger = deps.logger;
+  }
+  async start() {
+    if (!this.config.enabled) {
+      this.logger.info("SceneStateWorker disabled");
+      return;
+    }
+    this.pollTimer = setInterval(
+      () => {
+        void this.pollAll();
+      },
+      this.config.pollIntervalSec * 1e3
+    );
+    this.logger.info("SceneStateWorker started", { meta: { pollIntervalSec: this.config.pollIntervalSec, hysteresis: this.config.hysteresisCount } });
+  }
+  async stop() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  get activeCount() {
+    return this._activeCount;
+  }
+  async pollAll() {
+    const rawConfigs = await this.store.query.query({ collection: "device-settings", filter: {
+      where: { id: "enrichment:scene-monitor:%" }
+    } });
+    const allConfigs = rawConfigs.map((r) => ({ id: r.id, data: SceneMonitorConfigSchema.parse(r.data) }));
+    const deviceMonitors = /* @__PURE__ */ new Map();
+    for (const record of allConfigs) {
+      const deviceId = record.id.replace("enrichment:scene-monitor:", "");
+      const config = record.data;
+      const active = config.monitors.filter((m) => m.enabled);
+      if (active.length > 0) {
+        deviceMonitors.set(deviceId, active);
+      }
+    }
+    this._activeCount = [...deviceMonitors.values()].reduce((sum, ms) => sum + ms.length, 0);
+    await Promise.all(
+      [...deviceMonitors.entries()].map(
+        ([deviceId, monitors]) => this.pollCamera(deviceId, monitors)
+      )
+    );
+  }
+  async pollCamera(deviceId, monitors) {
+    if (this.encoders.length === 0) return;
+    try {
+      const snapshot = await this.streamBrokerRegistry.getSnapshot(deviceId);
+      if (!snapshot) return;
+      const encoder = this.encoders[0];
+      for (const monitor of monitors) {
+        try {
+          await this.processMonitor(deviceId, monitor, snapshot, encoder);
+        } catch (err) {
+          this.logger.warn("SceneState error", { tags: { deviceId: Number(deviceId) }, meta: { monitorLabel: monitor.label, error: String(err) } });
+        }
+      }
+    } catch (err) {
+      this.logger.warn("Failed to capture snapshot", { tags: { deviceId: Number(deviceId) }, meta: { error: String(err) } });
+    }
+  }
+  async processMonitor(deviceId, monitor, snapshot, encoder) {
+    const bbox = {
+      x: monitor.roi.x * snapshot.width,
+      y: monitor.roi.y * snapshot.height,
+      w: monitor.roi.w * snapshot.width,
+      h: monitor.roi.h * snapshot.height
+    };
+    const { crop, width, height } = await extractCrop(snapshot.data, snapshot.width, snapshot.height, bbox);
+    const { embedding: imageEmb } = await encoder.encode(crop, width, height);
+    let bestState = null;
+    let bestScore = -1;
+    for (const state of monitor.states) {
+      let score = 0;
+      if (state.referenceEmbeddings && state.referenceEmbeddings.length > 0) {
+        for (const refEmb of state.referenceEmbeddings) {
+          const ref = new Float32Array(refEmb);
+          const sim = cosineSimilarity(imageEmb, ref);
+          score = Math.max(score, sim);
+        }
+      } else if (state.textPrompts && state.textPrompts.length > 0) {
+        for (const prompt of state.textPrompts) {
+          const cacheKey = `${monitor.id}:${state.id}:${prompt}`;
+          let textEmb = this.textCache.get(cacheKey);
+          if (!textEmb) {
+            const result = await encoder.encodeText(prompt);
+            textEmb = result.embedding;
+            this.textCache.set(cacheKey, textEmb);
+          }
+          const sim = cosineSimilarity(imageEmb, textEmb);
+          score = Math.max(score, sim);
+        }
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestState = state.label;
+      }
+    }
+    if (!bestState) return;
+    const key = `${deviceId}:${monitor.id}`;
+    let ms = this.monitorStates.get(key);
+    if (!ms) {
+      ms = { currentState: null, pendingState: null, pendingCount: 0, pendingConfidence: 0 };
+      this.monitorStates.set(key, ms);
+    }
+    if (bestState === ms.pendingState) {
+      ms.pendingCount++;
+      ms.pendingConfidence = bestScore;
+    } else {
+      ms.pendingState = bestState;
+      ms.pendingCount = 1;
+      ms.pendingConfidence = bestScore;
+    }
+    if (ms.pendingCount < this.config.hysteresisCount) return;
+    if (bestState === ms.currentState) return;
+    const previousState = ms.currentState ?? "unknown";
+    ms.currentState = bestState;
+    ms.pendingState = null;
+    ms.pendingCount = 0;
+    const payload = {
+      deviceId: Number(deviceId),
+      monitorId: monitor.id,
+      monitorLabel: monitor.label,
+      previousState,
+      currentState: bestState,
+      confidence: bestScore,
+      timestamp: Date.now()
+    };
+    const data = { ...payload };
+    this.eventBus.emit({
+      id: `scene-state-${deviceId}-${monitor.id}-${Date.now()}`,
+      category: EventCategory.EnrichmentSceneStateChanged,
+      source: { type: "device", id: deviceId },
+      timestamp: /* @__PURE__ */ new Date(),
+      data
+    });
+    this.logger.info("Scene state changed", {
+      tags: { deviceId: Number(deviceId) },
+      meta: { monitorLabel: monitor.label, previousState, currentState: bestState, confidence: Number(bestScore.toFixed(2)) }
+    });
+  }
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+class ActivitySummaryWorker {
+  config;
+  eventBus;
+  store;
+  logger;
+  buffers = /* @__PURE__ */ new Map();
+  summaryTimer = null;
+  unsubDetection = null;
+  unsubSceneState = null;
+  _lastSummary = null;
+  constructor(deps) {
+    this.config = deps.config;
+    this.eventBus = deps.eventBus;
+    this.store = deps.store;
+    this.logger = deps.logger;
+  }
+  async start() {
+    if (!this.config.enabled) {
+      this.logger.info("ActivitySummaryWorker disabled");
+      return;
+    }
+    this.unsubDetection = this.eventBus.subscribe(
+      { category: EventCategory.DetectionResult },
+      (event) => {
+        this.handleDetection(event);
+      }
+    );
+    this.unsubSceneState = this.eventBus.subscribe(
+      { category: EventCategory.EnrichmentSceneStateChanged },
+      (event) => {
+        this.handleSceneStateChange(event);
+      }
+    );
+    this.summaryTimer = setInterval(
+      () => {
+        void this.emitSummaries();
+      },
+      this.config.intervalSec * 1e3
+    );
+    this.logger.info("ActivitySummaryWorker started", { meta: { intervalSec: this.config.intervalSec } });
+  }
+  async stop() {
+    this.unsubDetection?.();
+    this.unsubSceneState?.();
+    if (this.summaryTimer) {
+      clearInterval(this.summaryTimer);
+      this.summaryTimer = null;
+    }
+    await this.emitSummaries();
+  }
+  get lastSummary() {
+    return this._lastSummary;
+  }
+  getBuffer(deviceId) {
+    let buf = this.buffers.get(deviceId);
+    if (!buf) {
+      buf = { tracks: /* @__PURE__ */ new Map(), zoneEvents: [], stateChanges: [] };
+      this.buffers.set(deviceId, buf);
+    }
+    return buf;
+  }
+  handleDetection(event) {
+    const deviceId = event.source.id !== void 0 ? String(event.source.id) : "";
+    if (!deviceId) return;
+    const results = event.data.analysisResults ?? [];
+    const buf = this.getBuffer(deviceId);
+    const now = Date.now();
+    for (const det of results) {
+      const detection = det.detection;
+      if (!detection) continue;
+      const trackId = detection.trackId ?? `unknown-${now}`;
+      const existing = buf.tracks.get(trackId);
+      if (existing) {
+        existing.lastSeen = now;
+      } else {
+        buf.tracks.set(trackId, {
+          class: detection.class,
+          deviceId,
+          firstSeen: now,
+          lastSeen: now,
+          zones: /* @__PURE__ */ new Set()
+        });
+      }
+      const zoneEvents = det.zoneEvents ?? [];
+      for (const ze of zoneEvents) {
+        const track = buf.tracks.get(trackId);
+        if (track) track.zones.add(ze.zoneId);
+        if (ze.type === "zone-enter" || ze.type === "zone-exit") {
+          buf.zoneEvents.push({
+            type: ze.type === "zone-enter" ? "enter" : "exit",
+            zoneId: ze.zoneId,
+            trackId,
+            timestamp: ze.timestamp ?? now
+          });
+        }
+      }
+    }
+  }
+  handleSceneStateChange(event) {
+    const deviceId = event.source.id !== void 0 ? String(event.source.id) : "";
+    if (!deviceId) return;
+    const data = event.data;
+    const buf = this.getBuffer(deviceId);
+    buf.stateChanges.push({
+      monitorId: data.monitorId,
+      from: data.previousState,
+      to: data.currentState,
+      timestamp: data.timestamp
+    });
+  }
+  async emitSummaries() {
+    const now = Date.now();
+    for (const [deviceId, buf] of this.buffers) {
+      if (buf.tracks.size === 0 && buf.zoneEvents.length === 0 && buf.stateChanges.length === 0) {
+        continue;
+      }
+      const objectCounts = {};
+      for (const track of buf.tracks.values()) {
+        objectCounts[track.class] = (objectCounts[track.class] ?? 0) + 1;
+      }
+      const zoneMap = /* @__PURE__ */ new Map();
+      for (const ze of buf.zoneEvents) {
+        let z2 = zoneMap.get(ze.zoneId);
+        if (!z2) {
+          z2 = { entries: 0, exits: 0, dwellTimes: [] };
+          zoneMap.set(ze.zoneId, z2);
+        }
+        if (ze.type === "enter") z2.entries++;
+        else z2.exits++;
+      }
+      const zoneActivity = [...zoneMap.entries()].map(([zoneId, z2]) => ({
+        zoneId,
+        entries: z2.entries,
+        exits: z2.exits,
+        avgDwellMs: z2.dwellTimes.length > 0 ? z2.dwellTimes.reduce((a, b) => a + b, 0) / z2.dwellTimes.length : 0
+      }));
+      const totalEvents = buf.tracks.size + buf.zoneEvents.length;
+      const eventsPerMin = totalEvents / (this.config.intervalSec / 60);
+      const activityLevel = eventsPerMin >= this.config.activityThresholds.high ? "high" : eventsPerMin >= this.config.activityThresholds.medium ? "medium" : eventsPerMin >= this.config.activityThresholds.low ? "low" : "none";
+      const summary = {
+        deviceId: Number(deviceId),
+        periodStart: now - this.config.intervalSec * 1e3,
+        periodEnd: now,
+        objectCounts,
+        zoneActivity,
+        stateChanges: [...buf.stateChanges],
+        activityLevel
+      };
+      this._lastSummary = summary;
+      this.eventBus.emit(createEvent(
+        EventCategory.EnrichmentActivitySummary,
+        { type: "device", id: deviceId },
+        summary
+      ));
+      try {
+        await this.store.insert.mutate({ collection: "addon-settings", record: {
+          id: `${deviceId}:${now}`,
+          data: { ...summary }
+        } });
+      } catch {
+      }
+      buf.tracks.clear();
+      buf.zoneEvents.length = 0;
+      buf.stateChanges.length = 0;
+    }
+  }
+}
+class EnrichmentEngineAddon extends BaseAddon {
+  embeddingDispatcher = null;
+  sceneStateWorker = null;
+  activitySummary = null;
+  currentFlags = {
+    embeddingEnabled: true,
+    sceneMonitorEnabled: true,
+    activitySummaryEnabled: true
+  };
+  constructor() {
+    super({});
+  }
+  async onInitialize() {
+    const config = await this.loadConfig();
+    const encoderCollection = this.capabilities?.getCollection?.("embedding-encoder") ?? [];
+    const streamBrokerRaw = this.capabilities?.get?.("stream-broker");
+    this.embeddingDispatcher = new EmbeddingDispatcher({
+      config: config.embedding,
+      encoders: encoderCollection,
+      eventBus: this.ctx.eventBus,
+      logger: this.ctx.logger.child("EmbeddingDispatcher")
+    });
+    this.sceneStateWorker = new SceneStateWorker({
+      config: config.sceneMonitor,
+      encoders: encoderCollection,
+      eventBus: this.ctx.eventBus,
+      store: this.ctx.api.settingsStore,
+      streamBrokerRegistry: streamBrokerRaw ?? { getSnapshot: async () => null },
+      logger: this.ctx.logger.child("SceneStateWorker")
+    });
+    this.activitySummary = new ActivitySummaryWorker({
+      config: config.activitySummary,
+      eventBus: this.ctx.eventBus,
+      store: this.ctx.api.settingsStore,
+      logger: this.ctx.logger.child("ActivitySummary")
+    });
+    this.currentFlags = {
+      embeddingEnabled: config.embedding.enabled,
+      sceneMonitorEnabled: config.sceneMonitor.enabled,
+      activitySummaryEnabled: config.activitySummary.enabled
+    };
+    await this.embeddingDispatcher.start();
+    await this.sceneStateWorker.start();
+    await this.activitySummary.start();
+    this.ctx.logger.info("Enrichment engine initialized with 3 workers");
+  }
+  async onShutdown() {
+    await this.embeddingDispatcher?.stop();
+    await this.sceneStateWorker?.stop();
+    await this.activitySummary?.stop();
+    this.embeddingDispatcher = null;
+    this.sceneStateWorker = null;
+    this.activitySummary = null;
+  }
+  // ── Three-level settings API (Phase 3) ─────────────────────────────
+  //
+  // Enrichment engine is post-detection infra. The three boolean toggle
+  // flags (embedding/scene/activity) live in `getGlobalSettings` until
+  // the dedicated post-detection UI exists. The underlying
+  // EnrichmentConfig blob (stored opaquely in 'addon-settings' →
+  // 'enrichment:global') is a separate concern — the flags below mirror
+  // the `.enabled` field of each worker's config.
+  globalSettingsSchema() {
+    return this.schema({
+      sections: [
+        {
+          id: "enrichment-engine-settings",
+          title: "Enrichment Engine",
+          columns: 2,
+          fields: [
+            {
+              type: "boolean",
+              key: "embeddingEnabled",
+              label: "Embedding Enabled",
+              description: "Compute face/object embeddings from detection crops.",
+              default: true
+            },
+            {
+              type: "boolean",
+              key: "sceneMonitorEnabled",
+              label: "Scene Monitor Enabled",
+              description: "Run periodic scene state capture for change detection.",
+              default: true
+            },
+            {
+              type: "boolean",
+              key: "activitySummaryEnabled",
+              label: "Activity Summary Enabled",
+              description: "Aggregate hourly activity summaries per camera.",
+              default: true
+            }
+          ]
+        }
+      ]
+    });
+  }
+  async updateGlobalSettings(patch) {
+    await this.ctx?.settings?.writeAddonStore(patch);
+    const prev = this.currentFlags;
+    const next = {
+      embeddingEnabled: typeof patch["embeddingEnabled"] === "boolean" ? patch["embeddingEnabled"] : prev.embeddingEnabled,
+      sceneMonitorEnabled: typeof patch["sceneMonitorEnabled"] === "boolean" ? patch["sceneMonitorEnabled"] : prev.sceneMonitorEnabled,
+      activitySummaryEnabled: typeof patch["activitySummaryEnabled"] === "boolean" ? patch["activitySummaryEnabled"] : prev.activitySummaryEnabled
+    };
+    this.currentFlags = next;
+    if (prev.embeddingEnabled && !next.embeddingEnabled) {
+      this.ctx?.logger.info("Stopping embedding dispatcher (disabled via config)");
+      await this.embeddingDispatcher?.stop();
+    } else if (!prev.embeddingEnabled && next.embeddingEnabled) {
+      this.ctx?.logger.info("Starting embedding dispatcher (enabled via config)");
+      await this.embeddingDispatcher?.start();
+    }
+    if (prev.sceneMonitorEnabled && !next.sceneMonitorEnabled) {
+      this.ctx?.logger.info("Stopping scene state worker (disabled via config)");
+      await this.sceneStateWorker?.stop();
+    } else if (!prev.sceneMonitorEnabled && next.sceneMonitorEnabled) {
+      this.ctx?.logger.info("Starting scene state worker (enabled via config)");
+      await this.sceneStateWorker?.start();
+    }
+    if (prev.activitySummaryEnabled && !next.activitySummaryEnabled) {
+      this.ctx?.logger.info("Stopping activity summary worker (disabled via config)");
+      await this.activitySummary?.stop();
+    } else if (!prev.activitySummaryEnabled && next.activitySummaryEnabled) {
+      this.ctx?.logger.info("Starting activity summary worker (enabled via config)");
+      await this.activitySummary?.start();
+    }
+    this.ctx?.logger.info("Enrichment engine flags updated", { meta: { flags: this.currentFlags } });
+  }
+  async loadConfig() {
+    try {
+      const stored = asJsonObject(await this.ctx.api?.settingsStore.get.query({ collection: "addon-settings", key: "enrichment:global" }));
+      if (stored) {
+        const merged = { ...DEFAULT_ENRICHMENT_CONFIG, ...stored };
+        return merged;
+      }
+    } catch {
+    }
+    return DEFAULT_ENRICHMENT_CONFIG;
+  }
+}
+export {
+  EnrichmentEngineAddon,
+  EnrichmentEngineAddon as default
+};
+//# sourceMappingURL=index.mjs.map