@camstack/addon-post-analysis 1.1.26 → 1.1.28

package/dist/enrichment-engine/index.mjs

@@ -1,852 +0,0 @@
-import { C as number, E as tuple, S as boolean, T as string, _ as asJsonObject, b as _enum, g as EventCategory, m as BaseAddon, v as createEvent, w as object, x as array } from "../dist-DytVmDZg.mjs";
-import { n as extractCrop, t as resolveFrame } from "../resolve-frame-CT1T1tWy.mjs";
-import { FrameRingReaderCache } from "@camstack/shm-ring";
-//#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
-		}
-	}
-};
-//#endregion
-//#region src/enrichment-engine/workers/embedding-dispatcher.ts
-function selectCropBbox(detection) {
-	return detection.refinedBbox ?? detection.bbox;
-}
-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", {
-				tags: { deviceId: Number(deviceId) },
-				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", {
-				tags: { deviceId: Number(deviceId) },
-				meta: {
-					deviceId,
-					shmId: handle.shmId,
-					error: String(err)
-				}
-			});
-			return;
-		}
-		if (!decoded) {
-			this.logger.debug("skip: frame recycled before resolve", {
-				tags: { deviceId: Number(deviceId) },
-				meta: {
-					deviceId,
-					shmId: handle.shmId
-				}
-			});
-			return;
-		}
-		if (decoded.format !== "rgb") {
-			this.logger.debug("skip: resolved frame is not RGB", {
-				tags: { deviceId: Number(deviceId) },
-				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: selectCropBbox(detection),
-				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()
-	])
-});
-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()
-});
-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));
-}
-//#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 super.updateGlobalSettings(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;
-	}
-};
-//#endregion
-export { EnrichmentEngineAddon, EnrichmentEngineAddon as default };