@camera.ui/server 2.1.8 → 2.1.9

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

@@ -26,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, isFullFrameBox, 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;
@@ -46,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;
@@ -69,9 +70,9 @@ let DetectionCoordinator = class DetectionCoordinator {
     feedingSensors = new Map();
     dwell = new DwellManager();
     privacy;
-    videoBackoff = new ReconnectBackoff();
     // debugging
     perf = new PerfTracker();
+    benchmarkRunning = false;
     hqUpgrade;
     mainStreamActive = false;
     idleSince = 0;
@@ -92,28 +93,30 @@ 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.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, logger);
+        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);
         }
@@ -201,7 +204,86 @@ let DetectionCoordinator = class DetectionCoordinator {
         return this.config.detectionSettings;
     }
     getPerfSnapshot() {
-        return { ...this.perf.snapshot(), mainStreamEnabled: this.mainStreamAvailable, frameAnalysis: this.plugins.shouldVideoBeActive() };
+        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(),
+        };
+    }
+    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,
+        };
     }
     updateZoneConfig(zones) {
         zones = normalizeZones(zones);
@@ -234,6 +316,7 @@ let DetectionCoordinator = class DetectionCoordinator {
     }
     async dispose() {
         await this.stopVideoLoop();
+        await this.frameSource.stop();
         await this.audioLoop.stop();
         await this.thumbnailer.stop();
         this.ptzAutotracker.dispose();
@@ -293,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
@@ -322,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) {
@@ -363,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);
@@ -385,7 +454,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                     }
                 }
                 finally {
-                    await fetched[Symbol.asyncDispose]();
+                    await handle[Symbol.asyncDispose]();
                 }
             }
             finally {
@@ -546,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) : [],
@@ -596,12 +665,12 @@ let DetectionCoordinator = class DetectionCoordinator {
         let boxlessLabel;
         switch (sensorType) {
             case SensorType.Face:
-                boxlessLabel = 'person';
-                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'person');
+                boxlessLabel = 'face';
+                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'face');
                 break;
             case SensorType.LicensePlate:
-                boxlessLabel = 'vehicle';
-                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'vehicle');
+                boxlessLabel = 'license_plate';
+                filtered = this.pipeline.runZoneFilterWithLabel(positioned, 'license_plate');
                 break;
             case SensorType.Object:
                 filtered = this.pipeline.runZoneFilter(positioned);
@@ -755,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;
@@ -762,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,
@@ -773,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}`);
@@ -854,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() {
@@ -869,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;
         };
@@ -896,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');
     }
@@ -989,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 };
                 }
             }
@@ -1007,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 };
             }
         }
@@ -1074,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) {
@@ -1126,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 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) {
@@ -1259,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;
@@ -1280,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(),
                 });
             }
@@ -1296,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(),
                 });
             }
@@ -1593,8 +1689,8 @@ 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 = FrameScaler.undoLetterbox(ensureDetectionBoxes(result?.detections ?? []), scaled.geometry);
             const found = boxed.filter((d) => reportedLabels.size === 0 || reportedLabels.has(d.label.toLowerCase()));