@camera.ui/server 2.1.7 → 2.1.9

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

@@ -12,7 +12,9 @@ import { isNoRespondersError, RPCClass, RPCMethod } from '@camera.ui/rpc';
 import { SensorType } from '@camera.ui/sdk';
 import { NamespaceManager } from '../../rpc/namespaces.js';
 import { DETECTION_SENSOR_TYPES } from '../../sensors/types.js';
-import { normalizePolygon, normalizeZone } from '../utils/filter.js';
+import { PrivacyMask } from '../privacy/mask.js';
+import { normalizePolygon } from '../utils/filter.js';
+import { normalizeZones } from '../zones.js';
 import { AudioDetectionLoop } from './audio-loop.js';
 import { CascadeManager } from './cascade-manager.js';
 import { detectionRecord } from './debug/detection-record.js';
@@ -24,12 +26,12 @@ import { FrameScaler } from './frame-scaler.js';
 import { directionBetween, directionOf, MOMENT_FORMATS, MOMENT_QUALITY, momentWindow, unionBox } from './moment-crop.js';
 import { PerfTracker } from './perf-tracker.js';
 import { normalizePlateText } from './plate-vote.js';
-import { isVideoInputSpec, PluginRegistry } from './plugin-registry.js';
+import { isVideoInputSpec, modelIdentity, PluginRegistry } from './plugin-registry.js';
 import { PtzAutotracker } from './ptz/autotracker.js';
-import { ReconnectBackoff } from './reconnect-backoff.js';
 import { SecondaryStage } from './secondary-stage.js';
+import { BufferedSource } from './sources/buffered-source.js';
 import { FrameSource } from './sources/frame-source.js';
