@camstack/addon-post-analysis 0.1.19 → 0.2.0

package/dist/enrichment-engine/index.mjs

@@ -1,841 +1,837 @@
-import { E as EventCategory, c as createEvent, o as object, t as tuple, n as number, s as string, b as boolean, a as array, _ as _enum, B as BaseAddon, d as asJsonObject } from "../index-BrTlzsrE.mjs";
+import { C as number, E as tuple, S as boolean, T as string, b as _enum, c as asJsonObject, d as createEvent, i as EventCategory, n as BaseAddon, w as object, x as array } from "../dist-4mTLJ7BJ.mjs";
+import { n as extractCrop, t as resolveFrame } from "../resolve-frame-CT1T1tWy.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
-import sharp from "sharp";
-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
-    }
-  }
+//#region src/enrichment-engine/types.ts
+var DEFAULT_ENRICHMENT_CONFIG = {
+	enabled: false,
+	embedding: {
+		enabled: false,
+		modelId: "clip-vit-b32",
+		agentId: "local",
+		runtime: "node",
+		backend: "cpu",
+		classes: [],
+		minConfidence: .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 };
-}
-async function resolveFrame(handle, deps) {
-  if (handle.nodeId === deps.ownNodeId) {
-    return deps.readers.read(handle);
-  }
-  return deps.getRemoteFrame(handle);
-}
-class EmbeddingDispatcher {
-  config;
-  encoders;
-  eventBus;
-  logger;
-  ownNodeId;
-  readers;
-  getRemoteFrame;
-  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;
-    this.ownNodeId = deps.ownNodeId;
-    this.readers = deps.readers;
-    this.getRemoteFrame = deps.getRemoteFrame;
-  }
-  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 handle = data.frameHandle;
-    if (!handle) {
-      this.logger.debug("skip: no frameHandle on DetectionResult", {
-        meta: { deviceId }
-      });
-      return;
-    }
-    let decoded;
-    try {
-      decoded = await resolveFrame(handle, {
-        ownNodeId: this.ownNodeId,
-        readers: this.readers,
-        getRemoteFrame: this.getRemoteFrame
-      });
-    } catch (err) {
-      this.logger.debug("skip: resolveFrame threw", {
-        meta: { deviceId, shmId: handle.shmId, error: String(err) }
-      });
-      return;
-    }
-    if (!decoded) {
-      this.logger.debug("skip: frame recycled before resolve", {
-        meta: { deviceId, shmId: handle.shmId }
-      });
-      return;
-    }
-    if (decoded.format !== "rgb") {
-      this.logger.debug("skip: resolved frame is not RGB", {
-        meta: { deviceId, format: decoded.format }
-      });
-      return;
-    }
-    const frameData = Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data);
-    const frameWidth = decoded.width;
-    const frameHeight = decoded.height;
-    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 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 = object({
-  x: number(),
-  y: number(),
-  timestamp: number(),
-  bbox: tuple([number(), number(), number(), number()])
+//#endregion
+//#region src/enrichment-engine/workers/embedding-dispatcher.ts
+var EmbeddingDispatcher = class {
+	config;
+	encoders;
+	eventBus;
+	logger;
+	ownNodeId;
+	readers;
+	getRemoteFrame;
+	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;
+		this.ownNodeId = deps.ownNodeId;
+		this.readers = deps.readers;
+		this.getRemoteFrame = deps.getRemoteFrame;
+	}
+	async start() {
+		if (!this.config.enabled) {
+			this.logger.info("EmbeddingDispatcher disabled");
+			return;
+		}
+		this.unsubscribe = this.eventBus.subscribe({ category: EventCategory.DetectionResult }, (event) => {
+			this.handleDetectionResult(event);
+		});
+		if (this.config.cropStrategy === "best-confidence") this.flushTimer = setInterval(() => {
+			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 handle = data.frameHandle;
+		if (!handle) {
+			this.logger.debug("skip: no frameHandle on DetectionResult", { meta: { deviceId } });
+			return;
+		}
+		let decoded;
+		try {
+			decoded = await resolveFrame(handle, {
+				ownNodeId: this.ownNodeId,
+				readers: this.readers,
+				getRemoteFrame: this.getRemoteFrame
+			});
+		} catch (err) {
+			this.logger.debug("skip: resolveFrame threw", { meta: {
+				deviceId,
+				shmId: handle.shmId,
+				error: String(err)
+			} });
+			return;
+		}
+		if (!decoded) {
+			this.logger.debug("skip: frame recycled before resolve", { meta: {
+				deviceId,
+				shmId: handle.shmId
+			} });
+			return;
+		}
+		if (decoded.format !== "rgb") {
+			this.logger.debug("skip: resolved frame is not RGB", { meta: {
+				deviceId,
+				format: decoded.format
+			} });
+			return;
+		}
+		const frameData = Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data);
+		const frameWidth = decoded.width;
+		const frameHeight = decoded.height;
+		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;
+			if (now - (this.lastEmbedTime.get(deviceId) ?? 0) < minInterval) continue;
+			const trackId = detection.trackId ?? `${deviceId}-${now}`;
+			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);
+						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":
+					if (det.objectState?.state === "leaving") {
+						this.pendingCrops.set(trackId, pending);
+						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)
+				}
+			});
+		}
+	}
+};
+//#endregion
+//#region src/_analytics-schemas/persistence-records.ts
+/**
+* Zod schemas for analytics-suite persisted record types.
+* Used by persistence services to parse settings-store query results.
+*/
+var TrackPositionSchema = object({
+	x: number(),
+	y: number(),
+	timestamp: number(),
+	bbox: tuple([
+		number(),
+		number(),
+		number(),
+		number()
+	])
 });
