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

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

@@ -0,0 +1,1844 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { isNoRespondersError, RPCClass, RPCMethod } from '@camera.ui/rpc';
+import { SensorType } from '@camera.ui/sdk';
+// import { writeFileSync } from 'node:fs';
+import { NamespaceManager } from '../../rpc/namespaces.js';
+import { DETECTION_SENSOR_TYPES, SENSOR_TYPE_CONFIG } from '../sensors/types.js';
+import { normalizeZone } from '../utils/filter.js';
+import { AudioSource } from './audio-source.js';
+import { CascadeManager } from './cascade-manager.js';
+import { DetectionPipeline } from './detection-pipeline.js';
+import { DwellManager } from './dwell-manager.js';
+import { DetectionEventManager } from './event-manager.js';
+import { FrameScaler } from './frame-scaler.js';
+import { FrameSource } from './frame-source.js';
+import { PtzAutotracker } from './ptz-autotracker.js';
+import { MOTION_WIDTH_MAP } from './types.js';
+// Default cascade hold-open window in seconds
+export const DEFAULT_CASCADE_TIMEOUT = 10;
+// Tracks below this speed (normalized units/s) are considered stationary.
+// Typical values: parked bike ~0.0006, standing person ~0.003–0.03.
+export const STATIONARY_SPEED_THRESHOLD = 0.002;
+// Object detection dwell window — bridges 1-2 missed frames inside an active
+// cascade so a single uncertain frame doesn't fire `detected=false` and split
+// the event. Mirrors the motion/audio dwell pattern.
+const OBJECT_DWELL_SECONDS = 2;
+let DetectionCoordinator = class DetectionCoordinator {
+    config;
+    proxy;
+    logger;
+    frameSource;
+    frameScaler;
+    singlePlugins = new Map();
+    multiPlugins = new Map();
+    loopRunning = false;
+    loopPromise;
+    videoStopPromise;
+    audioSource;
+    audioLoopRunning = false;
+    audioLoopPromise;
+    audioStopPromise;
+    audioReconnectCount = 0;
+    reconnectCount = 0;
+    maxReconnectCount = 10;
+    normalReconnectDelay = 10000;
+    maxReconnectDelay = 60000;
+    ptzAutotracker;
+    eventManager;
+    cascade = new CascadeManager();
+    dwell = new DwellManager();
+    pipeline;
+    adHocVideoLoop = false;
+    processingExternalSecondary = false;
+    cascadeUnsubscribe;
+    dwellUnsubscribe;
+    seenStationaryTracks = new Set();
+    activeSensorTriggerTypes = new Map();
+    currentDetectionState = {};
+    get cascadeEnabled() {
+        return this.config.detectionSettings.cascadeDetection !== false;
+    }
+    get cascadeTimeoutSeconds() {
+        return this.config.detectionSettings.cascadeTimeout ?? DEFAULT_CASCADE_TIMEOUT;
+    }
+    get audioMinDecibels() {
+        return this.config.detectionSettings.audio.minDecibels;
+    }
+    get motionResolution() {
+        return this.config.detectionSettings.motion.resolution;
+    }
+    get targetFps() {
+        return this.frameSource.fps;
+    }
+    get videoAspectRatio() {
+        const [w, h] = this.config.interfaceSettings.aspectRatio.split(':').map(Number);
+        return w / h;
+    }
+    nvrProxy;
+    nvrProxyPromise;
+    constructor(config, proxy, logger) {
+        this.config = config;
+        this.proxy = proxy;
+        this.logger = logger;
+        const frameSourceConfig = {
+            streamUrl: config.streamUrl,
+            snapshotUrl: config.snapshotUrl,
+            fps: this.config.frameWorkerSettings.fps,
+        };
+        this.frameSource = new FrameSource(frameSourceConfig, logger);
+        this.frameScaler = new FrameScaler(null, logger);
+        this.pipeline = new DetectionPipeline(config.zones, config.detectionSettings);
+        if (config.lines.length > 0) {
+            this.pipeline.updateLines(config.lines, this.videoAspectRatio);
+        }
+        this.eventManager = new DetectionEventManager(config.cameraId, this.proxy, this.logger);
+        this.eventManager.onEventEnd(() => this.handleEventEnded());
+        this.ptzAutotracker = new PtzAutotracker({
+            logger: this.logger,
+            proxy: this.proxy,
+            cameraId: this.config.cameraId,
+            settings: this.config.ptzAutotrack,
+            onSuppressionActivated: () => this.clearMotionStateForSuppression(),
+        });
+        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();
+            }
+        });
+        this.dwellUnsubscribe = this.dwell.onChange((event) => {
+            const isSensorTrigger = event.sensorId.startsWith('trigger:');
+            if (event.state === 'activated') {
+                // Only write detected/blocked for detection sensors (motion/audio/object).
+                // Sensor triggers (contact/switch/light) manage their own properties.
+                if (!isSensorTrigger) {
+                    this.writeSensorProperties(event.sensorId, {
+                        detected: true,
+                        blocked: true,
+                        lastTriggered: event.timestamp,
+                    });
+                }
+            }
+            else {
+                if (!isSensorTrigger) {
+                    this.writeSensorProperties(event.sensorId, { detected: false, blocked: false });
+                }
+                this.activeSensorTriggerTypes.delete(event.sensorId);
+                if (!this.dwell.hasActive()) {
+                    this.eventManager.forceEndActiveEvent();
+                }
+            }
+        });
+    }
+    handleCascadeDeactivated() {
+        // Clear cascade-gated buffer slots but keep motion/audio intact
+        const cs = this.currentDetectionState;
+        cs.object = undefined;
+        cs.face = undefined;
+        cs.licensePlate = undefined;
+        cs.classifiers = undefined;
+        cs.clip = undefined;
+        cs.lineCrossings = undefined;
+        cs.cascadeTriggered = undefined;
+        // Publish empty detections for all cascade-gated sensors so UI clears bboxes
+        const clearTargets = [];
+        for (const [type, plugin] of this.singlePlugins) {
+            if (type === SensorType.Object || type === SensorType.Face || type === SensorType.LicensePlate) {
+                clearTargets.push({ sensorId: plugin.sensorId, type });
+            }
+        }
+        const classifierPlugins = this.multiPlugins.get(SensorType.Classifier);
+        if (classifierPlugins) {
+            for (const plugin of classifierPlugins.values()) {
+                clearTargets.push({ sensorId: plugin.sensorId, type: SensorType.Classifier });
+            }
+        }
+        for (const { sensorId } of clearTargets) {
+            this.writeSensorProperties(sensorId, { detected: false, detections: [] });
+        }
+        // Tick EventManager — segment ends but event continues (motion still active)
+        this.eventManager.processResults(this.buildSnapshot());
+    }
+    handleEventEnded() {
+        this.pipeline.cleanup();
+        this.seenStationaryTracks.clear();
+        this.activeSensorTriggerTypes.clear();
+        this.currentDetectionState = {};
+    }
+    writeSensorProperties(sensorId, properties) {
+        const msg = {
+            sensorId,
+            properties,
+            timestamp: Date.now(),
+        };
+        this.proxy.publish(NamespaceManager.sensorControllerNamespaces(this.config.cameraId).sensorWriteSubject, msg);
+    }
+    buildSnapshot() {
+        const cs = this.currentDetectionState;
+        return {
+            hasCascadeTrigger: this.cascade.isActive,
+            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 ? cs.object.detections : [],
+            faces: cs.face?.detections ?? [],
+            faceEmbeddingModel: cs.faceEmbeddingModel,
+            plates: cs.licensePlate?.detections ?? [],
+            classifiers: cs.classifiers ? Object.values(cs.classifiers).flatMap((c) => c.detections) : [],
+            clips: cs.clip?.embeddings ?? [],
+            clipEmbeddingModel: cs.clipEmbeddingModel,
+            thumbnails: undefined,
+            lineCrossings: cs.lineCrossings,
+            timestamp: Date.now(),
+            segmentTimeout: 10,
+            expectedEndTime: this.dwell.maxExpiry(),
+            detectionZones: this.getNormalizedDetectionZones(),
+        };
+    }
+    getNormalizedDetectionZones() {
+        if (!this.config.zones || this.config.zones.length === 0)
+            return [];
+        const result = [];
+        for (const zone of this.config.zones) {
+            if (zone.isPrivacyMask)
+                continue;
+            if (!zone.name)
+                continue;
+            const normalized = normalizeZone(zone);
+            result.push({ name: zone.name, points: normalized.points });
+        }
+        return result;
+    }
+    applyExternalDetectionFilters(sensorType, properties) {
+        const detections = properties.detections;
+        if (!Array.isArray(detections) || detections.length === 0)
+            return properties;
+        let filtered;
+        switch (sensorType) {
+            case SensorType.Face:
+                filtered = this.pipeline.runZoneFilterWithLabel(detections, 'person');
+                break;
+            case SensorType.LicensePlate:
+                filtered = this.pipeline.runZoneFilterWithLabel(detections, 'vehicle');
+                break;
+            case SensorType.Object:
+            case SensorType.Classifier:
+            case SensorType.Motion:
+                filtered = this.pipeline.runZoneFilter(detections);
+                break;
+            default:
+                return properties; // Audio etc — no zone filter
+        }
+        return {
+            ...properties,
+            detections: filtered,
+            detected: filtered.length > 0,
+        };
+    }
+    ingestDetectionResult(sensorType, sensorId, properties, pluginId) {
+        // Note: PTZ-suppression gating happens upstream — processDetection and
+        // reportSensorWrite decide whether to route to autotracker-only vs. full
+        // ingest. By the time we land here, the caller has already decided this
+        // write belongs in the full pipeline.
+        // Update aggregated buffer based on sensor type. Each type maps to a different
+        // ProcessedDetectionData field — partial-merge with what's already buffered.
+        this.updateBufferForType(sensorType, properties, pluginId);
+        const detected = properties.detected === true;
+        // Motion/Audio: refresh dwell on positive detection. Dwell drives the
+        // `detected` / `blocked` / `lastTriggered` lifecycle entirely — see the
+        // dwell.onChange listener wired in the constructor. Motion additionally
+        // triggers cascade.
+        if (sensorType === SensorType.Motion && detected) {
+            const motionTimeout = this.config.detectionSettings.motion.timeout;
+            this.dwell.refresh(sensorId, motionTimeout);
+            if (this.cascadeEnabled) {
+                this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+            }
+        }
+        else if (sensorType === SensorType.Audio && detected) {
+            const audioTimeout = this.config.detectionSettings.audio.timeout;
+            this.dwell.refresh(sensorId, audioTimeout);
+            if (this.cascadeEnabled) {
+                this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+            }
+        }
+        else if (sensorType === SensorType.Object && detected) {
+            // Object dwell — anti-chatter for object detection. Single missed frame
+            // (model uncertain for ~100ms) must not split the event into two.
+            //
+            // Stationary object gating: a track that is stationary AND was already
+            // seen in a previous frame during this event must NOT refresh the dwell.
+            // This prevents parked cars/bikes from keeping events alive forever.
+            // Moving tracks always refresh. Stationary tracks refresh only once
+            // (first time seen) — after that they're in seenStationaryTracks and
+            // get skipped. The set is cleared on cascade deactivate (event boundary).
+            const detections = properties.detections ?? [];
+            let hasActiveTrack = false;
+            for (const t of detections) {
+                if (t.trackLost)
+                    continue;
+                const isStationary = (t.trackSpeed ?? 0) < STATIONARY_SPEED_THRESHOLD;
+                if (isStationary) {
+                    if (t.trackId !== undefined && !this.seenStationaryTracks.has(t.trackId)) {
+                        // First time seeing this stationary track — count it as active
+                        this.seenStationaryTracks.add(t.trackId);
+                        hasActiveTrack = true;
+                    }
+                    // Already seen stationary track — does not count
+                }
+                else {
+                    // Moving track — always counts
+                    hasActiveTrack = true;
+                }
+            }
+            if (hasActiveTrack) {
+                this.dwell.refresh(sensorId, OBJECT_DWELL_SECONDS);
+            }
+            else {
+                // Only known stationary tracks — suppress detected and clear detections
+                // from the buffer so the EventManager doesn't open a new segment for
+                // objects we've already seen. The UI still gets the bboxes via the
+                // property publish (publishProps path below).
+                properties.detected = false;
+                if (this.currentDetectionState.object) {
+                    this.currentDetectionState.object.detected = false;
+                    this.currentDetectionState.object.detections = [];
+                }
+            }
+        }
+        // Publish path. For motion/audio sensors, dwell is the SOLE owner of
+        // `detected` / `blocked` / `lastTriggered` regardless of the current
+        // frame's detected value — anti-chatter means a "no detection" frame
+        // must NOT overwrite the dwell-set `detected=true`. Always strip these
+        // dwell-managed properties from the publish, and let `dwell.onChange`
+        // (activated/expired) be the only path that writes them.
+        let publishProps = properties;
+        if (sensorType === SensorType.Motion || sensorType === SensorType.Audio || sensorType === SensorType.Object) {
+            const { detected: _d, blocked: _b, lastTriggered: _t, ...rest } = properties;
+            publishProps = rest;
+        }
+        if (Object.keys(publishProps).length > 0) {
+            this.writeSensorProperties(sensorId, publishProps);
+        }
+        // EventManager is NOT ticked here — detection-coordinator flushes once
+        // per frame at the end of processDetection() after all detectors + thumbnails.
+    }
+    updateBufferForType(sensorType, properties, pluginId) {
+        const cs = this.currentDetectionState;
+        const detections = properties.detections ?? [];
+        const detected = properties.detected === true;
+        switch (sensorType) {
+            case SensorType.Motion:
+                cs.motion = { detected, detections };
+                break;
+            case SensorType.Audio:
+                cs.audio = {
+                    detected,
+                    detections,
+                    decibels: properties.decibels ?? cs.audio?.decibels,
+                };
+                break;
+            case SensorType.Object:
+                cs.object = { detected, detections };
+                break;
+            case SensorType.Face:
+                cs.face = { detected, detections: detections };
+                break;
+            case SensorType.LicensePlate:
+                cs.licensePlate = { detected, detections: detections };
+                break;
+            case SensorType.Classifier:
+                if (pluginId) {
+                    cs.classifiers ??= {};
+                    cs.classifiers[pluginId] = { detected, detections: detections };
+                }
+                break;
+            case SensorType.Clip:
+                cs.clip = { embeddings: properties.embeddings ?? [], embeddingModel: cs.clipEmbeddingModel ?? '' };
+                break;
+        }
+    }
+    updateZones(zones) {
+        this.config.zones = zones;
+        this.pipeline.updateZones(zones);
+    }
+    updateLines(lines) {
+        this.config.lines = lines;
+        this.pipeline.updateLines(lines, this.videoAspectRatio);
+    }
+    updateDetectionSettings(settings) {
+        this.config.detectionSettings = settings;
+        this.pipeline.updateSettings(settings);
+    }
+    updatePtzAutotrackSettings(settings) {
+        this.config.ptzAutotrack = settings;
+        this.ptzAutotracker.updateSettings(settings);
+    }
+    updateFrameWorkerSettings(settings) {
+        this.config.frameWorkerSettings = settings;
+    }
+    updateInterfaceSettings(settings) {
+        this.config.interfaceSettings = settings;
+        if (this.config.lines.length > 0) {
+            this.pipeline.updateLines(this.config.lines, this.videoAspectRatio);
+        }
+    }
+    async dispose() {
+        await this.stopVideoLoop();
+        await this.stopAudioLoop();
+        this.ptzAutotracker.dispose();
+        this.cascadeUnsubscribe?.();
+        this.dwellUnsubscribe?.();
+        this.cascade.dispose();
+        this.dwell.dispose();
+        this.eventManager.destroy();
+        this.adHocVideoLoop = false;
+        this.frameScaler.dispose();
+        this.pipeline.cleanup();
+        this.currentDetectionState = {};
+    }
+    async onSensorAdded(sensor) {
+        if (DETECTION_SENSOR_TYPES.has(sensor.sensorType) && sensor.requiresFrames) {
+            await this.registerDetectionPluginInternal(sensor);
+        }
+        if (sensor.sensorType === SensorType.PTZ) {
+            await this.ptzAutotracker.bind({
+                pluginId: sensor.pluginId,
+                sensorId: sensor.sensorId,
+                capabilities: sensor.capabilities,
+            });
+        }
+    }
+    async onSensorRemoved(sensorId) {
+        await this.removeDetectionPluginBySensor(sensorId);
+        this.ptzAutotracker.unbind(sensorId);
+        const dwellKey = `trigger:${sensorId}`;
+        this.activeSensorTriggerTypes.delete(dwellKey);
+        this.dwell.clear(dwellKey);
+        this.dwell.clear(sensorId);
+    }
+    onSensorCapabilitiesChanged(sensorId, capabilities) {
+        this.ptzAutotracker.setCapabilities(sensorId, capabilities);
+    }
+    async registerDetectionPluginInternal(sensor) {
+        // Wait for any in-progress stop to complete before starting a new loop
+        if (this.videoStopPromise)
+            await this.videoStopPromise;
+        if (this.audioStopPromise)
+            await this.audioStopPromise;
+        const wasVideoNeeded = this.shouldVideoBeActive();
+        const wasAudioNeeded = this.shouldAudioBeActive();
+        const namespaces = NamespaceManager.sensorProviderNamespaces(sensor.pluginId, this.config.cameraId, sensor.sensorId);
+        const sensorProxy = this.proxy.createProxy(namespaces.sensorRpc);
+        const pluginInfo = {
+            pluginId: sensor.pluginId,
+            sensorId: sensor.sensorId,
+            sensorType: sensor.sensorType,
+            requiresFrames: sensor.requiresFrames,
+            modelSpec: sensor.modelSpec,
+            proxy: sensorProxy,
+        };
+        if (this.isMultiProvider(sensor.sensorType)) {
+            if (!this.multiPlugins.has(sensor.sensorType)) {
+                this.multiPlugins.set(sensor.sensorType, new Map());
+            }
+            const typePlugins = this.multiPlugins.get(sensor.sensorType);
+            if (typePlugins.has(sensor.pluginId))
+                return;
+            typePlugins.set(sensor.pluginId, pluginInfo);
+            this.logger.trace(`Multi-provider plugin registered: ${sensor.pluginId} for ${sensor.sensorType}`);
+        }
+        else {
+            if (this.singlePlugins.has(sensor.sensorType))
+                return;
+            this.singlePlugins.set(sensor.sensorType, pluginInfo);
+            this.logger.trace(`Plugin registered: ${sensor.pluginId} for ${sensor.sensorType}`);
+        }
+        if (!wasVideoNeeded && this.shouldVideoBeActive()) {
+            this.adHocVideoLoop = false;
+            this.startVideoLoop();
+        }
+        if (!wasAudioNeeded && this.shouldAudioBeActive()) {
+            this.startAudioLoop();
+        }
+        if (this.cascade.isActive) {
+            this.startAdHocVideoLoopIfNeeded();
+        }
+    }
+    async removeDetectionPluginBySensor(sensorId) {
+        const wasVideoNeeded = this.shouldVideoBeActive();
+        const wasAudioNeeded = this.shouldAudioBeActive();
+        let removed = false;
+        for (const [sensorType, plugin] of this.singlePlugins) {
+            if (plugin.sensorId === sensorId) {
+                this.singlePlugins.delete(sensorType);
+                removed = true;
+                this.logger.trace(`Plugin unregistered: ${plugin.pluginId} (${sensorType})`);
+            }
+        }
+        for (const [sensorType, typePlugins] of this.multiPlugins) {
+            for (const [pluginId, plugin] of typePlugins) {
+                if (plugin.sensorId === sensorId) {
+                    typePlugins.delete(pluginId);
+                    removed = true;
+                    this.logger.trace(`Multi-provider plugin unregistered: ${pluginId} (${sensorType})`);
+                }
+            }
+            if (typePlugins.size === 0)
+                this.multiPlugins.delete(sensorType);
+        }
+        if (!removed)
+            return;
+        if (!this.singlePlugins.has(SensorType.Object)) {
+            this.adHocVideoLoop = false;
+        }
+        // Hot-reload: if the ad-hoc loop is no longer needed after removing the
+        // plugin, stop it. Uses needsAdHocLoop() (not shouldVideoBeActive) so we
+        // don't accidentally stop a loop still needed for F object (requiresFrames=true).
+        if (this.adHocVideoLoop && !this.needsAdHocLoop()) {
+            this.adHocVideoLoop = false;
+            this.logger.debug('Stopping ad-hoc video loop — last frame-based consumer removed');
+            this.stopVideoLoop();
+        }
+        // Await to prevent race: a rapid re-register could start a second loop
+        // while the old one is still shutting down.
+        if (wasVideoNeeded && !this.shouldVideoBeActive() && !this.adHocVideoLoop) {
+            await this.stopVideoLoop();
+        }
+        if (wasAudioNeeded && !this.shouldAudioBeActive()) {
+            await this.stopAudioLoop();
+        }
+    }
+    async reportSensorWrite(sensorId, sensorType, properties) {
+        if (sensorType === SensorType.Object) {
+            const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+            // Always feed the autotracker — it needs fresh data every write, even
+            // (especially) during suppression, so it can decide when to stop.
+            // External-sensor object writes are presence-only (SDK synthesises a
+            // full-frame bbox when the plugin reports without coordinates), so use
+            // the presence channel — it holds the return-to-home timer without
+            // driving the motor.
+            const externalDetections = filtered.detections ?? [];
+            this.ptzAutotracker.handlePresenceDetections(externalDetections);
+            // During PTZ suppression: autotracker got the data, but tracker/pipeline/
+            // events/UI are gated (no stale bboxes, no false events from camera pose
+            // change). Skip the rest.
+            if (this.ptzAutotracker.suppressionActive)
+                return;
+            this.ingestDetectionResult(SensorType.Object, sensorId, filtered);
+            this.eventManager.processResults(this.buildSnapshot());
+            if (!this.hasFrameBasedSecondary())
+                return;
+            if (this.processingExternalSecondary)
+                return; // busy-skip: previous RPC still running
+            this.processingExternalSecondary = true;
+            try {
+                // Wrap the zone-filtered external boxes as TrackedDetection (no real
+                // tracking, just shape adapter — `trackLost: false`) so the secondary
+                // pipeline can treat them uniformly with frame-driven output.
+                const rawExternal = filtered.detections ?? [];
+                const objectDetections = this.pipeline.processExternal(rawExternal);
+                // Fast path: loop is running and has a frame → crop mode.
+                const peeked = this.frameSource.peekLatestFrame();
+                if (peeked) {
+                    try {
+                        const results = { timestamp: Date.now() };
+                        await this.runSecondariesAndThumbnails(peeked.frame, 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;
+                }
+                // Slow path: loop hasn't produced a frame yet → snapshot fetch fallback.
+                // Full-frame mode (no per-detection crops) — secondaries run global
+                // detection on the whole scaled frame.
+                const fetched = await this.frameSource.fetchSnapshotFrame();
+                if (!fetched)
+                    return;
+                try {
+                    const results = { timestamp: Date.now() };
+                    const sceneJpeg = await this.runSecondariesFullFrame(fetched.frame, results);
+                    this.ingestResultsForAllSecondaries(results);
+                    const snapshot = this.buildSnapshot();
+                    if (sceneJpeg)
+                        snapshot.eventThumbnail = sceneJpeg;
+                    this.eventManager.processResults(snapshot);
+                }
+                finally {
+                    await fetched[Symbol.asyncDispose]();
+                }
+            }
+            finally {
+                this.processingExternalSecondary = false;
+            }
+            return;
+        }
+        if (sensorType === SensorType.Motion) {
+            // Motion: fully gated during suppression. Frame-diff is fake during
+            // camera repositioning.
+            if (this.ptzAutotracker.suppressionActive)
+                return;
+            const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+            this.ingestDetectionResult(SensorType.Motion, sensorId, filtered);
+            this.eventManager.processResults(this.buildSnapshot());
+            this.fetchEventThumbnailAsync();
+            return;
+        }
+        // External secondaries (Face/Plate/Classifier/Clip with requiresFrames=false):
+        // direct ingest, no pixel work. For multi-provider types (Classifier), look
+        // up the owning pluginId for buffer keying.
+        let pluginId;
+        if (sensorType === SensorType.Classifier) {
+            const typePlugins = this.multiPlugins.get(SensorType.Classifier);
+            if (typePlugins) {
+                for (const plugin of typePlugins.values()) {
+                    if (plugin.sensorId === sensorId) {
+                        pluginId = plugin.pluginId;
+                        break;
+                    }
+                }
+            }
+        }
+        const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+        this.ingestDetectionResult(sensorType, sensorId, filtered, pluginId);
+        this.eventManager.processResults(this.buildSnapshot());
+    }
+    reportSensorTrigger(sensorId, triggerType, action, _sustained, timeoutSeconds) {
+        // Use namespaced dwell key so sensor trigger dwells don't overwrite
+        // the sensor's own properties (detected/blocked). Motion/audio sensors
+        // have their properties managed by dwell; contact/switch/light sensors don't.
+        const dwellKey = `trigger:${sensorId}`;
+        // Track active sensor trigger types for snapshot
+        if (action === 'activate') {
+            this.activeSensorTriggerTypes.set(dwellKey, triggerType);
+        }
+        // Dwell for event lifecycle — consistent with motion/audio.
+        // Activate: starts/extends the event. Deactivate: refreshes for cooldown window.
+        this.dwell.refresh(dwellKey, timeoutSeconds);
+        // Cascade for object-detection gating — only on activate
+        if (action === 'activate' && this.cascadeEnabled) {
+            this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+        }
+        // Flush immediately so EventManager sees the trigger (like reportSensorWrite)
+        this.eventManager.processResults(this.buildSnapshot());
+        // Async event-thumb fetch via snapshot URL — covers the trigger-only path
+        // (doorbell, contact sensor) where no loop frame is available to encode from.
+        // No-op if a loop frame already populated the thumb earlier.
+        if (action === 'activate') {
+            this.fetchEventThumbnailAsync();
+        }
+    }
+    reconcileSensorTriggers(activeSensorIds) {
+        const activeSet = new Set(activeSensorIds);
+        for (const dwellKey of this.activeSensorTriggerTypes.keys()) {
+            const sensorId = dwellKey.slice('trigger:'.length);
+            if (!activeSet.has(sensorId)) {
+                this.activeSensorTriggerTypes.delete(dwellKey);
+                this.dwell.clear(dwellKey);
+            }
+        }
+    }
+    clearMotionStateForSuppression() {
+        const cs = this.currentDetectionState;
+        cs.motion = undefined;
+        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
+        if (motionPlugin) {
+            this.writeSensorProperties(motionPlugin.sensorId, { detections: [] });
+        }
+    }
+    hasPlugin(sensorType) {
+        if (this.isMultiProvider(sensorType)) {
+            const typePlugins = this.multiPlugins.get(sensorType);
+            return typePlugins !== undefined && typePlugins.size > 0;
+        }
+        return this.singlePlugins.has(sensorType);
+    }
+    getPlugin(sensorType) {
+        return this.singlePlugins.get(sensorType);
+    }
+    getPluginsForType(sensorType) {
+        if (this.isMultiProvider(sensorType)) {
+            const typePlugins = this.multiPlugins.get(sensorType);
+            return typePlugins ? Array.from(typePlugins.values()) : [];
+        }
+        const plugin = this.singlePlugins.get(sensorType);
+        return plugin ? [plugin] : [];
+    }
+    getPlugins() {
+        const allPlugins = [];
+        for (const plugin of this.singlePlugins.values())
+            allPlugins.push(plugin);
+        for (const typePlugins of this.multiPlugins.values()) {
+            for (const plugin of typePlugins.values())
+                allPlugins.push(plugin);
+        }
+        return allPlugins;
+    }
+    hasAnyPlugins() {
+        if (this.singlePlugins.size > 0)
+            return true;
+        for (const typePlugins of this.multiPlugins.values()) {
+            if (typePlugins.size > 0)
+                return true;
+        }
+        return false;
+    }
+    isRunning() {
+        return this.loopRunning;
+    }
+    isStreaming() {
+        return this.frameSource.isStreaming;
+    }
+    hasSecondaryModelSpec(spec) {
+        return spec !== undefined && 'triggerLabels' in spec && Array.isArray(spec.triggerLabels);
+    }
+    isVideoInputSpec(spec) {
+        return spec != null && typeof spec === 'object' && 'width' in spec && 'height' in spec && 'format' in spec;
+    }
+    isOnEdge(box) {
+        return box.x < 0.02 || box.y < 0.02 || box.x + box.width > 0.98 || box.y + box.height > 0.98;
+    }
+    isAudioModelSpec(spec) {
+        return spec !== undefined && 'input' in spec && typeof spec.input === 'object' && 'sampleRate' in spec.input;
+    }
+    isMultiProvider(sensorType) {
+        return SENSOR_TYPE_CONFIG[sensorType]?.multiProvider === true;
+    }
+    // Video stream is permanently needed when: (1) frame-based motion detection, or
+    // (2) audio plugin + object plugin for continuous audio-triggered cascade.
+    // External motion (requiresFrames=false) and sensor cascade triggers use an ad-hoc
+    // video loop — started on-demand, stopped when cascade ends. This prevents blocking
+    // event-based cameras (e.g. Ring) that stop firing events while the stream is consumed.
+    shouldVideoBeActive() {
+        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
+        const objectPlugin = this.singlePlugins.get(SensorType.Object);
+        const audioPlugin = this.singlePlugins.get(SensorType.Audio);
+        if (motionPlugin?.requiresFrames)
+            return true;
+        if (audioPlugin && objectPlugin?.requiresFrames)
+            return true;
+        return false;
+    }
+    shouldAudioBeActive() {
+        const audioPlugin = this.singlePlugins.get(SensorType.Audio);
+        return audioPlugin?.requiresFrames === true;
+    }
+    startVideoLoop() {
+        if (this.loopRunning || this.videoStopPromise)
+            return;
+        this.logger.debug('Starting video detection loop');
+        this.loopRunning = true;
+        this.reconnectCount = 0;
+        this.loopPromise = this.runDetectionLoop();
+    }
+    async stopVideoLoop() {
+        if (!this.loopRunning) {
+            if (this.videoStopPromise)
+                await this.videoStopPromise;
+            return;
+        }
+        this.logger.debug('Stopping video detection loop');
+        this.loopRunning = false;
+        const doStop = async () => {
+            await this.frameSource.stop();
+            await this.loopPromise;
+            this.loopPromise = undefined;
+        };
+        this.videoStopPromise = doStop();
+        try {
+            await this.videoStopPromise;
+        }
+        finally {
+            this.videoStopPromise = undefined;
+        }
+    }
+    startAudioLoop() {
+        if (this.audioLoopRunning || this.audioStopPromise)
+            return;
+        this.logger.debug('Starting audio detection loop');
+        this.audioLoopRunning = true;
+        this.audioReconnectCount = 0;
+        this.audioLoopPromise = this.runAudioDetectionLoop();
+    }
+    async stopAudioLoop() {
+        if (!this.audioLoopRunning) {
+            if (this.audioStopPromise)
+                await this.audioStopPromise;
+            return;
+        }
+        this.logger.debug('Stopping audio detection loop');
+        this.audioLoopRunning = false;
+        const doStop = async () => {
+            await this.audioSource?.stop();
+            await this.audioLoopPromise;
+            this.audioLoopPromise = undefined;
+        };
+        this.audioStopPromise = doStop();
+        try {
+            await this.audioStopPromise;
+        }
+        finally {
+            this.audioStopPromise = undefined;
+        }
+    }
+    hasFrameBasedSecondary() {
+        const face = this.singlePlugins.get(SensorType.Face);
+        if (face?.requiresFrames)
+            return true;
+        const lpd = this.singlePlugins.get(SensorType.LicensePlate);
+        if (lpd?.requiresFrames)
+            return true;
+        const clip = this.singlePlugins.get(SensorType.Clip);
+        if (clip?.requiresFrames)
+            return true;
+        const classifiers = this.multiPlugins.get(SensorType.Classifier);
+        if (classifiers) {
+            for (const p of classifiers.values()) {
+                if (p.requiresFrames)
+                    return true;
+            }
+        }
+        return false;
+    }
+    needsAdHocLoop() {
+        const obj = this.singlePlugins.get(SensorType.Object);
+        if (!obj)
+            return false;
+        if (obj.requiresFrames)
+            return true;
+        return this.hasFrameBasedSecondary();
+    }
+    startAdHocVideoLoopIfNeeded() {
+        if (!this.loopRunning && this.needsAdHocLoop()) {
+            this.adHocVideoLoop = true;
+            this.logger.debug('Starting ad-hoc video loop for sensor cascade trigger');
+            this.startVideoLoop();
+        }
+    }
+    stopAdHocVideoLoopIfIdle() {
+        if (this.adHocVideoLoop && !this.shouldVideoBeActive()) {
+            this.adHocVideoLoop = false;
+            this.logger.debug('Stopping ad-hoc video loop — cascade ended');
+            this.stopVideoLoop();
+        }
+    }
+    fetchEventThumbnailAsync() {
+        void (async () => {
+            try {
+                const env_1 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const handle = __addDisposableResource(env_1, await this.frameSource.fetchSnapshotFrame(), true);
+                    if (!handle)
+                        return;
+                    const jpeg = await this.frameScaler.frameToJPEG(handle.frame, 320);
+                    if (!jpeg)
+                        return;
+                    this.eventManager.publishEventThumbnail(jpeg);
+                }
+                catch (e_1) {
+                    env_1.error = e_1;
+                    env_1.hasError = true;
+                }
+                finally {
+                    const result_1 = __disposeResources(env_1);
+                    if (result_1)
+                        await result_1;
+                }
+            }
+            catch (e) {
+                this.logger.debug('event-thumb snapshot failed:', e);
+            }
+        })();
+    }
+    calculateDBFS(data, format) {
+        let sumSquares = 0;
+        let sampleCount = 0;
+        if (format === 'float32') {
+            const floatView = new Float32Array(data.buffer, data.byteOffset, data.byteLength / 4);
+            sampleCount = floatView.length;
+            for (let i = 0; i < sampleCount; i++)
+                sumSquares += floatView[i] * floatView[i];
+        }
+        else {
+            // PCM16: normalize [-32768, 32767] → [-1.0, 1.0]
+            const int16View = new Int16Array(data.buffer, data.byteOffset, data.byteLength / 2);
+            sampleCount = int16View.length;
+            for (let i = 0; i < sampleCount; i++) {
+                const normalized = int16View[i] / 32768;
+                sumSquares += normalized * normalized;
+            }
+        }
+        if (sampleCount === 0)
+            return -100;
+        const rms = Math.sqrt(sumSquares / sampleCount);
+        return rms > 0 ? 20 * Math.log10(Math.max(rms, 1e-10)) : -100;
+    }
+    async runAudioDetectionLoop() {
+        const audioPlugin = this.singlePlugins.get(SensorType.Audio);
+        if (!audioPlugin?.requiresFrames)
+            return;
+        const audioSpec = this.isAudioModelSpec(audioPlugin.modelSpec) ? audioPlugin.modelSpec : undefined;
+        const sampleRate = audioSpec?.input.sampleRate ?? 16000;
+        const channels = audioSpec?.input.channels ?? 1;
+        const format = audioSpec?.input.format ?? 'float32';
+        const samplesPerFrame = audioSpec?.input.samplesPerFrame;
+        const audioConfig = {
+            streamUrl: this.config.audioStreamUrl,
+            sampleRate,
+            channels,
+            format,
+            samplesPerFrame,
+        };
+        while (this.audioLoopRunning) {
+            try {
+                this.audioSource = new AudioSource(audioConfig, this.logger);
+                await this.audioSource.start();
+                this.logger.debug('Audio stream connected, processing audio frames...');
+                this.audioReconnectCount = 0;
+                let frameCount = 0;
+                let lastAudioFrameId = -1;
+                while (this.audioLoopRunning) {
+                    const snap = await this.audioSource.nextFrame(lastAudioFrameId);
+                    if (!snap)
+                        break; // source ended (stop or EOF)
+                    lastAudioFrameId = snap.id;
+                    const rawFrame = snap.frame;
+                    frameCount++;
+                    try {
+                        const frameData = rawFrame.data;
+                        if (!frameData?.[0])
+                            continue;
+                        const rawData = frameData[0];
+                        const dBFS = this.calculateDBFS(rawData, format);
+                        if (dBFS < this.audioMinDecibels)
+                            continue;
+                        const audioFrame = {
+                            cameraId: this.config.cameraId,
+                            data: rawData,
+                            sampleRate,
+                            channels,
+                            format,
+                            timestamp: Date.now(),
+                        };
+                        const result = await audioPlugin.proxy.detectAudio(audioFrame);
+                        if (!result)
+                            continue;
+                        // Frame-based audio detection: cascade trigger when detected (Motion's
+                        // dwell counterpart for audio is handled in ingestDetectionResult).
+                        if (result.detected && this.cascadeEnabled) {
+                            const audioTimeout = this.config.detectionSettings.audio.timeout;
+                            this.cascade.triggerMomentary(audioTimeout);
+                        }
+                        // Funnel through the unified ingest path — same as external audio writes.
+                        this.ingestDetectionResult(SensorType.Audio, audioPlugin.sensorId, {
+                            detected: result.detected,
+                            detections: result.detections ?? [],
+                            ...(result.decibels !== undefined ? { decibels: result.decibels } : {}),
+                        });
+                    }
+                    catch (error) {
+                        this.logger.error('Audio detection error:', error);
+                    }
+                    finally {
+                        try {
+                            rawFrame[Symbol.dispose]?.();
+                        }
+                        catch {
+                            // Best effort
+                        }
+                    }
+                }
+                await this.audioSource.stop();
+                if (this.audioLoopRunning && frameCount === 0) {
+                    this.logger.debug('Audio stream ended without frames, waiting before reconnect...');
+                    await new Promise((resolve) => setTimeout(resolve, this.normalReconnectDelay));
+                }
+            }
+            catch (error) {
+                if (!this.audioLoopRunning)
+                    break;
+                await this.audioSource?.stop();
+                this.audioReconnectCount = Math.min(this.audioReconnectCount + 1, this.maxReconnectCount);
+                const delay = this.audioReconnectCount >= this.maxReconnectCount ? this.maxReconnectDelay : this.normalReconnectDelay;
+                this.logger.warn(`Audio stream error, reconnecting in ${delay / 1000}s: ${error.message}`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        await this.audioSource?.stop();
+        this.audioSource = undefined;
+        this.logger.debug('Audio detection loop ended');
+    }
+    async runDetectionLoop() {
+        while (this.loopRunning) {
+            try {
+                await this.frameSource.start();
+                this.frameScaler.updateHardwareContext(this.frameSource.hardwareContext);
+                this.logger.debug('Stream connected, processing frames...');
+                this.reconnectCount = 0;
+                let frameCount = 0;
+                let lastFrameId = -1;
+                while (this.loopRunning) {
+                    const snap = await this.frameSource.nextFrame(lastFrameId);
+                    if (!snap)
+                        break; // source ended (stop or EOF)
+                    lastFrameId = snap.id;
+                    frameCount++;
+                    try {
+                        await this.processRawFrame(snap.frame);
+                    }
+                    finally {
+                        try {
+                            snap.frame[Symbol.dispose]?.();
+                        }
+                        catch {
+                            // Best effort
+                        }
+                    }
+                }
+                await this.frameSource.stop();
+                this.frameScaler.clearCache();
+                if (this.loopRunning && frameCount === 0) {
+                    this.logger.debug('Stream ended without frames, waiting before reconnect...');
+                    await new Promise((resolve) => setTimeout(resolve, this.normalReconnectDelay));
+                }
+            }
+            catch (error) {
+                if (!this.loopRunning)
+                    break;
+                await this.frameSource.stop();
+                this.frameScaler.clearCache();
+                this.reconnectCount = Math.min(this.reconnectCount + 1, this.maxReconnectCount);
+                const delay = this.reconnectCount >= this.maxReconnectCount ? this.maxReconnectDelay : this.normalReconnectDelay;
+                this.logger.warn(`Stream error, reconnecting in ${delay / 1000}s: ${error.message}`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        await this.frameSource.stop();
+        this.frameScaler.clearCache();
+        this.logger.debug('Detection loop ended');
+    }
+    async processRawFrame(rawFrame) {
+        if (!this.loopRunning || !this.hasAnyPlugins())
+            return;
+        try {
+            await this.processDetection(rawFrame);
+        }
+        catch (error) {
+            this.logger.error('Detection processing error:', error);
+        }
+    }
+    async processDetection(rawFrame) {
+        const t0 = Date.now();
+        let motionDetected = false;
+        let objectDetections = [];
+        const results = { timestamp: t0 };
+        // Refresh ReID counters every frame while cascade is active so dead
+        // tracks never expire during the cascade window — exactly tied to
+        // cascade lifecycle, no estimated timeout needed.
+        if (this.cascade.isActive) {
+            this.pipeline.refreshReid();
+        }
+        // PTZ-suppression gating:
+        //  - Motion: skipped entirely. Frame-diff is genuinely wrong while the camera
+        //    is repositioning (whole scene "moves") — the detector produces garbage.
+        //  - Object: runs through the full pipeline unchanged. Norfair is fed the
+        //    per-frame PTZ pose delta (via `consumePoseDelta()`) so Kalman
+        //    predictions stay aligned with the world frame across pans — track ids
+        //    survive camera motion instead of being lost-and-re-acquired every
+        //    cycle. The autotracker itself gates motor decisions on its own
+        //    `isPtzMoving` state, so it doesn't issue commands during a pan.
+        const ptzSuppressed = this.ptzAutotracker.suppressionActive;
+        // 1. Motion detection — runs every frame whenever a motion plugin is registered,
+        // regardless of cascade state. Two reasons:
+        //   a) Motion sensor properties (bboxes shown in UI) need to stay fresh during cascade
+        //   b) Re-triggering cascade.triggerMomentary on each detected frame extends the cascade
+        //      naturally, so a sustained motion event keeps cascade alive as long as motion happens.
+        // The cascade is the gate for OBJECT detection, not for motion.
+        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
+        if (motionPlugin?.requiresFrames && !ptzSuppressed) {
+            const motionFrame = await this.scaleForMotion(rawFrame);
+            if (!this.loopRunning)
+                return;
+            if (motionFrame) {
+                try {
+                    const result = await motionPlugin.proxy.detectMotion(motionFrame);
+                    if (!this.loopRunning)
+                        return;
+                    if (result.detections.length > 0) {
+                        const filtered = this.pipeline.runMergeAndZoneFilter(result.detections);
+                        motionDetected = filtered.length > 0;
+                        results.motion = { ...result, detections: filtered };
+                    }
+                    else {
+                        // Plugin reports no motion this frame — record empty so UI clears stale bboxes
+                        results.motion = { detected: false, detections: [] };
+                    }
+                }
+                catch (error) {
+                    if (!this.loopRunning || isNoRespondersError(error))
+                        return;
+                    this.logger.error('Motion detection error:', error);
+                }
+            }
+        }
+        else if (this.cascade.isActive) {
+            // No frame-based motion plugin — cascade is the only motion-equivalent signal
+            motionDetected = true;
+            results.cascadeTriggered = true;
+        }
+        // Funnel motion result through unified ingest path (handles dwell + cascade + buffer + EventManager tick).
+        // `detected` is re-derived from post-zone-filter detections: if the plugin reported
+        // motion but the zone filter wiped all boxes, effective detected is false. The plugin's
+        // own `detected` flag is ignored on purpose — zone filtering wins.
+        if (results.motion && motionPlugin) {
+            this.ingestDetectionResult(SensorType.Motion, motionPlugin.sensorId, {
+                detected: motionDetected,
+                detections: results.motion.detections,
+            });
+        }
+        // 2. Object detection — runs only when the cascade is active (i.e. some
+        // wake source has fired: frame-based motion, external motion, audio, or
+        // a configured sensor trigger). When cascade is disabled in the camera
+        // config, runs unconditionally as an always-on detector.
+        //
+        // A motion plugin (frame-based OR external) must be registered for object
+        // detection to ever fire — without one, no wake source exists for object,
+        // so the cascade would never become active.
+        const objectPlugin = this.singlePlugins.get(SensorType.Object);
+        // Object detection runs during suppression too — the tracker stays alive
+        // across pans via Norfair's camera-motion compensation so autotracker
+        // keeps a stable lock. Without suppression: needs an active cascade (or
+        // cascade disabled globally).
+        const shouldDetectObjects = objectPlugin?.requiresFrames === true && (ptzSuppressed || !this.cascadeEnabled || this.cascade.isActive);
+        if (shouldDetectObjects) {
+            const objectFrame = await this.scaleForObject(rawFrame);
+            if (!this.loopRunning)
+                return;
+            if (objectFrame) {
+                try {
+                    const result = await objectPlugin.proxy.detectObjects(objectFrame);
+                    if (!this.loopRunning)
+                        return;
+                    // Full pipeline (always): NMS → merge → zone filter → track (with
+                    // appearance ReID) → line crossing. Runs even on empty-detection
+                    // frames so Norfair advances Kalman state and the autotracker sees
+                    // extrapolated positions instead of a momentary hole.
+                    //
+                    // The PTZ pose delta is handed to Norfair so Kalman predictions
+                    // are transformed into a world-stable frame — track ids survive
+                    // pans instead of going through LOST → REACQUIRE every cycle.
+                    const poseDelta = this.ptzAutotracker.consumePoseDelta();
+                    const pipelineResult = this.pipeline.process(result.detections, objectFrame, poseDelta);
+                    // Tracks for UI: matched always pass, extrapolated (Kalman-only)
+                    // are shown for smooth bbox display across single-frame detector
+                    // misses — but filtered when they've drifted too far off-frame.
+                    // When a fast-moving target walks off-screen, Norfair keeps
+                    // extrapolating based on the last-known velocity; without this
+                    // guard the UI ends up drawing ghost bboxes floating outside the
+                    // stream and the autotracker has no reason to chase them anyway.
+                    const visibleTracks = pipelineResult.tracked.filter((t) => {
+                        if (!t.trackLost)
+                            return true;
+                        const cx = t.box.x + t.box.width * 0.5;
+                        const cy = t.box.y + t.box.height * 0.5;
+                        return cx > -0.1 && cx < 1.1 && cy > -0.1 && cy < 1.1;
+                    });
+                    objectDetections = visibleTracks.filter((t) => !t.trackLost);
+                    results.object = { ...result, detections: visibleTracks };
+                    if (pipelineResult.crossings.length > 0)
+                        results.lineCrossings = pipelineResult.crossings;
+                    // Feed the autotracker with ALL tracked detections, incl. Kalman-
+                    // extrapolated ones. When the object detector misses a single frame
+                    // (normal with YOLO-style models), Norfair's extrapolation gives
+                    // the best estimate of where the target still is — hiding that
+                    // from the autotracker would cause a one-frame "target gone" blip
+                    // and flip it into LOST, only to REACQUIRE on the very next frame
+                    // when the detection returns. That churn is orthogonal to camera
+                    // motion and shouldn't drive state transitions. The autotracker
+                    // gates motor decisions on its own `isPtzMoving` flag, so during
+                    // suppression it observes without commanding.
+                    this.ptzAutotracker.handleObjectDetections(pipelineResult.tracked);
+                }
+                catch (error) {
+                    if (!this.loopRunning || isNoRespondersError(error))
+                        return;
+                    this.logger.error('Object detection error:', error);
+                }
+            }
+        }
+        if (results.lineCrossings && results.lineCrossings.length > 0) {
+            for (const c of results.lineCrossings) {
+                this.logger.debug(`Line crossing: ${c.label}#${c.trackId} crossed "${c.lineName}" dir=${c.direction} conf=${c.confidence.toFixed(2)}`);
+            }
+            // Buffer line crossings so the EventManager snapshot picks them up
+            this.currentDetectionState.lineCrossings = results.lineCrossings;
+        }
+        // Funnel object result through unified ingest path. Same rule as motion:
+        // detected is re-derived from post-pipeline detections, the plugin's own
+        // detected flag is ignored after pipeline filtering.
+        if (results.object && objectPlugin) {
+            this.ingestDetectionResult(SensorType.Object, objectPlugin.sensorId, {
+                detected: objectDetections.length > 0,
+                detections: results.object.detections,
+            });
+        }
+        if (!this.loopRunning)
+            return;
+        // 3. Secondary detectors + per-detection thumbnails. Result-collection only —
+        //    ingest happens via ingestResultsForAllSecondaries below so the loop tick
+        //    and the external-RPC path share the same secondary-processing helper.
+        if (objectDetections.length > 0) {
+            await this.runSecondariesAndThumbnails(rawFrame, objectDetections, results);
+        }
+        if (!this.loopRunning)
+            return;
+        // 4. Funnel secondary results through unified ingest path.
+        this.ingestResultsForAllSecondaries(results);
+        // 5. Single flush — one processResults per frame, AFTER all detectors + thumbnails.
+        // This ensures segment-start messages have thumbnails and all secondary detection
+        // data (faces, plates, classifiers, clips) is available when the segment opens.
+        if (!this.loopRunning)
+            return;
+        const snapshot = this.buildSnapshot();
+        if (results.thumbnails && results.thumbnails.length > 0) {
+            snapshot.thumbnails = results.thumbnails;
+        }
+        // 5a. Event-level thumbnail — full-frame downscaled JPEG. Generated lazily
+        // whenever the EventManager signals it still needs one. This covers two cases:
+        //   1. Event was already started by a non-frame path (sensor trigger, motion
+        //      ingest from a plugin) — first frame after start fills it in.
+        //   2. Event will be started by THIS frame's triggers — pre-encode so the
+        //      'start' message carries the thumbnail inline.
+        // We use `eventManagerWillStart` heuristically here: if there's a trigger
+        // signal in the snapshot AND no active event yet, the event will be started
+        // by this processResults call. Either way, attaching is harmless because
+        // EventManager only consumes it if `needsEventThumbnail` is true.
+        if (this.eventManager.needsThumbnail() || this.snapshotWillStartEvent(snapshot)) {
+            try {
+                const jpeg = await this.frameScaler.frameToJPEG(rawFrame, 320);
+                if (jpeg)
+                    snapshot.eventThumbnail = jpeg;
+            }
+            catch (error) {
+                this.logger.error('Event thumbnail generation error:', error);
+            }
+        }
+        this.eventManager.processResults(snapshot);
+    }
+    snapshotWillStartEvent(snapshot) {
+        if (this.eventManager.hasActiveEvent())
+            return false;
+        if (snapshot.motion?.detected)
+            return true;
+        if (snapshot.audio?.detected)
+            return true;
+        if (snapshot.cascadeTriggered)
+            return true;
+        if ((snapshot.sensorTriggers?.length ?? 0) > 0)
+            return true;
+        if ((snapshot.lineCrossings?.length ?? 0) > 0)
+            return true;
+        return false;
+    }
+    async resolveFaceIdentities(faces) {
+        const withEmbeddings = faces.filter((f) => f.embedding?.length);
+        if (!withEmbeddings.length)
+            return;
+        const facePlugin = this.singlePlugins.get(SensorType.Face);
+        const embeddingModel = facePlugin?.modelSpec?.embeddingModel;
+        if (!embeddingModel)
+            return;
+        const nvr = await this.getNvrProxy();
+        if (!nvr)
+            return;
+        try {
+            const embeddings = withEmbeddings.map((f) => f.embedding);
+            const matches = await nvr.matchFaces(embeddings, embeddingModel);
+            for (let i = 0; i < withEmbeddings.length; i++) {
+                if (matches[i]) {
+                    withEmbeddings[i].identity = matches[i].identity;
+                }
+            }
+        }
+        catch (error) {
+            if (!this.loopRunning || isNoRespondersError(error))
+                return;
+            this.logger.error('Could not resolve face identities:', error);
+        }
+    }
+    async scaleForMotion(rawFrame) {
+        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
+        if (!motionPlugin?.requiresFrames)
+            return undefined;
+        const maxWidth = MOTION_WIDTH_MAP[this.motionResolution];
+        const scaled = await this.frameScaler.scaleProportional(rawFrame, maxWidth, 'gray');
+        return scaled ? this.frameScaler.toVideoFrameData(scaled) : undefined;
+    }
+    async scaleForObject(rawFrame) {
+        const objectPlugin = this.singlePlugins.get(SensorType.Object);
+        if (!objectPlugin?.requiresFrames)
+            return undefined;
+        const inputSpec = objectPlugin.modelSpec?.input;
+        if (!this.isVideoInputSpec(inputSpec))
+            return undefined;
+        const scaled = await this.frameScaler.scaleToSpec(rawFrame, inputSpec);
+        return scaled ? this.frameScaler.toVideoFrameData(scaled) : undefined;
+    }
+    async prepareSecondaryRegions(rawFrame, objectDetections) {
+        const result = new Map();
+        // Collect all active secondary plugins and their requirements
+        const consumers = [];
+        const facePlugin = this.singlePlugins.get(SensorType.Face);
+        if (facePlugin && this.hasSecondaryModelSpec(facePlugin.modelSpec) && this.isVideoInputSpec(facePlugin.modelSpec.input)) {
+            consumers.push({ key: 'face', triggerLabels: facePlugin.modelSpec.triggerLabels, input: facePlugin.modelSpec.input });
+        }
+        const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
+        if (lpdPlugin && this.hasSecondaryModelSpec(lpdPlugin.modelSpec) && this.isVideoInputSpec(lpdPlugin.modelSpec.input)) {
+            consumers.push({ key: 'lpd', triggerLabels: lpdPlugin.modelSpec.triggerLabels, input: lpdPlugin.modelSpec.input });
+        }
+        const clipPlugin = this.singlePlugins.get(SensorType.Clip);
+        if (clipPlugin && this.hasSecondaryModelSpec(clipPlugin.modelSpec) && this.isVideoInputSpec(clipPlugin.modelSpec.input)) {
+            consumers.push({ key: 'clip', triggerLabels: clipPlugin.modelSpec.triggerLabels, input: clipPlugin.modelSpec.input });
+        }
+        const classifierPlugins = this.multiPlugins.get(SensorType.Classifier);
+        if (classifierPlugins) {
+            for (const [pluginId, classifierPlugin] of classifierPlugins) {
+                if (this.hasSecondaryModelSpec(classifierPlugin.modelSpec) && this.isVideoInputSpec(classifierPlugin.modelSpec.input)) {
+                    consumers.push({ key: `classifier:${pluginId}`, triggerLabels: classifierPlugin.modelSpec.triggerLabels, input: classifierPlugin.modelSpec.input });
+                }
+            }
+        }
+        if (consumers.length === 0)
+            return result;
+        // For each detection, determine which consumers need it and what sizes
+        for (const detection of objectDetections) {
+            const detLabel = detection.label.toLowerCase();
+            const targets = [];
+            for (const consumer of consumers) {
+                if (consumer.triggerLabels.length === 0 || consumer.triggerLabels.some((l) => l.toLowerCase() === detLabel)) {
+                    targets.push({ key: consumer.key, width: consumer.input.width, height: consumer.input.height, format: consumer.input.format });
+                }
+            }
+            if (targets.length === 0)
+                continue;
+            // Deduplicate targets with identical dimensions (e.g. two classifiers at same size)
+            // — keep first key, share the result
+            const uniqueTargets = [];
+            const dupeMap = new Map(); // sizeKey → [consumerKey, ...]
+            for (const t of targets) {
+                const sizeKey = `${t.width}x${t.height}_${t.format}`;
+                const existing = dupeMap.get(sizeKey);
+                if (existing) {
+                    existing.push(t.key);
+                }
+                else {
+                    dupeMap.set(sizeKey, [t.key]);
+                    uniqueTargets.push(t);
+                }
+            }
+            const regions = await this.frameScaler.cropAndScaleMulti(rawFrame, detection, uniqueTargets);
+            // Distribute results to all consumers (including those sharing dimensions)
+            for (const [_sizeKey, consumerKeys] of dupeMap) {
+                const primaryKey = consumerKeys[0];
+                const region = regions.get(primaryKey);
+                if (!region)
+                    continue;
+                for (const key of consumerKeys) {
+                    const list = result.get(key);
+                    if (list) {
+                        list.push(region);
+                    }
+                    else {
+                        result.set(key, [region]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    async runSecondaryDetection(type, results, fn) {
+        let detections = undefined;
+        try {
+            detections = await fn();
+        }
+        catch (error) {
+            if (!this.loopRunning || isNoRespondersError(error))
+                return;
+            const logType = type === SensorType.Face ? 'Face' : type === SensorType.LicensePlate ? 'License plate' : type === SensorType.Clip ? 'CLIP' : 'Classifier';
+            this.logger.error(`${logType} detection error:`, error);
+        }
+        if (!detections)
+            return;
+        if (type === SensorType.Face) {
+            results.face = detections;
+            await this.resolveFaceIdentities(results.face.detections);
+        }
+        else if (type === SensorType.LicensePlate) {
+            results.licensePlate = detections;
+        }
+        else if (type === SensorType.Clip) {
+            results.clip = detections;
+            const clipPlugin = this.singlePlugins.get(SensorType.Clip);
+            results.clipEmbeddingModel = clipPlugin?.modelSpec?.embeddingModel;
+        }
+        else if (type === SensorType.Classifier) {
+            results.classifiers ??= {};
+            for (const { pluginId, result } of detections) {
+                results.classifiers[pluginId] = result;
+            }
+            if (Object.keys(results.classifiers).length === 0)
+                delete results.classifiers;
+        }
+    }
+    ingestResultsForAllSecondaries(results) {
+        if (results.face) {
+            const facePlugin = this.singlePlugins.get(SensorType.Face);
+            if (facePlugin) {
+                this.ingestDetectionResult(SensorType.Face, facePlugin.sensorId, {
+                    detected: results.face.detected,
+                    detections: results.face.detections,
+                });
+            }
+        }
+        if (results.licensePlate) {
+            const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
+            if (lpdPlugin) {
+                this.ingestDetectionResult(SensorType.LicensePlate, lpdPlugin.sensorId, {
+                    detected: results.licensePlate.detected,
+                    detections: results.licensePlate.detections,
+                });
+            }
+        }
+        if (results.classifiers) {
+            const classifierPlugins = this.multiPlugins.get(SensorType.Classifier);
+            if (classifierPlugins) {
+                for (const [pluginId, classifierResult] of Object.entries(results.classifiers)) {
+                    const plugin = classifierPlugins.get(pluginId);
+                    if (plugin) {
+                        this.ingestDetectionResult(SensorType.Classifier, plugin.sensorId, {
+                            detected: classifierResult.detected,
+                            detections: classifierResult.detections,
+                        }, pluginId);
+                    }
+                }
+            }
+        }
+        if (results.clip) {
+            // Clip has no sensor properties — embeddings flow through buffer only.
+            this.currentDetectionState.clip = results.clip;
+            this.currentDetectionState.clipEmbeddingModel = results.clipEmbeddingModel;
+        }
+    }
+    async runSecondariesAndThumbnails(rawFrame, objectDetections, results) {
+        if (objectDetections.length === 0)
+            return;
+        const regionMap = await this.prepareSecondaryRegions(rawFrame, objectDetections);
+        await Promise.allSettled([
+            this.runSecondaryDetection(SensorType.Face, results, () => this.runFaceDetection(regionMap.get('face') ?? [])),
+            this.runSecondaryDetection(SensorType.LicensePlate, results, () => this.runLicensePlateDetection(regionMap.get('lpd') ?? [])),
+            this.runSecondaryDetection(SensorType.Classifier, results, () => this.runClassifierDetections(regionMap)),
+            this.runSecondaryDetection(SensorType.Clip, results, () => this.runClipDetection(regionMap.get('clip') ?? [])),
+        ]);
+        if (results.face?.detections.length) {
+            const facePlugin = this.singlePlugins.get(SensorType.Face);
+            results.faceEmbeddingModel = facePlugin?.modelSpec?.embeddingModel;
+            this.currentDetectionState.faceEmbeddingModel = results.faceEmbeddingModel;
+        }
+        try {
+            results.thumbnails = await this.generateThumbnails(rawFrame, objectDetections, results);
+        }
+        catch (error) {
+            this.logger.error('Thumbnail generation error:', error);
+        }
+    }
+    async runSecondariesFullFrame(rawFrame, results) {
+        const regionMap = await this.prepareFullFrameRegions(rawFrame);
+        if (regionMap.size > 0) {
+            await Promise.allSettled([
+                this.runSecondaryDetection(SensorType.Face, results, () => this.runFaceDetection(regionMap.get('face') ?? [])),
+                this.runSecondaryDetection(SensorType.LicensePlate, results, () => this.runLicensePlateDetection(regionMap.get('lpd') ?? [])),
+                this.runSecondaryDetection(SensorType.Classifier, results, () => this.runClassifierDetections(regionMap)),
+                this.runSecondaryDetection(SensorType.Clip, results, () => this.runClipDetection(regionMap.get('clip') ?? [])),
+            ]);
+            if (results.face?.detections.length) {
+                const facePlugin = this.singlePlugins.get(SensorType.Face);
+                results.faceEmbeddingModel = facePlugin?.modelSpec?.embeddingModel;
+                this.currentDetectionState.faceEmbeddingModel = results.faceEmbeddingModel;
+            }
+        }
+        try {
+            return await this.frameScaler.frameToJPEG(rawFrame, 320);
+        }
+        catch (error) {
+            this.logger.debug('Full-frame scene thumbnail failed:', error);
+            return null;
+        }
+    }
+    async prepareFullFrameRegions(rawFrame) {
+        const result = new Map();
+        const consumers = [];
+        const facePlugin = this.singlePlugins.get(SensorType.Face);
+        if (facePlugin?.requiresFrames && this.hasSecondaryModelSpec(facePlugin.modelSpec) && this.isVideoInputSpec(facePlugin.modelSpec.input)) {
+            consumers.push({ key: 'face', triggerLabels: facePlugin.modelSpec.triggerLabels, input: facePlugin.modelSpec.input });
+        }
+        const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
+        if (lpdPlugin?.requiresFrames && this.hasSecondaryModelSpec(lpdPlugin.modelSpec) && this.isVideoInputSpec(lpdPlugin.modelSpec.input)) {
+            consumers.push({ key: 'lpd', triggerLabels: lpdPlugin.modelSpec.triggerLabels, input: lpdPlugin.modelSpec.input });
+        }
+        const clipPlugin = this.singlePlugins.get(SensorType.Clip);
+        if (clipPlugin?.requiresFrames && this.hasSecondaryModelSpec(clipPlugin.modelSpec) && this.isVideoInputSpec(clipPlugin.modelSpec.input)) {
+            consumers.push({ key: 'clip', triggerLabels: clipPlugin.modelSpec.triggerLabels, input: clipPlugin.modelSpec.input });
+        }
+        const classifierPlugins = this.multiPlugins.get(SensorType.Classifier);
+        if (classifierPlugins) {
+            for (const [pluginId, plugin] of classifierPlugins) {
+                if (plugin.requiresFrames && this.hasSecondaryModelSpec(plugin.modelSpec) && this.isVideoInputSpec(plugin.modelSpec.input)) {
+                    consumers.push({ key: `classifier:${pluginId}`, triggerLabels: plugin.modelSpec.triggerLabels, input: plugin.modelSpec.input });
+                }
+            }
+        }
+        if (consumers.length === 0)
+            return result;
+        const frameWidth = rawFrame.width;
+        const frameHeight = rawFrame.height;
+        const fullFrameDetection = {
+            label: 'person',
+            confidence: 1.0,
+            box: { x: 0, y: 0, width: 1, height: 1 },
+        };
+        for (const consumer of consumers) {
+            const scaled = await this.frameScaler.scaleToSpec(rawFrame, consumer.input);
+            if (!scaled)
+                continue;
+            const region = {
+                frame: this.frameScaler.toVideoFrameData(scaled, `fullframe:${consumer.key}`),
+                detection: fullFrameDetection,
+                offset: { x: 0, y: 0 },
+                cropSize: { width: frameWidth, height: frameHeight },
+                originalSize: { width: frameWidth, height: frameHeight },
+            };
+            result.set(consumer.key, [region]);
+        }
+        return result;
+    }
+    prepareSecondaryFrames(croppedRegions) {
+        return croppedRegions.map((r, i) => ({ ...r.frame, id: String(i), label: r.detection.label }));
+    }
+    async runFaceDetection(croppedRegions) {
+        const facePlugin = this.singlePlugins.get(SensorType.Face);
+        if (!facePlugin || croppedRegions.length === 0)
+            return undefined;
+        const batchResults = await facePlugin.proxy.detectFaces(this.prepareSecondaryFrames(croppedRegions));
+        const allFaces = [];
+        for (let i = 0; i < batchResults.length; i++) {
+            const parentTrackId = 'trackId' in croppedRegions[i].detection ? croppedRegions[i].detection.trackId : undefined;
+            for (const face of batchResults[i].detections) {
+                const transformed = this.transformBoxToOriginal(face.box, croppedRegions[i]);
+                allFaces.push({ ...face, box: transformed, parentTrackId });
+            }
+        }
+        if (allFaces.length === 0)
+            return { detected: false, detections: [] };
+        // NMS only — zone filter is skipped because face crops come from
+        // object detections that already passed zone filtering in process().
+        const deduped = this.pipeline.runNms(allFaces);
+        return { detected: deduped.length > 0, detections: deduped };
+    }
+    async runLicensePlateDetection(croppedRegions) {
+        const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
+        if (!lpdPlugin || croppedRegions.length === 0)
+            return undefined;
+        const batchResults = await lpdPlugin.proxy.detectLicensePlates(this.prepareSecondaryFrames(croppedRegions));
+        const allPlates = [];
+        for (let i = 0; i < batchResults.length; i++) {
+            const parentTrackId = 'trackId' in croppedRegions[i].detection ? croppedRegions[i].detection.trackId : undefined;
+            for (const plate of batchResults[i].detections) {
+                allPlates.push({ ...plate, box: this.transformBoxToOriginal(plate.box, croppedRegions[i]), parentTrackId });
+            }
+        }
+        if (allPlates.length === 0)
+            return { detected: false, detections: [] };
+        // NMS only — zone filter skipped (crops from already-filtered object boxes).
+        const deduped = this.pipeline.runNms(allPlates);
+        return { detected: deduped.length > 0, detections: deduped };
+    }
+    runClassifierDetections(regionMap) {
+        const classifierPlugins = this.multiPlugins.get(SensorType.Classifier);
+        if (!classifierPlugins || classifierPlugins.size === 0)
+            return [];
+        const promises = [];
+        for (const [pluginId, classifierPlugin] of classifierPlugins) {
+            const croppedRegions = regionMap.get(`classifier:${pluginId}`);
+            if (!croppedRegions || croppedRegions.length === 0)
+                continue;
+            const runClassifier = async () => {
+                const batchResults = await classifierPlugin.proxy.detectClassifications(this.prepareSecondaryFrames(croppedRegions));
+                const allDetections = [];
+                for (let i = 0; i < batchResults.length; i++) {
+                    const parentTrackId = 'trackId' in croppedRegions[i].detection ? croppedRegions[i].detection.trackId : undefined;
+                    for (const detection of batchResults[i].detections) {
+                        allDetections.push({ ...detection, box: this.transformBoxToOriginal(detection.box, croppedRegions[i]), parentTrackId });
+                    }
+                }
+                if (allDetections.length === 0)
+                    return undefined;
+                const deduped = this.pipeline.runNms(allDetections);
+                if (deduped.length === 0)
+                    return undefined;
+                return { pluginId, result: { detected: true, detections: deduped } };
+            };
+            promises.push(runClassifier());
+        }
+        return promises;
+    }
+    async runClipDetection(croppedRegions) {
+        const clipPlugin = this.singlePlugins.get(SensorType.Clip);
+        if (!clipPlugin || croppedRegions.length === 0)
+            return undefined;
+        const batchResults = await clipPlugin.proxy.detectEmbeddings(this.prepareSecondaryFrames(croppedRegions));
+        const allEmbeddings = [];
+        for (let i = 0; i < batchResults.length; i++) {
+            if (batchResults[i].embeddings && batchResults[i].embeddings.length > 0) {
+                const parentTrackId = 'trackId' in croppedRegions[i].detection ? croppedRegions[i].detection.trackId : undefined;
+                for (const emb of batchResults[i].embeddings) {
+                    const transformed = this.transformBoxToOriginal(emb.box, croppedRegions[i]);
+                    allEmbeddings.push({ ...emb, box: transformed, parentTrackId });
+                }
+            }
+        }
+        if (allEmbeddings.length === 0)
+            return undefined;
+        const embeddingModel = clipPlugin.modelSpec?.embeddingModel ?? '';
+        return { embeddings: allEmbeddings, embeddingModel };
+    }
+    async generateThumbnails(rawFrame, objectDetections, results) {
+        const thumbnails = [];
+        // Object thumbnails — objectDetections are TrackedDetection[] when tracker ran
+        const objectCrops = await this.frameScaler.cropToJPEG(rawFrame, objectDetections);
+        for (const crop of objectCrops) {
+            const detection = objectDetections[crop.index];
+            if (detection) {
+                thumbnails.push({
+                    label: detection.label,
+                    score: detection.confidence,
+                    jpeg: crop.jpeg,
+                    area: detection.box.width * detection.box.height,
+                    onEdge: this.isOnEdge(detection.box),
+                    trackId: 'trackId' in detection ? detection.trackId : undefined,
+                    speed: 'trackSpeed' in detection ? detection.trackSpeed : undefined,
+                });
+            }
+        }
+        if (results.face?.detections) {
+            const faceCrops = await this.frameScaler.cropToJPEG(rawFrame, results.face.detections, { padding: 0.1 });
+            for (const crop of faceCrops) {
+                const detection = results.face.detections[crop.index];
+                if (detection) {
+                    // Set thumbnail on the detection itself so enrichSegment can inline it
+                    // for unknown faces (needed for face store persistence).
+                    detection.thumbnail ??= crop.jpeg;
+                    thumbnails.push({
+                        label: `face:${detection.identity ?? 'unknown'}`,
+                        score: detection.confidence,
+                        jpeg: crop.jpeg,
+                        area: detection.box.width * detection.box.height,
+                        onEdge: this.isOnEdge(detection.box),
+                    });
+                }
+            }
+        }
+        if (results.licensePlate?.detections) {
+            const plateCrops = await this.frameScaler.cropToJPEG(rawFrame, results.licensePlate.detections, { padding: 0.1 });
+            for (const crop of plateCrops) {
+                const detection = results.licensePlate.detections[crop.index];
+                if (detection) {
+                    thumbnails.push({
+                        label: `plate:${detection.plateText ?? 'unknown'}`,
+                        score: detection.confidence,
+                        jpeg: crop.jpeg,
+                        area: detection.box.width * detection.box.height,
+                        onEdge: this.isOnEdge(detection.box),
+                    });
+                }
+            }
+        }
+        if (results.classifiers) {
+            for (const classifierResult of Object.values(results.classifiers)) {
+                const clsCrops = await this.frameScaler.cropToJPEG(rawFrame, classifierResult.detections);
+                for (const crop of clsCrops) {
+                    const detection = classifierResult.detections[crop.index];
+                    if (detection) {
+                        thumbnails.push({
+                            label: `class:${detection.label}`,
+                            score: detection.confidence,
+                            jpeg: crop.jpeg,
+                            area: detection.box.width * detection.box.height,
+                            onEdge: this.isOnEdge(detection.box),
+                        });
+                    }
+                }
+            }
+        }
+        return thumbnails;
+    }
+    transformBoxToOriginal(box, region) {
+        // box coordinates are normalized (0-1) relative to the scaled frame (e.g. 320x320),
+        // but must be mapped back through the original crop dimensions (before scaling)
+        const pixelX = box.x * region.cropSize.width + region.offset.x;
+        const pixelY = box.y * region.cropSize.height + region.offset.y;
+        const pixelW = box.width * region.cropSize.width;
+        const pixelH = box.height * region.cropSize.height;
+        return {
+            x: pixelX / region.originalSize.width,
+            y: pixelY / region.originalSize.height,
+            width: pixelW / region.originalSize.width,
+            height: pixelH / region.originalSize.height,
+        };
+    }
+    getNvrProxy() {
+        if (this.nvrProxy)
+            return Promise.resolve(this.nvrProxy);
+        this.nvrProxyPromise ??= this.resolveNvrProxy().finally(() => {
+            this.nvrProxyPromise = undefined;
+        });
+        return this.nvrProxyPromise;
+    }
+    async resolveNvrProxy() {
+        try {
+            const coreManagerProxy = this.proxy.createProxy(NamespaceManager.coreManagerNamespaces().coreManagerRpc);
+            const plugin = await coreManagerProxy.getPlugin('@camera.ui/camera-ui-nvr');
+            if (!plugin) {
+                return undefined;
+            }
+            const ns = NamespaceManager.pluginNamespaces(plugin.id);
+            const connection = this.proxy.createProxy(ns.pluginChildRpc, { isolatedConnection: true });
+            this.nvrProxy = connection.proxy;
+            return this.nvrProxy;
+        }
+        catch (error) {
+            this.logger.error('NVR proxy resolution failed:', error);
+            return undefined;
+        }
+    }
+};
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], DetectionCoordinator.prototype, "onSensorAdded", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], DetectionCoordinator.prototype, "onSensorRemoved", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", void 0)
+], DetectionCoordinator.prototype, "onSensorCapabilitiesChanged", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], DetectionCoordinator.prototype, "reportSensorWrite", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Boolean, Number]),
+    __metadata("design:returntype", void 0)
+], DetectionCoordinator.prototype, "reportSensorTrigger", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], DetectionCoordinator.prototype, "reconcileSensorTriggers", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], DetectionCoordinator.prototype, "hasPlugin", null);
+DetectionCoordinator = __decorate([
+    RPCClass,
+    __metadata("design:paramtypes", [Object, Object, Function])
+], DetectionCoordinator);
+export { DetectionCoordinator };
+//# sourceMappingURL=detection-coordinator.js.map