-import { DETECT_TIMEOUT_MS, ensureDetectionBoxes, MOTION_WIDTH_MAP } from './types.js';
+import { DETECT_TIMEOUT_MS, DETECTOR_METRIC_TYPES, ensureDetectionBoxes, isFullFrameBox, 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;
@@ -44,6 +46,7 @@ const ACTIVE_TICK_MS = 100;
 const MOTION_INTERVAL_MS = 200;
 const TICK_SLACK_MS = 20;
 const MAIN_STREAM_HOLD_MS = 5000;
+const EXTERNAL_FRAME_MAX_AGE_MS = 1000;
 let DetectionCoordinator = class DetectionCoordinator {
     config;
     proxy;
@@ -66,9 +69,10 @@ let DetectionCoordinator = class DetectionCoordinator {
     classifierLabels = new Map();
     feedingSensors = new Map();
     dwell = new DwellManager();
-    videoBackoff = new ReconnectBackoff();
+    privacy;
     // debugging
     perf = new PerfTracker();
+    benchmarkRunning = false;
     hqUpgrade;
     mainStreamActive = false;
     idleSince = 0;
@@ -89,27 +93,32 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.config = config;
         this.proxy = proxy;
         this.logger = logger;
-        const frameSourceConfig = {
-            streamUrl: config.streamUrl,
-            snapshotUrl: config.snapshotUrl,
-            decoder: this.config.frameWorkerSettings.decoder,
-        };
+        const snapshot = { snapshotUrl: config.snapshotUrl };
         if (config.controllerSnapshotSourceId) {
             const sourceId = config.controllerSnapshotSourceId;
             const controllerProxy = this.proxy.createProxy(NamespaceManager.cameraNamespaces(config.cameraId).cameraControllerRpc);
-            frameSourceConfig.snapshotProvider = async () => {
+            snapshot.snapshotProvider = async () => {
                 const jpeg = await controllerProxy.snapshot(sourceId, true, true);
                 if (!jpeg || jpeg.byteLength === 0)
                     return null;
                 return Buffer.from(jpeg);
             };
         }
-        this.frameSource = new FrameSource(frameSourceConfig, logger);
-        this.frameScaler = new FrameScaler(null, logger);
-        this.pipeline = new DetectionPipeline(config.zones, config.detectionSettings);
-        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.config.zones = normalizeZones(config.zones);
+        this.privacy = new PrivacyMask(logger);
+        this.privacy.update(this.config.zones);
+        const decoder = this.config.frameWorkerSettings.decoder;
+        this.frameSource = config.streamHot
+            ? new BufferedSource({ url: config.streamUrl, decoder, privacy: this.privacy, snapshot }, logger)
+            : new FrameSource({ streamUrl: config.streamUrl, decoder, ...snapshot }, logger);
+        // a hot source buffers from the start, the loop only decides what is analysed
+        if (config.streamHot)
+            this.frameSource.start();
+        this.frameScaler = new FrameScaler(null, logger, this.privacy);
+        this.pipeline = new DetectionPipeline(this.pipelineZones(), config.detectionSettings);
+        this.secondaries = new SecondaryStage(this, this.plugins, this.pipeline, this.frameScaler, this.proxy, this.perf, logger);
+        if (config.zones.lines.length > 0) {
+            this.pipeline.updateLines(config.zones.lines, this.videoAspectRatio);
         }
         this.eventManager = new DetectionEventManager(config.cameraId, this.proxy, this.logger);
         this.eventManager.updateNvrRpc(config.nvrRpc);
@@ -122,6 +131,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.thumbnailer = new EventThumbnailer({
             frameSource: this.frameSource,
             frameScaler: this.frameScaler,
+            privacy: this.privacy,
             eventManager: this.eventManager,
             logger,
             decoder: this.config.frameWorkerSettings.decoder,
@@ -194,18 +204,93 @@ let DetectionCoordinator = class DetectionCoordinator {
         return this.config.detectionSettings;
     }
     getPerfSnapshot() {
-        return { ...this.perf.snapshot(), mainStreamEnabled: this.mainStreamAvailable, frameAnalysis: this.plugins.shouldVideoBeActive() };
-    }
-    updateZones(zones) {
-        this.config.zones = zones;
-        this.pipeline.updateZones(zones);
+        const { timings, ...counters } = this.perf.snapshot();
+        const detectors = {};
+        for (const type of DETECTOR_METRIC_TYPES) {
+            const plugin = this.plugins.get(type);
+            // motion without frames is the camera's own signal, there is no detector to report
+            if (!plugin || (type === SensorType.Motion && !plugin.requiresFrames))
+                continue;
+            const input = plugin.modelSpec?.input;
+            detectors[type] = {
+                plugin: plugin.pluginId,
+                input: isVideoInputSpec(input) ? `${input.width}x${input.height}` : undefined,
+                runtime: plugin.modelSpec?.runtime,
+                models: plugin.modelSpec?.models,
+                ...timings[type],
+            };
+        }
+        return {
+            ...counters,
+            detectors,
+            mainStreamEnabled: this.mainStreamAvailable,
+            frameAnalysis: this.plugins.shouldVideoBeActive(),
+        };
     }
-    updateAlertZones(zones) {
-        this.config.alertZones = zones;
+    resetPerf() {
+        this.perf.reset();
+    }
+    pauseForBenchmark(paused) {
+        this.benchmarkRunning = paused;
+    }
+    async runObjectBenchmark(iterations, concurrency) {
+        const plugin = this.plugins.get(SensorType.Object);
+        const input = plugin?.modelSpec?.input;
+        if (!plugin || !isVideoInputSpec(input))
+            return null;
+        const channels = input.format === 'gray' ? 1 : input.format === 'nv12' ? 1.5 : 3;
+        const frame = {
+            id: 'benchmark',
+            data: Buffer.alloc(Math.round(input.width * input.height * channels)),
+            width: input.width,
+            height: input.height,
+            format: input.format,
+        };
+        let handlerMs = 0;
+        let completed = 0;
+        let failed = 0;
+        const timed = this.proxy.createProxy(NamespaceManager.sensorProviderNamespaces(plugin.pluginId, plugin.sensorId).sensorRpc, {
+            onTiming: (_method, timing) => {
+                handlerMs += timing.handlerMs;
+            },
+        });
+        const startedAt = Date.now();
+        const workers = Array.from({ length: Math.max(1, concurrency) }, async () => {
+            while (completed + failed < iterations) {
+                completed++;
+                try {
+                    await PromiseTimeout(timed.detectObjects(frame), DETECT_TIMEOUT_MS, undefined, `Benchmark call timed out after ${DETECT_TIMEOUT_MS}ms`);
+                }
+                catch (error) {
+                    completed--;
+                    failed++;
+                    this.logger.debug('Benchmark call failed:', error);
+                }
+            }
+        });
+        await Promise.all(workers);
+        const totalMs = Date.now() - startedAt;
+        return {
+            camera: '',
+            plugin: plugin.pluginId,
+            sensorId: plugin.sensorId,
+            runtime: plugin.modelSpec?.runtime,
+            models: plugin.modelSpec?.models,
+            input: `${input.width}x${input.height}`,
+            iterations: completed,
+            failed,
+            concurrency,
+            totalMs,
+            perSecond: totalMs > 0 ? Math.round((completed / (totalMs / 1000)) * 10) / 10 : 0,
+            handlerMs: completed > 0 ? Math.round((handlerMs / completed) * 10) / 10 : 0,
+        };
     }
-    updateLines(lines) {
-        this.config.lines = lines;
-        this.pipeline.updateLines(lines, this.videoAspectRatio);
+    updateZoneConfig(zones) {
+        zones = normalizeZones(zones);
+        this.config.zones = zones;
+        this.pipeline.updateZones(this.pipelineZones());
+        this.privacy.update(zones);
+        this.pipeline.updateLines(zones.lines, this.videoAspectRatio);
     }
     updateDetectionSettings(settings) {
         this.config.detectionSettings = settings;
@@ -225,12 +310,13 @@ let DetectionCoordinator = class DetectionCoordinator {
     }
     updateInterfaceSettings(settings) {
         this.config.interfaceSettings = settings;
-        if (this.config.lines.length > 0) {
-            this.pipeline.updateLines(this.config.lines, this.videoAspectRatio);
+        if (this.config.zones.lines.length > 0) {
+            this.pipeline.updateLines(this.config.zones.lines, this.videoAspectRatio);
         }
     }
     async dispose() {
         await this.stopVideoLoop();
+        await this.frameSource.stop();
         await this.audioLoop.stop();
         await this.thumbnailer.stop();
         this.ptzAutotracker.dispose();
@@ -290,6 +376,12 @@ let DetectionCoordinator = class DetectionCoordinator {
         // the registry only announces the plugin assigned for this type, everyone else reports into the void
         if (!this.feedingSensors.has(sensorId))
             return;
+        // a detector reports its spec again once its models finished loading
+        if (properties.modelSpec) {
+            this.applyModelSpec(sensorId, sensorType, properties.modelSpec);
+            if (Object.keys(properties).length === 1)
+                return;
+        }
         if (sensorType === SensorType.Object) {
             const filtered = this.applyExternalDetectionFilters(sensorType, properties);
             // presence feed keeps the autotracker's return-home timer alive even while
@@ -319,39 +411,19 @@ let DetectionCoordinator = class DetectionCoordinator {
             this.processingExternalSecondary = true;
             try {
                 const rawExternal = filtered.detections ?? [];
-                const peeked = this.frameSource.peekLatestFrame();
-                if (peeked) {
-                    try {
-                        const results = { timestamp: Date.now() };
-                        const objects = await this.runObjectAssist(peeked.frame, rawExternal);
-                        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({ frame: peeked.frame, scaler: this.frameScaler, isMainStream: false }, objectDetections, results);
-                        this.ingestResultsForAllSecondaries(results);
-                        const snapshot = this.buildSnapshot();
-                        if (results.thumbnails && results.thumbnails.length > 0) {
-                            snapshot.thumbnails = results.thumbnails;
-                        }
-                        this.eventManager.processResults(snapshot);
-                    }
-                    finally {
-                        await peeked[Symbol.asyncDispose]();
-                    }
-                    return;
-                }
-                const fetched = await this.frameSource.fetchSnapshotFrame();
-                if (!fetched)
+                const handle = await this.frameSource.getFrame(EXTERNAL_FRAME_MAX_AGE_MS);
+                if (!handle)
                     return;
                 try {
                     const results = { timestamp: Date.now() };
-                    const objects = await this.runObjectAssist(fetched.frame, rawExternal);
+                    const objects = await this.runObjectAssist(handle.frame, rawExternal);
                     this.ingestAssistedObjects(sensorId, objects);
                     if (objects.assisted) {
                         // real boxes: crop the object like the frame pipeline, so face and
                         // plate secondaries run on the subject instead of the whole scene
+                        // (processExternal only adapts the shape, external boxes get no real tracking)
                         const objectDetections = this.pipeline.processExternal(objects.detections);
-                        await this.runSecondariesAndThumbnails({ frame: fetched.frame, scaler: this.frameScaler, isMainStream: false }, objectDetections, results);
+                        await this.runSecondariesAndThumbnails({ frame: handle.frame, scaler: this.frameScaler, isMainStream: false }, objectDetections, results);
                         this.ingestResultsForAllSecondaries(results);
                         const snapshot = this.buildSnapshot();
                         if (results.thumbnails && results.thumbnails.length > 0) {
@@ -360,9 +432,9 @@ let DetectionCoordinator = class DetectionCoordinator {
                         this.eventManager.processResults(snapshot);
                     }
                     else {
-                        const sceneJpeg = await this.secondaries.detectFullFrame(fetched.frame, results);
+                        const sceneJpeg = await this.secondaries.detectFullFrame(handle.frame, results);
                         try {
-                            results.thumbnails = await this.secondaries.generateThumbnails(fetched.frame, this.frameScaler, results);
+                            results.thumbnails = await this.secondaries.generateThumbnails(handle.frame, this.frameScaler, results);
                         }
                         catch (error) {
                             this.logger.error('Thumbnail generation error:', error);
@@ -382,7 +454,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                     }
                 }
                 finally {
-                    await fetched[Symbol.asyncDispose]();
+                    await handle[Symbol.asyncDispose]();
                 }
             }
             finally {
@@ -543,7 +615,7 @@ let DetectionCoordinator = class DetectionCoordinator {
             faceEmbeddingModel: cs.faceEmbeddingModel,
             plates: cs.licensePlate?.detections ?? [],
             plateVoting: this.plugins.get(SensorType.LicensePlate)?.requiresFrames === true,
-            plateMinConfidence: this.config.detectionSettings.licensePlate?.confidence,
+            plateMinConfidence: this.config.detectionSettings.licensePlate?.ocrConfidence,
             plateMinLength: this.config.detectionSettings.licensePlate?.minLength,
             faceMinConfidence: this.config.detectionSettings.face?.confidence,
             classifiers: cs.classifiers ? Object.values(cs.classifiers).flatMap((c) => c.detections) : [],
@@ -557,57 +629,69 @@ let DetectionCoordinator = class DetectionCoordinator {
             detectionZones: this.getNormalizedDetectionZones(),
         };
     }
+    pipelineZones() {
+        return { motion: this.config.zones.motion, object: this.config.zones.object, privacy: this.config.zones.privacy };
+    }
     getNormalizedDetectionZones() {
         const result = [];
-        for (const zone of this.config.zones ?? []) {
-            if (zone.isPrivacyMask)
-                continue;
+        for (const zone of this.config.zones.object) {
             if (!zone.name)
                 continue;
-            result.push({ name: zone.name, points: normalizeZone(zone).points });
+            result.push({ name: zone.name, points: normalizePolygon(zone.points) });
         }
-        for (const zone of this.config.alertZones ?? []) {
+        for (const zone of this.config.zones.alert) {
             if (!zone.name)
                 continue;
-            result.push({ name: zone.name, points: normalizePolygon(zone.points), match: zone.match ?? 'contain' });
+            result.push({
+                name: zone.name,
+                points: normalizePolygon(zone.points),
+                match: zone.match ?? 'contain',
+                alertLabels: zone.labels.map((label) => label.toLowerCase()),
+            });
         }
         return result;
     }
-    filterAllowedObjectLabels(detections) {
-        const allowed = this.config.detectionSettings.object.labels;
-        if (!allowed || allowed.length === 0 || detections.length === 0)
-            return detections;
-        const set = new Set(allowed.map((label) => label.toLowerCase()));
-        return detections.filter((detection) => set.has(detection.label.toLowerCase()));
-    }
     applyExternalDetectionFilters(sensorType, properties) {
         const raw = properties.detections;
         if (!Array.isArray(raw) || raw.length === 0)
             return properties;
         // the zone filter and the rust merge assume a box on every detection
         const detections = ensureDetectionBoxes(raw);
+        // a camera that reports a label without coordinates gives no position, a
+        // zone cannot judge it and the object assist has not run yet
+        const positioned = detections.filter((detection) => !isFullFrameBox(detection.box));
+        const boxless = detections.filter((detection) => isFullFrameBox(detection.box));
         let filtered;
+        let boxlessLabel;
         switch (sensorType) {
             case SensorType.Face:
-                filtered = this.pipeline.runZoneFilterWithLabel(detections, 'person');
+                boxlessLabel = 'face';
+                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'face');
                 break;
             case SensorType.LicensePlate:
-                filtered = this.pipeline.runZoneFilterWithLabel(detections, 'vehicle');
+                boxlessLabel = 'license_plate';
+                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'license_plate');
                 break;
             case SensorType.Object:
-                filtered = this.pipeline.runZoneFilter(this.filterAllowedObjectLabels(detections));
+                filtered = this.pipeline.runZoneFilter(positioned);
                 break;
             case SensorType.Classifier:
             case SensorType.Motion:
-                filtered = this.pipeline.runZoneFilter(detections);
+                filtered = this.pipeline.runZoneFilter(positioned);
                 break;
             default:
                 return { ...properties, detections }; // audio etc, no zone filter
         }
+        const survivors = new Set(filtered);
+        for (const detection of boxless) {
+            if (this.pipeline.objectLabelAllowed(boxlessLabel ?? detection.label))
+                survivors.add(detection);
+        }
+        const kept = detections.filter((detection) => survivors.has(detection));
         return {
             ...properties,
-            detections: filtered,
-            detected: filtered.length > 0,
+            detections: kept,
+            detected: kept.length > 0,
         };
     }
     applyAudioConfidence(properties) {
@@ -740,6 +824,18 @@ let DetectionCoordinator = class DetectionCoordinator {
                 break;
         }
     }
+    applyModelSpec(sensorId, sensorType, modelSpec) {
+        const current = this.plugins.get(sensorType);
+        if (current?.sensorId !== sensorId)
+            return;
+        // another model means other numbers, keeping the old average would mislead;
+        // load time is not part of the identity, a reload of the same model is not a change
+        if (sensorType === SensorType.Object || sensorType === SensorType.Motion) {
+            if (modelIdentity(current.modelSpec) !== modelIdentity(modelSpec))
+                this.perf.reset();
+        }
+        this.plugins.updateModelSpec(sensorId, modelSpec);
+    }
     async registerDetectionPluginInternal(sensor) {
         if (this.videoStopPromise)
             await this.videoStopPromise;
@@ -747,7 +843,9 @@ let DetectionCoordinator = class DetectionCoordinator {
         const wasVideoNeeded = this.plugins.shouldVideoBeActive();
         const wasAudioNeeded = this.plugins.shouldAudioBeActive();
         const namespaces = NamespaceManager.sensorProviderNamespaces(sensor.pluginId, sensor.sensorId);
-        const sensorProxy = this.proxy.createProxy(namespaces.sensorRpc);
+        const sensorProxy = this.proxy.createProxy(namespaces.sensorRpc, {
+            onTiming: (_method, timing) => this.perf.trackTiming(sensor.sensorType, timing.handlerMs, timing.transportMs),
+        });
         const registered = this.plugins.register({
             pluginId: sensor.pluginId,
             sensorId: sensor.sensorId,
@@ -758,7 +856,8 @@ let DetectionCoordinator = class DetectionCoordinator {
         });
         if (!registered) {
             // re-push from the registry: the sensor is already live, only the spec may have changed
-            this.plugins.updateModelSpec(sensor.sensorId, sensor.modelSpec);
+            if (sensor.modelSpec)
+                this.applyModelSpec(sensor.sensorId, sensor.sensorType, sensor.modelSpec);
             return;
         }
         this.logger.trace(`Plugin registered: ${sensor.pluginId} for ${sensor.sensorType}`);
@@ -839,7 +938,6 @@ let DetectionCoordinator = class DetectionCoordinator {
             return;
         this.logger.debug('Starting video detection loop');
         this.loopRunning = true;
-        this.videoBackoff.reset();
         this.loopPromise = this.runDetectionLoop();
     }
     async stopVideoLoop() {
@@ -854,7 +952,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.mainStreamActive = false;
         this.idleSince = 0;
         const doStop = async () => {
-            await this.frameSource.stop();
+            await this.frameSource.detach();
             await this.loopPromise;
             this.loopPromise = undefined;
         };
@@ -881,81 +979,87 @@ let DetectionCoordinator = class DetectionCoordinator {
         }
     }
     async runDetectionLoop() {
+        // the source reconnects on its own, nextFrame simply waits it out
+        const startedAt = Date.now();
+        await this.frameSource.start();
+        let lastFrameId = -1;
+        let seenGeneration = -1;
+        let firstFrame = true;
         while (this.loopRunning) {
+            const tickStart = Date.now();
+            const snap = await this.frameSource.nextFrame(lastFrameId);
+            if (!snap)
+                break; // source stopped
+            if (firstFrame) {
+                firstFrame = false;
+                this.logger.debug(`Analysing after ${Date.now() - startedAt}ms`);
+            }
+            lastFrameId = snap.id;
+            if (this.benchmarkRunning) {
+                // the detector is saturated on purpose, feeding it real frames would
+                // both distort the measurement and queue up behind it
+                snap.frame[Symbol.dispose]?.();
+                await sleep(IDLE_TICK_MS);
+                continue;
+            }
             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);
+                if (this.frameSource.generation !== seenGeneration) {
+                    seenGeneration = this.frameSource.generation;
+                    // a fresh connection brings its own hardware context and resolution
+                    this.frameScaler.updateHardwareContext(this.frameSource.hardwareContext);
+                    this.frameScaler.clearCache();
+                    this.thumbnailer.sync(this.mainStreamAnalysisWanted);
+                }
+                // 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(analysis, snap.frame);
+                }
+                finally {
                     try {
-                        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
+                        if (this.hqUpgrade) {
+                            this.hqUpgrade.frame[Symbol.dispose]?.();
+                            this.hqUpgrade = undefined;
                         }
+                        if (analysis.frame !== snap.frame)
+                            analysis.frame[Symbol.dispose]?.();
+                    }
+                    catch {
+                        // ignore
                     }
-                    this.updateStreamState();
-                    // activity, not stream choice: cameras without main-stream analysis still count as active
-                    if (this.worldSpans.size > 0 || this.eventManager.hasActiveSegment())
-                        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();
-                this.frameScaler.clearCache();
-                if (this.loopRunning && streamError) {
-                    const delay = this.videoBackoff.nextDelayMs();
-                    this.logger.warn(`Stream ended with read error, reconnecting in ${delay / 1000}s: ${streamError.message}`);
-                    await sleep(delay);
-                }
-                else if (this.loopRunning && frameCount === 0) {
-                    this.logger.debug('Stream ended without frames, waiting before reconnect...');
-                    await sleep(this.videoBackoff.idleDelayMs);
                 }
+                this.updateStreamState();
             }
             catch (error) {
-                if (!this.loopRunning)
-                    break;
-                await this.frameSource.stop();
-                this.frameScaler.clearCache();
-                const delay = this.videoBackoff.nextDelayMs();
-                this.logger.warn(`Stream error, reconnecting in ${delay / 1000}s: ${error.message}`);
-                await sleep(delay);
+                // the stream keeps running, a broken tick must not end the loop
+                this.logger.error('Detection tick failed:', error);
             }
-        }
-        await this.frameSource.stop();
+            finally {
+                try {
+                    snap.frame[Symbol.dispose]?.();
+                }
+                catch {
+                    // ignore
+                }
+            }
+            const decode = this.frameSource.takeDecodeStats();
+            this.perf.decodeMs += decode.ms;
+            this.perf.decodedFrames += decode.frames;
+            // activity, not stream choice: cameras without main-stream analysis still count as active
+            if (this.worldSpans.size > 0 || this.eventManager.hasActiveSegment())
+                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;
+        }
+        await this.frameSource.detach();
         this.frameScaler.clearCache();
         this.logger.debug('Detection loop ended');
     }
@@ -974,7 +1078,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                 const main = await this.thumbnailer.acquireHqFrame(0);
                 if (main) {
                     this.perf.mainFrames++;
-                    this.perf.decodeMs += Date.now() - t0;
+                    this.perf.mainDecodeMs += Date.now() - t0;
                     return { frame: main.frame, scaler: main.scaler, isMainStream: true };
                 }
             }
@@ -992,7 +1096,7 @@ let DetectionCoordinator = class DetectionCoordinator {
             const main = await this.thumbnailer.acquireHqFrame(0);
             if (main) {
                 this.perf.mainFrames++;
-                this.perf.decodeMs += Date.now() - t0;
+                this.perf.mainDecodeMs += Date.now() - t0;
                 return { frame: main.frame, scaler: main.scaler, isMainStream: true };
             }
         }
@@ -1059,8 +1163,8 @@ let DetectionCoordinator = class DetectionCoordinator {
                 try {
                     const motionInferStart = Date.now();
                     const result = await motionPlugin.proxy.detectMotion(motionFrame);
-                    this.perf.inferMs += Date.now() - motionInferStart;
-                    this.perf.inferCount++;
+                    this.perf.motionMs += Date.now() - motionInferStart;
+                    this.perf.motionCount++;
                     if (!this.loopRunning)
                         return;
                     if (ptzSuppressed) {
@@ -1111,16 +1215,18 @@ let DetectionCoordinator = class DetectionCoordinator {
                 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;
-                    this.perf.inferCount++;
+                    this.perf.objectMs += Date.now() - inferStart;
+                    this.perf.objectCount++;
                     if (!this.loopRunning)
                         return;
                     this.trackDetectionCadence();
                     // run the pipeline even on empty frames so Norfair advances its
                     // Kalman state; the pose delta keeps predictions stable across pans
                     const poseDelta = this.ptzAutotracker.consumePoseDelta();
-                    const detected = this.filterAllowedObjectLabels(FrameScaler.undoLetterbox(ensureDetectionBoxes(result.detections), objectFrame.geometry));
+                    const postStart = Date.now();
+                    const detected = FrameScaler.undoLetterbox(ensureDetectionBoxes(result.detections), objectFrame.geometry);
                     const pipelineResult = this.pipeline.process(detected, poseDelta);
+                    this.perf.postMs += Date.now() - postStart;
                     // 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) {
@@ -1244,6 +1350,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         if (objectDetections.length === 0)
             return;
         this.perf.objects += objectDetections.length;
+        this.perf.framesWithObjects++;
         const secondaryStart = Date.now();
         await this.secondaries.detect(analysis.frame, analysis.scaler, objectDetections, results);
         this.perf.secondaryMs += Date.now() - secondaryStart;
@@ -1265,15 +1372,18 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
             const facePlugin = this.plugins.get(SensorType.Face);
             if (facePlugin) {
+                // the crop path reaches ingestDetectionResult directly, so the zone
+                // filter that guards the plugin path has to be applied here too
+                const detections = this.pipeline.runZoneFilterWithLabel(results.face.detections, 'face');
                 // 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) {
+                for (const detection of detections) {
                     if (detection.identity)
                         this.faceIdentities.add(detection.identity);
                 }
                 this.ingestDetectionResult(SensorType.Face, facePlugin.sensorId, {
-                    detected: results.face.detected,
-                    detections: results.face.detections,
+                    detected: detections.length > 0 && results.face.detected,
+                    detections,
                     identities: [...this.faceIdentities].sort(),
                 });
             }
@@ -1281,14 +1391,15 @@ let DetectionCoordinator = class DetectionCoordinator {
         if (results.licensePlate) {
             const lpdPlugin = this.plugins.get(SensorType.LicensePlate);
             if (lpdPlugin) {
-                for (const detection of results.licensePlate.detections) {
+                const detections = this.pipeline.runZoneFilterWithLabel(results.licensePlate.detections, 'license_plate');
+                for (const detection of 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,
+                    detected: detections.length > 0 && results.licensePlate.detected,
+                    detections,
                     plates: [...this.platesSeen].sort(),
                 });
             }
@@ -1578,10 +1689,10 @@ let DetectionCoordinator = class DetectionCoordinator {
         try {
             const inferStart = Date.now();
             const result = await PromiseTimeout(assist.proxy.detectObjects(scaled.model), DETECT_TIMEOUT_MS, undefined, `Object assist timed out after ${DETECT_TIMEOUT_MS}ms`);
-            this.perf.inferMs += Date.now() - inferStart;
-            this.perf.inferCount++;
+            this.perf.assistMs += Date.now() - inferStart;
+            this.perf.assistCount++;
             const reportedLabels = new Set(reported.map((d) => d.label.toLowerCase()));
-            const boxed = this.filterAllowedObjectLabels(FrameScaler.undoLetterbox(ensureDetectionBoxes(result?.detections ?? []), scaled.geometry));
+            const boxed = FrameScaler.undoLetterbox(ensureDetectionBoxes(result?.detections ?? []), scaled.geometry);
             const found = boxed.filter((d) => reportedLabels.size === 0 || reportedLabels.has(d.label.toLowerCase()));
             if (found.length === 0)
                 return { detections: reported, assisted: false };