@camera.ui/server 2.1.2 → 2.1.4

package/dist/server/src/camera/decoder/detection-coordinator.js

@@ -15,24 +15,35 @@ import { DETECTION_SENSOR_TYPES } from '../../sensors/types.js';
 import { normalizeZone } from '../utils/filter.js';
 import { AudioDetectionLoop } from './audio-loop.js';
 import { CascadeManager } from './cascade-manager.js';
+import { detectionRecord } from './debug/detection-record.js';
+import { PerfTracker } from './debug/perf-tracker.js';
 import { DetectionPipeline } from './detection-pipeline.js';
 import { DwellManager } from './dwell-manager.js';
-import { DetectionEventManager } from './event-manager.js';
+import { DetectionEventManager, MOMENT_RANK_ATTRIBUTE, MOMENT_RANK_OBJECT } from './event-manager.js';
 import { EventThumbnailer } from './event-thumbnailer.js';
 import { FrameScaler } from './frame-scaler.js';
+import { directionBetween, directionOf, MOMENT_FORMATS, MOMENT_QUALITY, momentWindow, unionBox } from './moment-crop.js';
+import { normalizePlateText } from './plate-vote.js';
 import { isVideoInputSpec, PluginRegistry } from './plugin-registry.js';
 import { PtzAutotracker } from './ptz/autotracker.js';
 import { ReconnectBackoff } from './reconnect-backoff.js';
 import { SecondaryStage } from './secondary-stage.js';
 import { FrameSource } from './sources/frame-source.js';
-import { StationarySuppressor } from './stationary-suppressor.js';
 import { DETECT_TIMEOUT_MS, ensureDetectionBoxes, MOTION_WIDTH_MAP } from './types.js';
+const MOMENT_EVENTS = new Set(['objectEntered', 'objectWoke', 'objectRecovered', 'bestShotUpdated']);
+const MOMENT_MOVING_SPEED = 0.05;
+const MOMENT_ATTRIBUTE_MIN_AREA = 600;
 const DEFAULT_CASCADE_TIMEOUT = 10;
 const OBJECT_DWELL_SECONDS = 2;
 const SECONDARY_BBOX_TTL_MS = 2000;
 const CADENCE_MIN_SAMPLES = 5;
 const CADENCE_OUTLIER_BAND = 2.5;
 const CADENCE_OUTLIER_RESEED = 5;