-const TrackSnapshotSchema = object({
-  timestamp: number(),
-  position: TrackPositionSchema,
-  thumbnailPath: string()
+var TrackSnapshotSchema = object({
+	timestamp: number(),
+	position: TrackPositionSchema,
+	thumbnailPath: string()
 });
 object({
-  trackId: string(),
-  deviceId: string(),
-  className: string(),
-  label: string().optional(),
-  firstSeen: number(),
-  lastSeen: number(),
-  positions: array(TrackPositionSchema),
-  snapshots: array(TrackSnapshotSchema),
-  totalDistance: number(),
-  zonesVisited: array(string()),
-  active: boolean()
-});
-const SceneMonitorConfigSchema = object({
-  monitors: array(object({
-    id: string(),
-    label: string(),
-    roi: object({ x: number(), y: number(), w: number(), h: number() }),
-    enabled: boolean(),
-    states: array(object({
-      id: string(),
-      label: string(),
-      prompt: string().optional(),
-      textPrompts: array(string()).optional(),
-      referenceEmbeddings: array(array(number())).optional(),
-      threshold: number().optional(),
-      notify: boolean().optional(),
-      severity: _enum(["info", "warning", "alert"]).optional()
-    }))
-  }))
+	trackId: string(),
+	deviceId: string(),
+	className: string(),
+	label: string().optional(),
+	firstSeen: number(),
+	lastSeen: number(),
+	positions: array(TrackPositionSchema),
+	snapshots: array(TrackSnapshotSchema),
+	totalDistance: number(),
+	zonesVisited: array(string()),
+	active: boolean()
 });
-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)) }
-    });
-  }
-}
+var SceneMonitorConfigSchema = object({ monitors: array(object({
+	id: string(),
+	label: string(),
+	roi: object({
+		x: number(),
+		y: number(),
+		w: number(),
+		h: number()
+	}),
+	enabled: boolean(),
+	states: array(object({
+		id: string(),
+		label: string(),
+		prompt: string().optional(),
+		textPrompts: array(string()).optional(),
+		referenceEmbeddings: array(array(number())).optional(),
+		threshold: number().optional(),
+		notify: boolean().optional(),
+		severity: _enum([
+			"info",
+			"warning",
+			"alert"
+		]).optional()
+	}))
+})) });
+//#endregion
+//#region src/enrichment-engine/services/text-embedding-cache.ts
+/**
+* In-memory cache for text prompt embeddings.
+*
+* Keys follow the convention `${monitorId}:${text}` so that all entries
+* belonging to a specific scene monitor can be invalidated in one call.
+*/
+var TextEmbeddingCache = class {
+	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;
+	}
+};
+//#endregion
+//#region src/enrichment-engine/workers/scene-state-worker.ts
+var SceneStateWorker = class {
+	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(() => {
+			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 allConfigs = (await this.store.query.query({
+			collection: "device-settings",
+			filter: { where: { id: "enrichment:scene-monitor:%" } }
+		})).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 active = record.data.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 sim = cosineSimilarity(imageEmb, new Float32Array(refEmb));
+				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) {
+					textEmb = (await encoder.encodeText(prompt)).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 data = {
+			deviceId: Number(deviceId),
+			monitorId: monitor.id,
+			monitorLabel: monitor.label,
+			previousState,
+			currentState: bestState,
+			confidence: bestScore,
+			timestamp: Date.now()
+		};
+		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));
+	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 z = zoneMap.get(ze.zoneId);
-        if (!z) {
-          z = { entries: 0, exits: 0, dwellTimes: [] };
-          zoneMap.set(ze.zoneId, z);
-        }
-        if (ze.type === "enter") z.entries++;
-        else z.exits++;
-      }
-      const zoneActivity = [...zoneMap.entries()].map(([zoneId, z]) => ({
-        zoneId,
-        entries: z.entries,
-        exits: z.exits,
-        avgDwellMs: z.dwellTimes.length > 0 ? z.dwellTimes.reduce((a, b) => a + b, 0) / z.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;
-  /**
-   * Shared shm-ring reader cache for downstream frame access. Owned by the
-   * engine so the cached segments stay open across worker restarts and close
-   * exactly once on shutdown.
-   */
-  readers = 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");
-    const rawNodeId = this.ctx.kernel.localNodeId ?? this.ctx.id;
-    const ownNodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
-    this.readers = new FrameRingReaderCache(this.ctx.logger.child("shm-readers"));
-    const getRemoteFrame = async (handle) => {
-      const remote = await this.ctx.api.decoder.getFrame.query({ handle, nodeId: handle.nodeId });
-      if (!remote) return null;
-      return {
-        data: Buffer.from(remote.data),
-        width: remote.width,
-        height: remote.height,
-        format: remote.format,
-        timestamp: remote.timestamp
-      };
-    };
-    this.embeddingDispatcher = new EmbeddingDispatcher({
-      config: config.embedding,
-      encoders: encoderCollection,
-      eventBus: this.ctx.eventBus,
-      logger: this.ctx.logger.child("EmbeddingDispatcher"),
-      ownNodeId,
-      readers: this.readers,
-      getRemoteFrame
-    });
-    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;
-    this.readers?.close();
-    this.readers = 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
+//#endregion
+//#region src/enrichment-engine/workers/activity-summary.ts
+var ActivitySummaryWorker = class {
+	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(() => {
+			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;
+		this.getBuffer(deviceId).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 z = zoneMap.get(ze.zoneId);
+				if (!z) {
+					z = {
+						entries: 0,
+						exits: 0,
+						dwellTimes: []
+					};
+					zoneMap.set(ze.zoneId, z);
+				}
+				if (ze.type === "enter") z.entries++;
+				else z.exits++;
+			}
+			const zoneActivity = [...zoneMap.entries()].map(([zoneId, z]) => ({
+				zoneId,
+				entries: z.entries,
+				exits: z.exits,
+				avgDwellMs: z.dwellTimes.length > 0 ? z.dwellTimes.reduce((a, b) => a + b, 0) / z.dwellTimes.length : 0
+			}));
+			const eventsPerMin = (buf.tracks.size + buf.zoneEvents.length) / (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;
+		}
+	}
+};
+//#endregion
+//#region src/enrichment-engine/index.ts
+/**
+* Extended context shape injected at runtime by the server's capability wiring.
+* Not part of the base AddonContext interface because capabilities are resolved
+* after addon initialization.
+*/
+var EnrichmentEngineAddon = class extends BaseAddon {
+	embeddingDispatcher = null;
+	sceneStateWorker = null;
+	activitySummary = null;
+	/**
+	* Shared shm-ring reader cache for downstream frame access. Owned by the
+	* engine so the cached segments stay open across worker restarts and close
+	* exactly once on shutdown.
+	*/
+	readers = 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");
+		const rawNodeId = this.ctx.kernel.localNodeId ?? this.ctx.id;
+		const ownNodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
+		this.readers = new FrameRingReaderCache(this.ctx.logger.child("shm-readers"));
+		const getRemoteFrame = async (handle) => {
+			const remote = await this.ctx.api.decoder.getFrame.query({
+				handle,
+				nodeId: handle.nodeId
+			});
+			if (!remote) return null;
+			return {
+				data: Buffer.from(remote.data),
+				width: remote.width,
+				height: remote.height,
+				format: remote.format,
+				timestamp: remote.timestamp
+			};
+		};
+		this.embeddingDispatcher = new EmbeddingDispatcher({
+			config: config.embedding,
+			encoders: encoderCollection,
+			eventBus: this.ctx.eventBus,
+			logger: this.ctx.logger.child("EmbeddingDispatcher"),
+			ownNodeId,
+			readers: this.readers,
+			getRemoteFrame
+		});
+		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;
+		this.readers?.close();
+		this.readers = null;
+	}
+	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) return {
+				...DEFAULT_ENRICHMENT_CONFIG,
+				...stored
+			};
+		} catch {}
+		return DEFAULT_ENRICHMENT_CONFIG;
+	}
 };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { EnrichmentEngineAddon, EnrichmentEngineAddon as default };