@camera.ui/server 0.0.69 → 0.0.71-dev.0

package/dist/server/src/camera/decoder/event-manager.js

@@ -0,0 +1,674 @@
+import { randomUUID } from 'node:crypto';
+import { NamespaceManager } from '../../rpc/namespaces.js';
+import { boxIntersectsPolygon } from '../utils/filter.js';
+import { STATIONARY_SPEED_THRESHOLD } from './detection-coordinator.js';
+const UPDATE_THROTTLE_MS = 1000; // Minimum interval between throttled 'update' publishes (ms)
+const MIN_MOVING_SPEED = 0.05; // Minimum speed to consider an object as moving (normalized units/second)
+export class DetectionEventManager {
+    cameraId;
+    proxy;
+    logger;
+    activeEvent = null;
+    activeSegment = null;
+    segmentTimer = null;
+    segmentIndex = 0;
+    lastPublishTime = 0;
+    // Thumbnail accumulator — best candidate per segment, cleared on segment close
+    sceneThumbnail = null;
+    sceneThumbnailShipped = false;
+    detectionLabelThumbnails = new Map();
+    attributeThumbnails = new Map();
+    // Event-level thumbnail (full frame at event start). Captured once per event;
+    // stays through the event lifetime as the fallback shown until segments arrive.
+    eventThumbnail = null;
+    needsEventThumbnail = false;
+    // Track-based deduplication — maps parentTrackId → attribute index in active segment
+    segmentFaceTrackIds = new Map();
+    segmentPlateTrackIds = new Map();
+    segmentClassifierTrackIds = new Map(); // "trackId:attribute" → index
+    segmentClipTrackIds = new Set(); // "trackId:label"
+    eventSubject;
+    onEventEndCallback;
+    constructor(cameraId, proxy, logger) {
+        this.cameraId = cameraId;
+        this.proxy = proxy;
+        this.logger = logger;
+        const ns = NamespaceManager.detectionEventNamespaces(cameraId);
+        this.eventSubject = ns.detectionEventSubject;
+    }
+    onEventEnd(callback) {
+        this.onEventEndCallback = callback;
+    }
+    processResults(data) {
+        const now = data.timestamp;
+        const triggers = this.extractTriggers(data, now);
+        const hasDetections = this.hasNewDetections(data);
+        if (triggers.length === 0 && !this.activeEvent)
+            return;
+        if (!this.activeEvent) {
+            if (triggers.length === 0)
+                return;
+            this.startEvent(triggers, data, now);
+            return;
+        }
+        // Coordinator delivered the requested event-level thumbnail — store it and
+        // immediately publish an update so the UI gets the picture without waiting
+        // for the next throttled update.
+        if (data.eventThumbnail && this.needsEventThumbnail) {
+            this.eventThumbnail = data.eventThumbnail;
+            this.needsEventThumbnail = false;
+            this.publishEventThumbnail();
+        }
+        if (triggers.length > 0) {
+            this.enrichTriggers(triggers, now);
+            this.activeEvent.lastUpdate = now;
+            this.activeEvent.expectedEndTime = data.expectedEndTime;
+            // Throttled update so UI knows event is still alive (trigger bar grows).
+            // When a segment is active, segment-update already carries this info.
+            if (!this.activeSegment) {
+                this.publishUpdateThrottled();
+            }
+        }
+        if (hasDetections && data.hasCascadeTrigger) {
+            if (!this.activeSegment) {
+                this.openSegment(data, now);
+            }
+            else {
+                this.enrichSegment(data, now);
+                if (data.thumbnails && data.thumbnails.length > 0) {
+                    this.updateThumbnails(data.thumbnails);
+                }
+                this.activeEvent.lastUpdate = now;
+                this.updateTypes();
+                this.publishSegmentThrottled('segment-update');
+            }
+            this.resetSegmentTimer(data.segmentTimeout);
+        }
+    }
+    forceEndActiveEvent() {
+        if (this.activeEvent)
+            this.endEvent();
+    }
+    destroy() {
+        if (this.segmentTimer) {
+            clearTimeout(this.segmentTimer);
+            this.segmentTimer = null;
+        }
+        if (this.activeEvent)
+            this.endEvent();
+    }
+    publishEventThumbnail(jpeg) {
+        if (!this.activeEvent)
+            return;
+        if (jpeg) {
+            this.eventThumbnail = jpeg;
+            this.needsEventThumbnail = false;
+        }
+        if (!this.eventThumbnail)
+            return;
+        this.activeEvent.segments = [];
+        this.activeEvent.thumbnail = this.eventThumbnail;
+        this.publish('update');
+        this.activeEvent.thumbnail = undefined;
+    }
+    needsThumbnail() {
+        return this.needsEventThumbnail;
+    }
+    hasActiveEvent() {
+        return this.activeEvent !== null;
+    }
+    startEvent(triggers, data, now) {
+        this.activeEvent = {
+            id: randomUUID(),
+            cameraId: this.cameraId,
+            state: 'active',
+            startTime: now,
+            lastUpdate: now,
+            types: [],
+            triggers: [...triggers],
+            segments: [],
+            expectedEndTime: data.expectedEndTime,
+        };
+        this.segmentIndex = 0;
+        // Request a full-frame thumbnail from the coordinator on the next frame
+        // tick. If `data.eventThumbnail` is already populated (event triggered by
+        // a frame-driven path that pre-captured) consume it immediately.
+        this.needsEventThumbnail = true;
+        this.eventThumbnail = null;
+        if (data.eventThumbnail) {
+            this.eventThumbnail = data.eventThumbnail;
+            this.needsEventThumbnail = false;
+        }
+        this.updateTypes();
+        // If we already have a thumbnail (frame-driven path captured one for us in
+        // the same tick that started the event), include it inline in the start
+        // message so the UI gets it immediately. Otherwise the next processResults
+        // tick from the coordinator will deliver it via an 'update' message.
+        if (this.eventThumbnail) {
+            this.activeEvent.thumbnail = this.eventThumbnail;
+        }
+        this.publish('start');
+        if (this.activeEvent)
+            this.activeEvent.thumbnail = undefined;
+        const triggerTypes = [...new Set(triggers.map((t) => t.type))].join(',');
+        this.logger.log(`[event] start id=${this.activeEvent.id.slice(0, 8)} triggers=[${triggerTypes}] types=[${this.activeEvent.types.join(',')}]`);
+        if (this.hasNewDetections(data) && data.hasCascadeTrigger) {
+            this.openSegment(data, now);
+            this.resetSegmentTimer(data.segmentTimeout);
+        }
+    }
+    endEvent() {
+        if (!this.activeEvent)
+            return;
+        this.closeSegment();
+        this.activeEvent.state = 'ended';
+        this.activeEvent.endTime = Date.now();
+        this.activeEvent.lastUpdate = this.activeEvent.endTime;
+        this.activeEvent.segments = [];
+        this.eventThumbnail = null;
+        this.needsEventThumbnail = false;
+        this.publish('end');
+        const duration = this.activeEvent.endTime - this.activeEvent.startTime;
+        this.logger.log(`[event] end id=${this.activeEvent.id.slice(0, 8)} duration=${duration}ms segments=${this.segmentIndex} types=[${this.activeEvent.types.join(',')}]`);
+        this.activeEvent = null;
+        this.activeSegment = null;
+        if (this.segmentTimer) {
+            clearTimeout(this.segmentTimer);
+            this.segmentTimer = null;
+        }
+        if (this.onEventEndCallback) {
+            this.onEventEndCallback();
+        }
+    }
+    openSegment(data, now) {
+        if (!this.activeEvent)
+            return;
+        this.activeSegment = {
+            firstSeen: now,
+            lastSeen: now,
+            detections: [],
+            attributes: [],
+        };
+        this.enrichSegment(data, now);
+        if (data.thumbnails && data.thumbnails.length > 0) {
+            this.updateThumbnails(data.thumbnails);
+        }
+        this.activeEvent.lastUpdate = now;
+        this.updateTypes();
+        this.publishSegment('segment-start');
+    }
+    closeSegment() {
+        if (!this.activeSegment || !this.activeEvent)
+            return;
+        this.activeSegment.lastSeen = Date.now();
+        this.publishSegment('segment-end');
+        this.clearSegmentThumbnails();
+        this.segmentIndex++;
+        this.activeSegment = null;
+        if (this.segmentTimer) {
+            clearTimeout(this.segmentTimer);
+            this.segmentTimer = null;
+        }
+    }
+    enrichTriggers(triggers, now) {
+        if (!this.activeEvent)
+            return;
+        for (const incoming of triggers) {
+            const existing = this.activeEvent.triggers.find((t) => t.type === incoming.type && t.label === incoming.label);
+            if (existing) {
+                existing.lastSeen = now;
+                if (incoming.score !== undefined && (existing.score === undefined || incoming.score > existing.score)) {
+                    existing.score = incoming.score;
+                }
+            }
+            else {
+                this.activeEvent.triggers.push({ ...incoming });
+            }
+        }
+    }
+    enrichSegment(data, now) {
+        if (!this.activeSegment)
+            return;
+        this.activeSegment.lastSeen = now;
+        if (data.objects.length > 0) {
+            // Count objects per label in this frame — upsert by label, track best score/box/trackId and maxCount
+            const labelCounts = new Map();
+            for (const obj of data.objects) {
+                const t = obj;
+                const entry = labelCounts.get(obj.label);
+                if (entry) {
+                    entry.count++;
+                    if (obj.confidence > entry.bestScore) {
+                        entry.bestScore = obj.confidence;
+                        entry.bestBox = obj.box;
+                        entry.bestTrackId = t.trackId;
+                        entry.moving = t.trackSpeed !== undefined ? t.trackSpeed >= STATIONARY_SPEED_THRESHOLD : undefined;
+                    }
+                }
+                else {
+                    labelCounts.set(obj.label, {
+                        count: 1,
+                        bestScore: obj.confidence,
+                        bestBox: obj.box,
+                        bestTrackId: t.trackId,
+                        moving: t.trackSpeed !== undefined ? t.trackSpeed >= STATIONARY_SPEED_THRESHOLD : undefined,
+                    });
+                }
+            }
+            for (const [label, { count, bestScore, bestBox, bestTrackId, moving }] of labelCounts) {
+                const existing = this.activeSegment.detections.find((d) => d.label === label);
+                if (existing) {
+                    if (bestScore > existing.score) {
+                        existing.score = bestScore;
+                        existing.box = bestBox;
+                        existing.trackId = bestTrackId;
+                        existing.moving = moving;
+                    }
+                    if (count > existing.maxCount)
+                        existing.maxCount = count;
+                }
+                else {
+                    this.activeSegment.detections.push({ label, score: bestScore, maxCount: count, box: bestBox, trackId: bestTrackId, moving });
+                }
+            }
+            // Track which detection zones any object box overlapped during this segment.
+            // Boxes are normalized 0–1, polygons are pre-normalized to the same space.
+            if (data.detectionZones && data.detectionZones.length > 0) {
+                const zonesSet = new Set(this.activeSegment.zones ?? []);
+                for (const obj of data.objects) {
+                    for (const zone of data.detectionZones) {
+                        if (zonesSet.has(zone.name))
+                            continue;
+                        if (boxIntersectsPolygon(obj.box, zone.points)) {
+                            zonesSet.add(zone.name);
+                        }
+                    }
+                }
+                if (zonesSet.size > 0) {
+                    this.activeSegment.zones = [...zonesSet];
+                }
+            }
+        }
+        for (const face of data.faces) {
+            if (face.identity) {
+                if (!this.activeSegment.attributes.some((a) => a.type === 'face' && a.label === face.identity)) {
+                    this.activeSegment.attributes.push({ type: 'face', label: face.identity, parentTrackId: face.parentTrackId });
+                }
+            }
+            else if (face.embedding?.length) {
+                // Deduplicate unknown faces by parent track ID — keep only the best per tracked object
+                if (face.parentTrackId !== undefined) {
+                    const existingIdx = this.segmentFaceTrackIds.get(face.parentTrackId);
+                    if (existingIdx !== undefined) {
+                        const existing = this.activeSegment.attributes[existingIdx];
+                        if (existing && face.confidence > (existing.confidence ?? 0)) {
+                            existing.confidence = face.confidence;
+                            existing.embedding = face.embedding;
+                            existing.embeddingModel = data.faceEmbeddingModel;
+                            existing.thumbnail = face.thumbnail;
+                        }
+                        continue;
+                    }
+                    this.segmentFaceTrackIds.set(face.parentTrackId, this.activeSegment.attributes.length);
+                }
+                this.activeSegment.attributes.push({
+                    type: 'face',
+                    label: 'unknown',
+                    confidence: face.confidence,
+                    embedding: face.embedding,
+                    embeddingModel: data.faceEmbeddingModel,
+                    thumbnail: face.thumbnail,
+                    parentTrackId: face.parentTrackId,
+                });
+            }
+        }
+        for (const plate of data.plates) {
+            if (!plate.plateText)
+                continue;
+            // Deduplicate by parentTrackId — same vehicle may get different OCR results across frames
+            if (plate.parentTrackId !== undefined) {
+                const existingIdx = this.segmentPlateTrackIds.get(plate.parentTrackId);
+                if (existingIdx !== undefined) {
+                    const existing = this.activeSegment.attributes[existingIdx];
+                    if (existing && plate.confidence > (existing.confidence ?? 0)) {
+                        existing.label = plate.plateText;
+                        existing.confidence = plate.confidence;
+                    }
+                    continue;
+                }
+                this.segmentPlateTrackIds.set(plate.parentTrackId, this.activeSegment.attributes.length);
+            }
+            else if (this.activeSegment.attributes.some((a) => a.type === 'license_plate' && a.label === plate.plateText)) {
+                continue;
+            }
+            this.activeSegment.attributes.push({ type: 'license_plate', label: plate.plateText, confidence: plate.confidence, parentTrackId: plate.parentTrackId });
+        }
+        for (const cls of data.classifiers) {
+            if (!cls.subAttribute)
+                continue;
+            // Deduplicate by parentTrackId — same object may get different classifications across frames
+            if (cls.parentTrackId !== undefined) {
+                const clsKey = `${cls.parentTrackId}:${cls.attribute}`;
+                const existingIdx = this.segmentClassifierTrackIds.get(clsKey);
+                if (existingIdx !== undefined) {
+                    const existing = this.activeSegment.attributes[existingIdx];
+                    if (existing && cls.confidence > (existing.confidence ?? 0)) {
+                        existing.label = cls.subAttribute;
+                        existing.confidence = cls.confidence;
+                    }
+                    continue;
+                }
+                this.segmentClassifierTrackIds.set(clsKey, this.activeSegment.attributes.length);
+            }
+            else if (this.activeSegment.attributes.some((a) => a.type === cls.attribute && a.label === cls.subAttribute)) {
+                continue;
+            }
+            this.activeSegment.attributes.push({ type: cls.attribute, label: cls.subAttribute, confidence: cls.confidence, parentTrackId: cls.parentTrackId });
+        }
+        for (const clip of data.clips) {
+            if (clip.embedding?.length) {
+                // Deduplicate CLIP embeddings by trackId + label
+                const clipKey = clip.parentTrackId !== undefined ? `${clip.parentTrackId}:${clip.label}` : clip.label;
+                if (this.segmentClipTrackIds.has(clipKey))
+                    continue;
+                this.segmentClipTrackIds.add(clipKey);
+                this.activeSegment.attributes.push({
+                    type: 'clip',
+                    label: clip.label,
+                    clipEmbedding: clip.embedding,
+                    clipEmbeddingModel: data.clipEmbeddingModel,
+                    parentTrackId: clip.parentTrackId,
+                });
+            }
+        }
+    }
+    extractTriggers(data, now) {
+        const triggers = [];
+        if (data.motion?.detected) {
+            triggers.push({ type: 'motion', firstSeen: now, lastSeen: now });
+        }
+        else if (data.cascadeTriggered && !data.motion && (!data.sensorTriggers || data.sensorTriggers.length === 0)) {
+            // External motion (backward compatible: no specific sensor trigger)
+            triggers.push({ type: 'motion', firstSeen: now, lastSeen: now });
+        }
+        if (data.audio?.detected) {
+            if (data.audio.detections.length > 0) {
+                for (const d of data.audio.detections) {
+                    triggers.push({ type: 'audio', label: d.attribute ?? d.label, score: d.confidence, firstSeen: now, lastSeen: now });
+                }
+            }
+            else {
+                triggers.push({ type: 'audio', firstSeen: now, lastSeen: now });
+            }
+        }
+        if (data.sensorTriggers && data.sensorTriggers.length > 0) {
+            for (const type of data.sensorTriggers) {
+                triggers.push({ type: type, firstSeen: now, lastSeen: now });
+            }
+        }
+        if (data.lineCrossings && data.lineCrossings.length > 0) {
+            for (const lc of data.lineCrossings) {
+                triggers.push({
+                    type: 'line-crossing',
+                    label: lc.label,
+                    score: lc.confidence,
+                    lineName: lc.lineName,
+                    crossingDirection: lc.direction,
+                    trackId: lc.trackId,
+                    firstSeen: now,
+                    lastSeen: now,
+                });
+            }
+        }
+        return triggers;
+    }
+    updateTypes() {
+        if (!this.activeEvent)
+            return;
+        const types = new Set();
+        for (const t of this.activeEvent.triggers)
+            types.add(t.type);
+        // activeEvent.segments is only populated during publishSegment,
+        // so also include the current activeSegment for up-to-date types.
+        const segs = this.activeSegment ? [this.activeSegment] : this.activeEvent.segments;
+        for (const seg of segs) {
+            for (const d of seg.detections)
+                types.add(d.label);
+            for (const attr of seg.attributes)
+                types.add(attr.type);
+        }
+        this.activeEvent.types = [...types];
+    }
+    hasNewDetections(data) {
+        return data.objects.length > 0 || data.faces.length > 0 || data.plates.length > 0 || data.classifiers.length > 0;
+    }
+    resetSegmentTimer(timeoutSeconds) {
+        if (this.segmentTimer)
+            clearTimeout(this.segmentTimer);
+        this.segmentTimer = setTimeout(() => {
+            this.segmentTimer = null;
+            this.closeSegment();
+        }, timeoutSeconds * 1000);
+    }
+    updateThumbnails(thumbnails) {
+        for (const thumb of thumbnails) {
+            const label = thumb.label;
+            if (label.startsWith('face:') || label.startsWith('plate:') || label.startsWith('class:')) {
+                this.updateBestCandidate(this.attributeThumbnails, label, thumb);
+            }
+            else {
+                const hasAttr = thumbnails.some((t) => t.label.startsWith('face:') || t.label.startsWith('plate:') || t.label.startsWith('class:'));
+                const candidate = {
+                    jpeg: thumb.jpeg,
+                    score: thumb.score,
+                    area: thumb.area,
+                    onEdge: thumb.onEdge,
+                    hasAttribute: hasAttr,
+                    trackId: thumb.trackId,
+                    speed: thumb.speed,
+                };
+                if (!this.sceneThumbnail || this.isBetterScene(candidate, this.sceneThumbnail)) {
+                    this.sceneThumbnail = candidate;
+                }
+                this.updateBestCandidate(this.detectionLabelThumbnails, label, thumb);
+            }
+        }
+    }
+    updateBestCandidate(map, key, thumb) {
+        const current = map.get(key);
+        const candidate = {
+            jpeg: thumb.jpeg,
+            score: thumb.score,
+            area: thumb.area,
+            onEdge: thumb.onEdge,
+            hasAttribute: true,
+            trackId: thumb.trackId,
+            speed: thumb.speed,
+        };
+        if (!current) {
+            map.set(key, candidate);
+            return;
+        }
+        const cm = DetectionEventManager.isMoving(candidate);
+        const currM = DetectionEventManager.isMoving(current);
+        // Prefer moving objects over stationary
+        if (cm && !currM) {
+            this.logger.trace(`Thumbnail ${key}: prefer moving track#${candidate.trackId} (speed=${candidate.speed?.toFixed(4)}) over static track#${current.trackId}`);
+            map.set(key, candidate);
+            return;
+        }
+        if (!cm && currM)
+            return;
+        if (!candidate.onEdge && (candidate.area > current.area || candidate.score > current.score)) {
+            map.set(key, candidate);
+        }
+    }
+    isBetterScene(candidate, current) {
+        if (candidate.hasAttribute && !current.hasAttribute)
+            return true;
+        const cm = DetectionEventManager.isMoving(candidate);
+        const currM = DetectionEventManager.isMoving(current);
+        if (cm && !currM) {
+            this.logger.trace(`Scene thumbnail: prefer moving track#${candidate.trackId} (speed=${candidate.speed?.toFixed(4)}) over static track#${current.trackId}`);
+            return true;
+        }
+        if (!cm && currM)
+            return false;
+        if (candidate.onEdge && !current.onEdge)
+            return false;
+        if (candidate.score > current.score * 1.05)
+            return true;
+        if (candidate.area > current.area * 1.1)
+            return true;
+        return false;
+    }
+    static isMoving(c) {
+        return (c.speed ?? 0) >= MIN_MOVING_SPEED;
+    }
+    injectSegmentThumbnails() {
+        if (!this.activeSegment)
+            return;
+        if (this.sceneThumbnail) {
+            this.activeSegment.thumbnail = this.sceneThumbnail.jpeg;
+        }
+        for (const detection of this.activeSegment.detections) {
+            const detCand = this.detectionLabelThumbnails.get(detection.label);
+            if (detCand)
+                detection.thumbnail = detCand.jpeg;
+        }
+        for (const attr of this.activeSegment.attributes) {
+            // Skip attributes that already have a thumbnail (e.g. unknown faces set inline by enrichSegment)
+            if (attr.thumbnail)
+                continue;
+            const keys = [`face:${attr.label}`, `plate:${attr.label}`, `class:${attr.label}`];
+            const directKey = `${attr.type}:${attr.label}`;
+            if (!keys.includes(directKey))
+                keys.unshift(directKey);
+            for (const key of keys) {
+                const cand = this.attributeThumbnails.get(key);
+                if (cand) {
+                    attr.thumbnail = cand.jpeg;
+                    break;
+                }
+            }
+        }
+    }
+    stripSegmentThumbnails() {
+        if (!this.activeSegment)
+            return;
+        this.activeSegment.thumbnail = undefined;
+        for (const det of this.activeSegment.detections)
+            det.thumbnail = undefined;
+        for (const attr of this.activeSegment.attributes)
+            attr.thumbnail = undefined;
+    }
+    clearSegmentThumbnails() {
+        this.sceneThumbnail = null;
+        this.sceneThumbnailShipped = false;
+        this.detectionLabelThumbnails.clear();
+        this.attributeThumbnails.clear();
+        this.segmentFaceTrackIds.clear();
+        this.segmentPlateTrackIds.clear();
+        this.segmentClassifierTrackIds.clear();
+        this.segmentClipTrackIds.clear();
+    }
+    publish(type) {
+        if (!this.activeEvent)
+            return;
+        this.proxy.publish(this.eventSubject, { type, data: this.activeEvent });
+        this.lastPublishTime = Date.now();
+    }
+    publishSegment(type) {
+        if (!this.activeEvent || !this.activeSegment)
+            return;
+        this.activeEvent.segments = [this.activeSegment];
+        this.activeEvent.segmentIndex = this.segmentIndex;
+        this.logSegment(type);
+        if (type === 'segment-end') {
+            this.injectSegmentThumbnails();
+            this.publish(type);
+        }
+        else if (type === 'segment-start') {
+            this.injectSegmentThumbnails();
+            this.publish(type);
+            this.sceneThumbnailShipped = this.sceneThumbnail !== null;
+            this.stripSegmentThumbnails();
+        }
+        else if (!this.sceneThumbnailShipped && this.sceneThumbnail) {
+            this.activeSegment.thumbnail = this.sceneThumbnail.jpeg;
+            this.publish(type);
+            this.activeSegment.thumbnail = undefined;
+            this.sceneThumbnailShipped = true;
+        }
+        else {
+            this.publish(type);
+        }
+    }
+    publishSegmentThrottled(type) {
+        const now = Date.now();
+        if (now - this.lastPublishTime >= UPDATE_THROTTLE_MS) {
+            this.publishSegment(type);
+        }
+    }
+    publishUpdateThrottled() {
+        const now = Date.now();
+        if (now - this.lastPublishTime >= UPDATE_THROTTLE_MS) {
+            this.activeEvent.segments = [];
+            this.publish('update');
+        }
+    }
+    logSegment(type) {
+        if (!this.activeEvent || !this.activeSegment)
+            return;
+        const seg = this.activeSegment;
+        const parts = [`[event] ${type}`, `id=${this.activeEvent.id.slice(0, 8)}`, `seg=${this.segmentIndex}`];
+        if (type === 'segment-end') {
+            parts.push(`duration=${seg.lastSeen - seg.firstSeen}ms`);
+        }
+        // Detections: "person(0.92,x2) vehicle(0.78,x1)"
+        if (seg.detections.length > 0) {
+            const dets = seg.detections.map((d) => `${d.label}(${d.score.toFixed(2)},x${d.maxCount})`).join(' ');
+            parts.push(`det=[${dets}]`);
+        }
+        // Attributes summary: group by type
+        if (seg.attributes.length > 0) {
+            const groups = new Map();
+            for (const a of seg.attributes) {
+                const list = groups.get(a.type) ?? [];
+                let info = a.label;
+                if (a.confidence)
+                    info += `(${a.confidence.toFixed(2)})`;
+                if (a.type === 'face' && a.embedding?.length)
+                    info += '+emb';
+                if (a.type === 'face' && a.thumbnail)
+                    info += '+thumb';
+                if (a.type === 'clip' && a.clipEmbedding?.length)
+                    info += '+emb';
+                list.push(info);
+                groups.set(a.type, list);
+            }
+            const attr = [...groups.entries()].map(([t, items]) => `${t}:[${items.join(',')}]`).join(' ');
+            parts.push(`attr={${attr}}`);
+        }
+        // Tracker info from detections
+        const tracked = seg.detections.filter((d) => d.trackId !== undefined);
+        if (tracked.length > 0) {
+            const info = tracked
+                .map((d) => {
+                let s = `${d.label}#${d.trackId}`;
+                if (d.moving !== undefined)
+                    s += d.moving ? ',moving' : ',static';
+                return s;
+            })
+                .join(' ');
+            parts.push(`tracker=[${info}]`);
+        }
+        if (seg.zones?.length) {
+            parts.push(`zones=[${seg.zones.join(',')}]`);
+        }
+        const thumbCount = (this.sceneThumbnail ? 1 : 0) + this.detectionLabelThumbnails.size + this.attributeThumbnails.size;
+        parts.push(`thumbs=${thumbCount}`);
+        this.logger.debug(parts.join(' '));
+    }
+}
+//# sourceMappingURL=event-manager.js.map