+const IDLE_TICK_MS = 200;
+const ACTIVE_TICK_MS = 100;
+const MOTION_INTERVAL_MS = 200;
+const TICK_SLACK_MS = 20;
+const MAIN_STREAM_HOLD_MS = 5000;
 let DetectionCoordinator = class DetectionCoordinator {
     config;
     proxy;
@@ -41,29 +52,38 @@ let DetectionCoordinator = class DetectionCoordinator {
     frameScaler;
     plugins = new PluginRegistry();
     pipeline;
-    stationary;
     secondaries;
     thumbnailer;
     audioLoop;
     ptzAutotracker;
     eventManager;
     cascade = new CascadeManager();
+    worldSpans = new Set();
+    activeSensorTriggerTypes = new Map();
+    secondaryBboxSeen = new Map();
+    faceIdentities = new Set();
+    platesSeen = new Set();
+    classifierLabels = new Map();
+    feedingSensors = new Map();
     dwell = new DwellManager();
     videoBackoff = new ReconnectBackoff();
+    // debugging
+    perf = new PerfTracker();
+    hqUpgrade;
+    mainStreamActive = false;
+    idleSince = 0;
+    lastMotionAt = 0;
     loopRunning = false;
     loopPromise;
     videoStopPromise;
     adHocVideoLoop = false;
     processingExternalSecondary = false;
-    cascadeUnsubscribe;
-    dwellUnsubscribe;
-    activeSensorTriggerTypes = new Map();
-    secondaryBboxSeen = new Map();
-    feedingSensors = new Set();
     lastObjectCallAt = 0;
     objectIntervalMs = 0;
     objectIntervalSamples = 0;
     objectIntervalOutliers = 0;
+    cascadeUnsubscribe;
+    dwellUnsubscribe;
     currentDetectionState = {};
     constructor(config, proxy, logger) {
         this.config = config;
@@ -72,7 +92,6 @@ let DetectionCoordinator = class DetectionCoordinator {
         const frameSourceConfig = {
             streamUrl: config.streamUrl,
             snapshotUrl: config.snapshotUrl,
-            fps: this.config.frameWorkerSettings.fps,
             decoder: this.config.frameWorkerSettings.decoder,
         };
         if (config.controllerSnapshotSourceId) {
@@ -88,13 +107,18 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.frameSource = new FrameSource(frameSourceConfig, logger);
         this.frameScaler = new FrameScaler(null, logger);
         this.pipeline = new DetectionPipeline(config.zones, config.detectionSettings);
-        this.stationary = new StationarySuppressor(logger);
         this.secondaries = new SecondaryStage(this, this.plugins, this.pipeline, this.frameScaler, this.proxy, logger);
         if (config.lines.length > 0) {
             this.pipeline.updateLines(config.lines, this.videoAspectRatio);
         }
         this.eventManager = new DetectionEventManager(config.cameraId, this.proxy, this.logger);
+        this.eventManager.updateNvrRpc(config.nvrRpc);
         this.eventManager.onEventEnd(() => this.handleEventEnded());
+        this.eventManager.onSegmentClosed(() => {
+            if (!this.dwell.hasActive() && this.worldSpans.size === 0) {
+                this.eventManager.forceEndActiveEvent();
+            }
+        });
         this.thumbnailer = new EventThumbnailer({
             frameSource: this.frameSource,
             frameScaler: this.frameScaler,
@@ -102,7 +126,19 @@ let DetectionCoordinator = class DetectionCoordinator {
             logger,
             decoder: this.config.frameWorkerSettings.decoder,
         }, config.availableSources);
-        this.thumbnailer.sync(this.config.frameWorkerSettings.hqSnapshots === true);
+        this.thumbnailer.sync(this.mainStreamAnalysisWanted);
+        // debugging
+        detectionRecord.sources({
+            roles: config.availableSources?.map((s) => s.role),
+            mainStreamAnalysis: this.config.frameWorkerSettings.mainStreamAnalysis === true,
+            hasMainStream: this.thumbnailer.hasMainStream,
+            cascade: this.cascadeEnabled,
+            cascadeTimeout: this.cascadeTimeoutSeconds,
+            motionTimeout: this.config.detectionSettings.motion.timeout,
+            audioTimeout: this.config.detectionSettings.audio.timeout,
+            suppressStatic: this.config.detectionSettings.object.suppressStatic ?? true,
+            motionResolution: this.motionResolution,
+        });
         this.audioLoop = new AudioDetectionLoop({
             cameraId: config.cameraId,
             getPlugin: () => this.plugins.get(SensorType.Audio),
@@ -120,11 +156,9 @@ let DetectionCoordinator = class DetectionCoordinator {
         });
         this.cascadeUnsubscribe = this.cascade.onChange((event) => {
             if (event.type === 'activated') {
-                this.pipeline.setReidHitCounterMax(this.cascadeTimeoutSeconds * this.targetFps);
                 this.startAdHocVideoLoopIfNeeded();
             }
             else {
-                this.pipeline.setReidHitCounterMax(0);
                 this.stopAdHocVideoLoopIfIdle();
                 this.handleCascadeDeactivated();
             }
@@ -146,7 +180,8 @@ let DetectionCoordinator = class DetectionCoordinator {
                     this.writeSensorProperties(event.sensorId, { detected: false, blocked: false });
                 }
                 this.activeSensorTriggerTypes.delete(event.sensorId);
-                if (!this.dwell.hasActive()) {
+                this.eventManager.processResults(this.buildSnapshot());
+                if (!this.dwell.hasActive() && this.worldSpans.size === 0 && !this.eventManager.hasActiveSegment()) {
                     this.eventManager.forceEndActiveEvent();
                 }
             }
@@ -176,7 +211,11 @@ let DetectionCoordinator = class DetectionCoordinator {
     }
     updateFrameWorkerSettings(settings) {
         this.config.frameWorkerSettings = settings;
-        this.thumbnailer.sync(settings.hqSnapshots === true);
+        this.thumbnailer.sync(this.mainStreamAnalysisWanted);
+    }
+    updateNvrRpc(namespace) {
+        this.config.nvrRpc = namespace;
+        this.eventManager.updateNvrRpc(namespace);
     }
     updateInterfaceSettings(settings) {
         this.config.interfaceSettings = settings;
@@ -196,12 +235,11 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.eventManager.destroy();
         this.adHocVideoLoop = false;
         this.frameScaler.dispose();
-        this.pipeline.cleanup();
         this.currentDetectionState = {};
     }
     async onSensorAdded(sensor) {
         if (DETECTION_SENSOR_TYPES.has(sensor.sensorType)) {
-            this.feedingSensors.add(sensor.sensorId);
+            this.feedingSensors.set(sensor.sensorId, sensor.sensorType);
         }
         if (DETECTION_SENSOR_TYPES.has(sensor.sensorType) && sensor.requiresFrames) {
             await this.registerDetectionPluginInternal(sensor);
@@ -215,8 +253,22 @@ let DetectionCoordinator = class DetectionCoordinator {
         }
     }
     async onSensorRemoved(sensorId) {
-        if (this.feedingSensors.delete(sensorId)) {
-            this.writeSensorProperties(sensorId, { detected: false, detections: [] });
+        this.classifierLabels.delete(sensorId);
+        const sensorType = this.feedingSensors.get(sensorId);
+        if (sensorType === SensorType.Face)
+            this.faceIdentities.clear();
+        if (sensorType === SensorType.LicensePlate)
+            this.platesSeen.clear();
+        if (sensorType !== undefined && this.feedingSensors.delete(sensorId)) {
+            // a sensor removed mid-segment misses the cascade-end clear, so the
+            // recognized lists must reset here or they survive the re-register
+            this.writeSensorProperties(sensorId, {
+                detected: false,
+                detections: [],
+                ...(sensorType === SensorType.Face ? { identities: [] } : {}),
+                ...(sensorType === SensorType.LicensePlate ? { plates: [] } : {}),
+                ...(sensorType === SensorType.Classifier ? { labels: [] } : {}),
+            });
         }
         await this.removeDetectionPluginBySensor(sensorId);
         this.ptzAutotracker.unbind(sensorId);
@@ -264,7 +316,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                         this.ingestAssistedObjects(sensorId, objects);
                         // processExternal only adapts the shape, external boxes get no real tracking
                         const objectDetections = this.pipeline.processExternal(objects.detections);
-                        await this.runSecondariesAndThumbnails(peeked.frame, objectDetections, results);
+                        await this.runSecondariesAndThumbnails({ frame: peeked.frame, scaler: this.frameScaler, isMainStream: false }, objectDetections, results);
                         this.ingestResultsForAllSecondaries(results);
                         const snapshot = this.buildSnapshot();
                         if (results.thumbnails && results.thumbnails.length > 0) {
@@ -288,7 +340,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                         // real boxes: crop the object like the frame pipeline, so face and
                         // plate secondaries run on the subject instead of the whole scene
                         const objectDetections = this.pipeline.processExternal(objects.detections);
-                        await this.runSecondariesAndThumbnails(fetched.frame, objectDetections, results);
+                        await this.runSecondariesAndThumbnails({ frame: fetched.frame, scaler: this.frameScaler, isMainStream: false }, objectDetections, results);
                         this.ingestResultsForAllSecondaries(results);
                         const snapshot = this.buildSnapshot();
                         if (results.thumbnails && results.thumbnails.length > 0) {
@@ -297,11 +349,9 @@ let DetectionCoordinator = class DetectionCoordinator {
                         this.eventManager.processResults(snapshot);
                     }
                     else {
-                        const objectDetections = this.pipeline.processExternal(objects.detections);
                         const sceneJpeg = await this.secondaries.detectFullFrame(fetched.frame, results);
                         try {
-                            // face/plate crops feed the segment attributes
-                            results.thumbnails = await this.secondaries.generateThumbnails(fetched.frame, this.frameScaler, false, objectDetections, results);
+                            results.thumbnails = await this.secondaries.generateThumbnails(fetched.frame, this.frameScaler, results);
                         }
                         catch (error) {
                             this.logger.error('Thumbnail generation error:', error);
@@ -356,7 +406,8 @@ let DetectionCoordinator = class DetectionCoordinator {
         }
         this.dwell.refresh(dwellKey, timeoutSeconds);
         if (action === 'activate' && this.cascadeEnabled) {
-            this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+            // trigger edges never repeat, the cascade covers the trigger's dwell
+            this.cascade.triggerMomentary(Math.max(timeoutSeconds, this.cascadeTimeoutSeconds));
         }
         this.eventManager.processResults(this.buildSnapshot());
         // no loop frame to encode from, fetch async (no-op if already captured)
@@ -377,6 +428,12 @@ let DetectionCoordinator = class DetectionCoordinator {
     hasPlugin(sensorType) {
         return this.plugins.has(sensorType);
     }
+    externalObjectSpanActive() {
+        const objectPlugin = this.plugins.get(SensorType.Object);
+        if (!objectPlugin || objectPlugin.requiresFrames)
+            return false;
+        return this.dwell.isActive(objectPlugin.sensorId);
+    }
     get cascadeEnabled() {
         return this.config.detectionSettings.cascadeDetection !== false;
     }
@@ -413,22 +470,26 @@ let DetectionCoordinator = class DetectionCoordinator {
         for (const plugin of this.plugins.getAll(SensorType.Classifier)) {
             clearTargets.push(plugin.sensorId);
         }
+        this.faceIdentities.clear();
+        this.platesSeen.clear();
+        this.classifierLabels.clear();
+        const faceSensorId = this.plugins.get(SensorType.Face)?.sensorId;
+        const plateSensorId = this.plugins.get(SensorType.LicensePlate)?.sensorId;
+        const classifierSensorIds = new Set(this.plugins.getAll(SensorType.Classifier).map((p) => p.sensorId));
         for (const sensorId of clearTargets) {
-            this.writeSensorProperties(sensorId, { detected: false, detections: [] });
+            this.writeSensorProperties(sensorId, {
+                detected: false,
+                detections: [],
+                ...(sensorId === faceSensorId ? { identities: [] } : {}),
+                ...(sensorId === plateSensorId ? { plates: [] } : {}),
+                ...(classifierSensorIds.has(sensorId) ? { labels: [] } : {}),
+            });
             this.secondaryBboxSeen.delete(sensorId);
         }
         // segment ends here, the event itself continues while motion is active
         this.eventManager.processResults(this.buildSnapshot());
     }
     handleEventEnded() {
-        if (this.config.detectionSettings.object.suppressStatic ?? true) {
-            this.stationary.retainAcrossEvent((trackIds) => this.pipeline.retainTracks(trackIds));
-        }
-        else {
-            this.pipeline.cleanup();
-            this.stationary.clear();
-        }
-        this.stationary.resetEventState();
         this.activeSensorTriggerTypes.clear();
         this.currentDetectionState = {};
     }
@@ -451,15 +512,16 @@ let DetectionCoordinator = class DetectionCoordinator {
         };
         this.proxy.publish(NamespaceManager.sensorCameraViewNamespaces(this.config.cameraId).sensorWriteSubject, msg);
     }
-    buildSnapshot() {
+    buildSnapshot(at = Date.now()) {
         const cs = this.currentDetectionState;
         return {
             hasCascadeTrigger: this.cascade.isActive,
+            hasOpenSpans: this.worldSpans.size > 0 || this.externalObjectSpanActive(),
             motion: cs.motion ? { detected: cs.motion.detected ?? false } : undefined,
             audio: cs.audio ? { detected: cs.audio.detected ?? false, detections: cs.audio.detections ?? [] } : undefined,
             cascadeTriggered: cs.cascadeTriggered,
             sensorTriggers: [...new Set(this.activeSensorTriggerTypes.values())],
-            objects: cs.object?.detected ? this.stationary.excludeSealed(cs.object.detections) : [],
+            objects: cs.object?.detected ? cs.object.detections : [],
             faces: cs.face?.detections ?? [],
             faceEmbeddingModel: cs.faceEmbeddingModel,
             plates: cs.licensePlate?.detections ?? [],
@@ -472,7 +534,7 @@ let DetectionCoordinator = class DetectionCoordinator {
             clipEmbeddingModel: cs.clipEmbeddingModel,
             thumbnails: undefined,
             lineCrossings: cs.lineCrossings,
-            timestamp: Date.now(),
+            timestamp: at,
             segmentTimeout: 10,
             expectedEndTime: this.dwell.maxExpiry(),
             detectionZones: this.getNormalizedDetectionZones(),
@@ -532,7 +594,6 @@ let DetectionCoordinator = class DetectionCoordinator {
             return properties;
         return { ...properties, detections: filtered, detected: filtered.length > 0 };
     }
-    // PTZ-suppression gating happens upstream, callers decide what gets in here
     ingestDetectionResult(sensorType, sensorId, properties, pluginId) {
         if (sensorType === SensorType.Audio) {
             properties = this.applyAudioConfidence(properties);
@@ -543,7 +604,12 @@ let DetectionCoordinator = class DetectionCoordinator {
             const motionTimeout = this.config.detectionSettings.motion.timeout;
             this.dwell.refresh(sensorId, motionTimeout);
             if (this.cascadeEnabled) {
-                this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+                // a frame-based motion sensor re-arms on every motion frame, so its
+                // short tail is fine; an external sensor fires one edge and goes
+                // quiet, that edge must arm the cascade for the whole belief window
+                const framePlugin = this.plugins.get(SensorType.Motion);
+                const frameBased = framePlugin?.requiresFrames === true && framePlugin.sensorId === sensorId;
+                this.cascade.triggerMomentary(frameBased ? this.cascadeTimeoutSeconds : Math.max(motionTimeout, this.cascadeTimeoutSeconds));
             }
         }
         else if (sensorType === SensorType.Audio && detected) {
@@ -557,7 +623,7 @@ let DetectionCoordinator = class DetectionCoordinator {
             // the dwell bridges single missed frames; anchored stationary tracks
             // don't refresh it, so parked objects can't hold events open
             const detections = properties.detections ?? [];
-            if (this.stationary.evaluate(detections)) {
+            if (detections.length > 0) {
                 this.dwell.refresh(sensorId, OBJECT_DWELL_SECONDS);
                 // a confirmed object re-arms the cascade like motion does: a time-based
                 // motion sensor (ONVIF cool-down) must not blind detection and split
@@ -574,7 +640,6 @@ let DetectionCoordinator = class DetectionCoordinator {
                     this.currentDetectionState.object.detected = false;
                     this.currentDetectionState.object.detections = [];
                 }
-                this.stationary.logSuppressedOnce(detections);
             }
         }
         // dwell owns detected/blocked/lastTriggered for these types, a no-detection
@@ -711,8 +776,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         for (const plugin of this.plugins.getAll(SensorType.Classifier)) {
             this.clearSecondaryBboxes(plugin.sensorId);
         }
-        // image-space anchors don't survive a camera move, they re-form after
-        this.stationary.dropForCameraMove();
+        this.pipeline.notifyCameraMove();
     }
     clearSecondaryBboxes(sensorId) {
         this.writeSensorProperties(sensorId, { detections: [] });
@@ -744,6 +808,9 @@ let DetectionCoordinator = class DetectionCoordinator {
         }
         this.logger.debug('Stopping video detection loop');
         this.loopRunning = false;
+        this.worldSpans.clear();
+        this.mainStreamActive = false;
+        this.idleSince = 0;
         const doStop = async () => {
             await this.frameSource.stop();
             await this.loopPromise;
@@ -776,27 +843,51 @@ let DetectionCoordinator = class DetectionCoordinator {
             try {
                 await this.frameSource.start();
                 this.frameScaler.updateHardwareContext(this.frameSource.hardwareContext);
+                // the hardware context exists only after start, re-evaluate the HQ session
+                this.thumbnailer.sync(this.mainStreamAnalysisWanted);
                 this.logger.debug('Stream connected, processing frames...');
                 this.videoBackoff.reset();
                 let frameCount = 0;
                 let lastFrameId = -1;
                 while (this.loopRunning) {
+                    const tickStart = Date.now();
                     const snap = await this.frameSource.nextFrame(lastFrameId);
                     if (!snap)
                         break; // source ended (stop or EOF)
                     lastFrameId = snap.id;
                     frameCount++;
+                    // motion always reads the low stream: switching its input resolution
+                    // would reset the background model on every transition
+                    const analysis = await this.acquireAnalysisFrame(snap.frame);
+                    // debugging
+                    detectionRecord.setFrame(analysis.isMainStream ? 'main' : 'low', analysis.frame.width, analysis.frame.height);
                     try {
-                        await this.processRawFrame(snap.frame);
+                        await this.processRawFrame(analysis, snap.frame);
                     }
                     finally {
                         try {
+                            if (this.hqUpgrade) {
+                                this.hqUpgrade.frame[Symbol.dispose]?.();
+                                this.hqUpgrade = undefined;
+                            }
+                            if (analysis.frame !== snap.frame)
+                                analysis.frame[Symbol.dispose]?.();
                             snap.frame[Symbol.dispose]?.();
                         }
                         catch {
                             // best-effort
                         }
                     }
+                    this.updateStreamState();
+                    if (this.mainStreamActive)
+                        this.perf.activeTicks++;
+                    else
+                        this.perf.idleTicks++;
+                    this.perf.report(this.logger);
+                    const remaining = (this.mainStreamActive ? ACTIVE_TICK_MS : IDLE_TICK_MS) - (Date.now() - tickStart);
+                    if (remaining > 0)
+                        await sleep(remaining);
+                    this.perf.loopMs += Date.now() - tickStart;
                 }
                 const streamError = this.frameSource.lastError;
                 await this.frameSource.stop();
@@ -825,25 +916,85 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.frameScaler.clearCache();
         this.logger.debug('Detection loop ended');
     }
-    async processRawFrame(rawFrame) {
+    get mainStreamAvailable() {
+        if (!this.thumbnailer.hasMainStream)
+            return false;
+        return this.mainStreamAnalysisWanted;
+    }
+    get mainStreamAnalysisWanted() {
+        return this.config.frameWorkerSettings.mainStreamAnalysis === true || this.frameSource.hardwareContext !== null;
+    }
+    async acquireAnalysisFrame(lowFrame) {
+        if (this.mainStreamActive) {
+            const t0 = Date.now();
+            try {
+                const main = await this.thumbnailer.acquireHqFrame(0);
+                if (main) {
+                    this.perf.mainFrames++;
+                    this.perf.decodeMs += Date.now() - t0;
+                    return { frame: main.frame, scaler: main.scaler, isMainStream: true };
+                }
+            }
+            catch (error) {
+                this.logger.debug('Main stream frame unavailable:', error);
+            }
+        }
+        return { frame: lowFrame, scaler: this.frameScaler, isMainStream: false };
+    }
+    async acquireOpeningHqFrame() {
+        if (!this.mainStreamAvailable)
+            return undefined;
+        const t0 = Date.now();
+        try {
+            const main = await this.thumbnailer.acquireHqFrame(0);
+            if (main) {
+                this.perf.mainFrames++;
+                this.perf.decodeMs += Date.now() - t0;
+                return { frame: main.frame, scaler: main.scaler, isMainStream: true };
+            }
+        }
+        catch (error) {
+            this.logger.debug('HQ frame unavailable for the opening tick:', error);
+        }
+        return undefined;
+    }
+    updateStreamState() {
+        if (this.worldSpans.size > 0 || this.eventManager.hasActiveSegment()) {
+            this.idleSince = 0;
+            if (!this.mainStreamActive && this.mainStreamAvailable) {
+                this.mainStreamActive = true;
+                this.perf.switches++;
+                this.logger.debug('Analysis switched to the main stream');
+            }
+            return;
+        }
+        if (!this.mainStreamActive)
+            return;
+        if (this.idleSince === 0) {
+            this.idleSince = Date.now();
+        }
+        else if (Date.now() - this.idleSince >= MAIN_STREAM_HOLD_MS) {
+            this.mainStreamActive = false;
+            this.idleSince = 0;
+            this.perf.switches++;
+            this.logger.debug('Analysis back on the low-resolution stream');
+        }
+    }
+    async processRawFrame(analysis, motionRawFrame) {
         if (!this.loopRunning || !this.plugins.hasAny())
             return;
         try {
-            await this.processDetection(rawFrame);
+            await this.processDetection(analysis, motionRawFrame);
         }
         catch (error) {
             this.logger.error('Detection processing error:', error);
         }
     }
-    async processDetection(rawFrame) {
+    async processDetection(analysis, motionRawFrame) {
         const t0 = Date.now();
         let motionDetected = false;
         let objectDetections = [];
         const results = { timestamp: t0 };
-        // keeps dead tracks from expiring during the cascade window
-        if (this.cascade.isActive) {
-            this.pipeline.refreshReid();
-        }
         // while the PTZ repositions: motion and object keep running so the
         // background model and track ids survive the pan, but nothing below
         // reaches dwell/events until the settle window ends
@@ -852,12 +1003,20 @@ let DetectionCoordinator = class DetectionCoordinator {
         // object detection, not motion
         const motionPlugin = this.plugins.get(SensorType.Motion);
         if (motionPlugin?.requiresFrames) {
-            const motionFrame = await this.scaleForMotion(rawFrame);
+            // motion keeps its own rate, a background diff gains nothing from the active tick speed
+            const motionDue = t0 - this.lastMotionAt >= MOTION_INTERVAL_MS - TICK_SLACK_MS;
+            const motionScaleStart = Date.now();
+            const motionFrame = motionDue ? await this.scaleForMotion(motionRawFrame) : undefined;
+            if (motionDue)
+                this.perf.scaleMs += Date.now() - motionScaleStart;
             if (!this.loopRunning)
                 return;
             if (motionFrame) {
+                this.lastMotionAt = t0;
                 try {
+                    const motionInferStart = Date.now();
                     const result = await motionPlugin.proxy.detectMotion(motionFrame);
+                    this.perf.inferMs += Date.now() - motionInferStart;
                     if (!this.loopRunning)
                         return;
                     if (ptzSuppressed) {
@@ -899,12 +1058,16 @@ let DetectionCoordinator = class DetectionCoordinator {
         const objectPlugin = this.plugins.get(SensorType.Object);
         const shouldDetectObjects = objectPlugin?.requiresFrames === true && (ptzSuppressed || !this.cascadeEnabled || this.cascade.isActive);
         if (shouldDetectObjects) {
-            const objectFrame = await this.scaleForObject(rawFrame);
+            const scaleStart = Date.now();
+            const objectFrame = await this.scaleForObject(analysis.frame, analysis.scaler);
+            this.perf.scaleMs += Date.now() - scaleStart;
             if (!this.loopRunning)
                 return;
             if (objectFrame) {
                 try {
+                    const inferStart = Date.now();
                     const result = await PromiseTimeout(objectPlugin.proxy.detectObjects(objectFrame.model), DETECT_TIMEOUT_MS, undefined, `Object detection timed out after ${DETECT_TIMEOUT_MS}ms`);
+                    this.perf.inferMs += Date.now() - inferStart;
                     if (!this.loopRunning)
                         return;
                     this.trackDetectionCadence();
@@ -912,14 +1075,26 @@ let DetectionCoordinator = class DetectionCoordinator {
                     // Kalman state; the pose delta keeps predictions stable across pans
                     const poseDelta = this.ptzAutotracker.consumePoseDelta();
                     const detected = FrameScaler.undoLetterbox(ensureDetectionBoxes(result.detections), objectFrame.geometry);
-                    const pipelineResult = this.pipeline.process(detected, objectFrame.tracking, poseDelta);
+                    const pipelineResult = this.pipeline.process(detected, poseDelta);
+                    // the tick that opens a span analysed the low stream (the switch lands
+                    // next tick), its picture work is worth a one-off HQ decode
+                    if (this.updateWorldSpans(pipelineResult) && !analysis.isMainStream) {
+                        this.hqUpgrade = await this.acquireOpeningHqFrame();
+                    }
+                    await this.captureMoments(pipelineResult, this.hqUpgrade ?? analysis, t0);
+                    // open spans and a lingering segment keep the cascade armed: the
+                    // world can only observe absence or a reappearance while it still
+                    // receives ticks
+                    if (this.cascadeEnabled && (this.worldSpans.size > 0 || this.eventManager.hasActiveSegment())) {
+                        this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+                    }
                     // track id churn is invisible in the event log without this
                     if (pipelineResult.created.length > 0 || pipelineResult.removed.length > 0) {
                         const born = pipelineResult.created.map((id) => {
                             const t = pipelineResult.tracked.find((d) => d.trackId === id);
                             return `${t?.label ?? 'unknown'}#${id}`;
                         });
-                        const died = pipelineResult.removed.map((id) => `#${id}${this.stationary.isAnchored(id) ? ' (anchored!)' : ''}`);
+                        const died = pipelineResult.removed.map((id) => `#${id}`);
                         this.logger.trace(`[tracker] ${born.length ? `born: ${born.join(', ')}` : ''}${born.length && died.length ? ' — ' : ''}${died.length ? `died: ${died.join(', ')}` : ''}`);
                     }
                     // extrapolated (Kalman-only) tracks smooth single-frame misses in
@@ -974,7 +1149,11 @@ let DetectionCoordinator = class DetectionCoordinator {
         if (!this.loopRunning)
             return;
         if (objectDetections.length > 0) {
-            await this.runSecondariesAndThumbnails(rawFrame, objectDetections, results);
+            const images = this.hqUpgrade ?? analysis;
+            await this.runSecondariesAndThumbnails(images, objectDetections, results);
+            if (!this.loopRunning)
+                return;
+            await this.captureAttributeMoment(results, images, t0);
         }
         if (!this.loopRunning)
             return;
@@ -984,7 +1163,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         // messages already carry them
         if (!this.loopRunning)
             return;
-        const snapshot = this.buildSnapshot();
+        const snapshot = this.buildSnapshot(t0);
         if (results.thumbnails && results.thumbnails.length > 0) {
             snapshot.thumbnails = results.thumbnails;
         }
@@ -994,7 +1173,9 @@ let DetectionCoordinator = class DetectionCoordinator {
         let hqThumbAttached = false;
         if (wantsEventThumb) {
             try {
-                const thumb = await this.thumbnailer.captureEventThumbnail(rawFrame);
+                const thumbStart = Date.now();
+                const thumb = await this.thumbnailer.captureEventThumbnail((this.hqUpgrade ?? analysis).frame);
+                this.perf.jpegMs += Date.now() - thumbStart;
                 if (thumb.jpeg)
                     snapshot.eventThumbnail = thumb.jpeg;
                 hqThumbAttached = thumb.fromHq;
@@ -1004,25 +1185,29 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         }
         this.eventManager.processResults(snapshot);
+        // spans can outlive every trigger dwell (gate case); once spans, dwells
+        // and the segment linger are all quiet the event ends here
+        if (this.worldSpans.size === 0 && !this.dwell.hasActive() && !this.eventManager.hasActiveSegment()) {
+            this.eventManager.forceEndActiveEvent();
+        }
         // covers the window where the HQ source wasn't ready at event start
         if (wantsEventThumb && !hqThumbAttached) {
             this.thumbnailer.upgradeEventThumbnailAsync();
         }
     }
-    async runSecondariesAndThumbnails(rawFrame, objectDetections, results) {
-        objectDetections = this.stationary.excludeSealed(objectDetections);
+    async runSecondariesAndThumbnails(analysis, objectDetections, results) {
         if (objectDetections.length === 0)
             return;
-        await this.secondaries.detect(rawFrame, objectDetections, results);
+        this.perf.objects += objectDetections.length;
+        const secondaryStart = Date.now();
+        await this.secondaries.detect(analysis.frame, analysis.scaler, objectDetections, results);
+        this.perf.secondaryMs += Date.now() - secondaryStart;
         try {
-            // detectors ran on the substream frame, thumbnails prefer the HQ frame
-            const hq = await this.thumbnailer.acquireHqFrame({ width: rawFrame.width, height: rawFrame.height });
-            try {
-                results.thumbnails = await this.secondaries.generateThumbnails(hq?.frame ?? rawFrame, hq?.scaler ?? this.frameScaler, hq !== null, objectDetections, results);
-            }
-            finally {
-                hq?.frame[Symbol.dispose]?.();
-            }
+            const jpegStart = Date.now();
+            results.thumbnails = await this.secondaries.generateThumbnails(analysis.frame, analysis.scaler, results);
+            this.perf.jpegMs += Date.now() - jpegStart;
+            this.perf.faces += results.face?.detections?.length ?? 0;
+            this.perf.plates += results.licensePlate?.detections?.length ?? 0;
         }
         catch (error) {
             this.logger.error('Thumbnail generation error:', error);
@@ -1035,18 +1220,31 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
             const facePlugin = this.plugins.get(SensorType.Face);
             if (facePlugin) {
+                // no mid-segment clear: a turned-away head yields a no-face frame and
+                // would flap the list, departure is reflected when the segment ends
+                for (const detection of results.face.detections) {
+                    if (detection.identity)
+                        this.faceIdentities.add(detection.identity);
+                }
                 this.ingestDetectionResult(SensorType.Face, facePlugin.sensorId, {
                     detected: results.face.detected,
                     detections: results.face.detections,
+                    identities: [...this.faceIdentities].sort(),
                 });
             }
         }
         if (results.licensePlate) {
             const lpdPlugin = this.plugins.get(SensorType.LicensePlate);
             if (lpdPlugin) {
+                for (const detection of results.licensePlate.detections) {
+                    const plate = detection.plateText ? normalizePlateText(detection.plateText) || detection.plateText : '';
+                    if (plate)
+                        this.platesSeen.add(plate);
+                }
                 this.ingestDetectionResult(SensorType.LicensePlate, lpdPlugin.sensorId, {
                     detected: results.licensePlate.detected,
                     detections: results.licensePlate.detections,
+                    plates: [...this.platesSeen].sort(),
                 });
             }
         }
@@ -1054,9 +1252,21 @@ let DetectionCoordinator = class DetectionCoordinator {
             for (const [pluginId, classifierResult] of Object.entries(results.classifiers)) {
                 const plugin = this.plugins.getAll(SensorType.Classifier).find((p) => p.pluginId === pluginId);
                 if (plugin) {
+                    let seen = this.classifierLabels.get(plugin.sensorId);
+                    if (!seen) {
+                        seen = new Set();
+                        this.classifierLabels.set(plugin.sensorId, seen);
+                    }
+                    for (const detection of classifierResult.detections) {
+                        // the specific answer wins (subAttribute, e.g. the bird species)
+                        const label = detection.subAttribute || detection.attribute || detection.label;
+                        if (label)
+                            seen.add(label);
+                    }
                     this.ingestDetectionResult(SensorType.Classifier, plugin.sensorId, {
                         detected: classifierResult.detected,
                         detections: classifierResult.detections,
+                        labels: [...seen].sort(),
                     }, pluginId);
                 }
             }
@@ -1082,6 +1292,173 @@ let DetectionCoordinator = class DetectionCoordinator {
             return true;
         return false;
     }
+    updateWorldSpans(result) {
+        let opened = false;
+        const suppressStatic = this.config.detectionSettings.object.suppressStatic ?? true;
+        for (const event of result.events) {
+            const obj = event.object;
+            const recoveredRelevant = event.eventType === 'objectRecovered' && (obj.state !== 'stationary' || !suppressStatic);
+            if (event.eventType === 'objectEntered' || event.eventType === 'objectWoke' || recoveredRelevant) {
+                if (!this.worldSpans.has(obj.trackId))
+                    opened = true;
+                this.worldSpans.add(obj.trackId);
+            }
+            else if (event.eventType === 'objectDeparted' || event.eventType === 'objectLost' || (event.eventType === 'objectSettled' && suppressStatic)) {
+                this.worldSpans.delete(obj.trackId);
+            }
+        }
+        return opened;
+    }
+    async captureMoments(result, analysis, at) {
+        let subject;
+        let bestScore = -1;
+        let trigger = '';
+        for (const event of result.events) {
+            const obj = event.object;
+            // a moment is worth a picture when a span opens or the view got better;
+            // closing events report absence, there is nothing to show
+            if (!MOMENT_EVENTS.has(event.eventType))
+                continue;
+            // and only for a track that holds a span: a tentative first sighting or a
+            // stationary recovery opens nothing, so its picture is never handed over
+            if (!this.worldSpans.has(obj.trackId))
+                continue;
+            const score = obj.confidence * Math.sqrt(obj.width * obj.height);
+            if (score > bestScore) {
+                bestScore = score;
+                subject = obj;
+                trigger = event.eventType;
+            }
+        }
+        // one frame per tick, not one per object: they share the picture
+        if (!subject)
+            return;
+        if (!this.eventManager.wantsMoment(MOMENT_RANK_OBJECT, bestScore, analysis.isMainStream ? 'main' : 'low', at))
+            return;
+        await this.captureMoment(subject, bestScore, trigger, result.tracked, analysis, at);
+    }
+    async captureMoment(subject, score, trigger, tracked, analysis, at) {
+        const box = { x: subject.x, y: subject.y, width: subject.width, height: subject.height };
+        const moving = tracked.filter((d) => (d.trackSpeed ?? 0) >= MOMENT_MOVING_SPEED).map((d) => d.box);
+        const target = { subject: box, base: unionBox([box, ...moving]), hint: directionOf(subject.velocityX, subject.velocityY) };
+        const rendered = await this.renderMoment(target, analysis);
+        if (!rendered)
+            return;
+        const stream = analysis.isMainStream ? 'main' : 'low';
+        this.eventManager.offerMoment({ strip: rendered.strip, card: rendered.card, capturedAt: at, score, rank: MOMENT_RANK_OBJECT, stream });
+        // debugging
+        await this.recordMoment(target, rendered, analysis, `${subject.label}-${subject.trackId}`, score, trigger, at);
+    }
+    async captureAttributeMoment(results, analysis, at) {
+        const candidates = [];
+        // same rule as the object rank: only a span-holding subject hands over a
+        // picture. A face or plate riding on a settled bystander (the parked car
+        // at the kerb) must not anchor the segment of an unrelated event
+        const spanHolder = (parentTrackId) => parentTrackId !== undefined && this.worldSpans.has(parentTrackId);
+        for (const face of results.face?.detections ?? []) {
+            const f = face;
+            if (!spanHolder(f.parentTrackId))
+                continue;
+            candidates.push({ label: `face:${f.identity ?? 'unknown'}`, box: f.box, parentBox: f.parentBox, confidence: f.confidence });
+        }
+        for (const plate of results.licensePlate?.detections ?? []) {
+            const p = plate;
+            if (!p.plateText || !spanHolder(p.parentTrackId))
+                continue;
+            candidates.push({ label: `plate:${normalizePlateText(p.plateText)}`, box: p.box, parentBox: p.parentBox, confidence: p.confidence });
+        }
+        // one picture per tick, never one per subject: with several faces the most
+        // legible one frames the shot, the rest stay their own attribute tiles
+        let best;
+        let bestScore = -1;
+        let bestCard;
+        for (const candidate of candidates) {
+            const cut = results.thumbnails?.find((t) => t.label === candidate.label);
+            // a subject cut off by the frame edge makes a poor card
+            if (cut?.onEdge)
+                continue;
+            // a few-pixel face or plate carries no information even at the crop's max
+            // upscale: it stays an attribute tile, the anchor keeps the object shot
+            const areaPx = candidate.box.width * analysis.frame.width * candidate.box.height * analysis.frame.height;
+            if (areaPx < MOMENT_ATTRIBUTE_MIN_AREA)
+                continue;
+            const score = candidate.confidence * Math.sqrt(candidate.box.width * candidate.box.height);
+            if (score > bestScore) {
+                bestScore = score;
+                best = candidate;
+                bestCard = cut?.jpeg;
+            }
+        }
+        // ask before cutting: the same face rides along on every tick of a segment
+        // and re-encoding for a picture that loses anyway is pure cost
+        if (!best || !this.eventManager.wantsMoment(MOMENT_RANK_ATTRIBUTE, bestScore, analysis.isMainStream ? 'main' : 'low', at))
+            return;
+        const target = {
+            subject: best.box,
+            hint: best.parentBox ? directionBetween(best.box, best.parentBox) : undefined,
+        };
+        // the attribute tile was cut from this frame with this very target, so the
+        // card is already encoded; only the 16:9 companion is still missing
+        const rendered = await this.renderMoment(target, analysis, bestCard);
+        if (!rendered)
+            return;
+        const stream = analysis.isMainStream ? 'main' : 'low';
+        this.eventManager.offerMoment({ strip: rendered.strip, card: rendered.card, capturedAt: at, score: bestScore, rank: MOMENT_RANK_ATTRIBUTE, stream });
+        // debugging
+        await this.recordMoment(target, rendered, analysis, best.label.replace(':', '-'), bestScore, 'attributeFound', at);
+    }
+    async renderMoment(target, analysis, card) {
+        const start = Date.now();
+        const rendered = new Map();
+        const windows = {};
+        if (card)
+            rendered.set('card', card);
+        try {
+            for (const format of MOMENT_FORMATS) {
+                const window = momentWindow(target, analysis.frame.width, analysis.frame.height, format);
+                if (!window)
+                    continue;
+                windows[format.name] = window;
+                if (rendered.has(format.name))
+                    continue;
+                const jpeg = await analysis.scaler.cropWindowToJPEG(analysis.frame, window, format.width, format.height, MOMENT_QUALITY);
+                if (jpeg)
+                    rendered.set(format.name, jpeg);
+            }
+        }
+        catch (error) {
+            this.logger.debug('Moment crop failed:', error);
+        }
+        this.perf.jpegMs += Date.now() - start;
+        const strip = rendered.get('strip');
+        return strip ? { strip, card: rendered.get('card'), windows } : null;
+    }
+    // debugging
+    async recordMoment(target, rendered, analysis, subjectName, score, trigger, at) {
+        if (!detectionRecord.active)
+            return;
+        const stream = analysis.isMainStream ? 'main' : 'low';
+        const detail = `${subjectName}_${stream}_s${score.toFixed(3)}`;
+        try {
+            const frameJpeg = await analysis.scaler.frameToJPEG(analysis.frame, analysis.frame.width, 85);
+            detectionRecord.moment({
+                at,
+                trigger,
+                score,
+                subject: target.subject,
+                base: target.base,
+                windows: rendered.windows,
+                pictures: {
+                    strip: detectionRecord.picture(at, 'moment', `strip_${detail}`, rendered.strip),
+                    card: rendered.card ? detectionRecord.picture(at, 'moment', `card_${detail}`, rendered.card) : undefined,
+                },
+                frame: frameJpeg ? detectionRecord.picture(at, 'frame', detail, frameJpeg) : undefined,
+            });
+        }
+        catch (error) {
+            this.logger.debug('Moment record failed:', error);
+        }
+    }
     async scaleForMotion(rawFrame) {
         const motionPlugin = this.plugins.get(SensorType.Motion);
         if (!motionPlugin?.requiresFrames)
@@ -1116,24 +1493,23 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.objectIntervalSamples++;
         if (this.objectIntervalSamples < CADENCE_MIN_SAMPLES)
             return;
-        this.pipeline.syncDetectionCadence(this.objectIntervalMs);
     }
-    async scaleForObject(rawFrame) {
+    async scaleForObject(rawFrame, scaler) {
         const objectPlugin = this.plugins.get(SensorType.Object);
         if (!objectPlugin?.requiresFrames)
             return undefined;
-        return this.scaleFrameForPlugin(rawFrame, objectPlugin);
+        return this.scaleFrameForPlugin(rawFrame, objectPlugin, scaler);
     }
-    async scaleFrameForPlugin(rawFrame, plugin) {
+    async scaleFrameForPlugin(rawFrame, plugin, scaler = this.frameScaler) {
         const inputSpec = plugin.modelSpec?.input;
         if (!isVideoInputSpec(inputSpec))
             return undefined;
-        const letterboxed = await this.frameScaler.letterboxToSpec(rawFrame, inputSpec);
+        const letterboxed = await scaler.letterboxToSpec(rawFrame, inputSpec);
         if (!letterboxed)
             return undefined;
         return {
-            model: this.frameScaler.toVideoFrameData(letterboxed.padded, 'model'),
-            tracking: this.frameScaler.toVideoFrameData(letterboxed.inner, 'tracking'),
+            model: scaler.toVideoFrameData(letterboxed.padded, 'model'),
+            tracking: scaler.toVideoFrameData(letterboxed.inner, 'tracking'),
             geometry: letterboxed.geometry,
         };
     }