@camera.ui/server 2.0.10 → 2.0.12

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

@@ -1,4 +1,3 @@
-/* eslint-disable @stylistic/max-len */
 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);
@@ -8,154 +7,56 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { PromiseTimeout, sleep } from '@camera.ui/common/utils';
 import { isNoRespondersError, RPCClass, RPCMethod } from '@camera.ui/rpc';
 import { SensorType } from '@camera.ui/sdk';
 import { NamespaceManager } from '../../rpc/namespaces.js';
-import { DETECTION_SENSOR_TYPES, SENSOR_TYPE_CONFIG } from '../sensors/types.js';
+import { DETECTION_SENSOR_TYPES } from '../sensors/types.js';
 import { normalizeZone } from '../utils/filter.js';
-import { AudioSource } from './audio-source.js';
+import { AudioDetectionLoop } from './audio-loop.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 { EventThumbnailer } from './event-thumbnailer.js';
 import { FrameScaler } from './frame-scaler.js';
-import { FrameSource } from './frame-source.js';
-import { PtzAutotracker } from './ptz-autotracker.js';
-import { SnapshotSource } from './snapshot-source.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;
+import { isVideoInputSpec, PluginRegistry } from './plugin-registry.js';
+import { PtzAutotracker } from './ptz/autotracker.js';
+import { ReconnectBackoff } from './reconnect-backoff.js';
+import { SecondaryStage } from './secondary-stage.js';
+import { FrameSource } from './sources/frame-source.js';
+import { StationarySuppressor } from './stationary-suppressor.js';
+import { DETECT_TIMEOUT_MS, MOTION_WIDTH_MAP } from './types.js';
+const DEFAULT_CASCADE_TIMEOUT = 10;
 const OBJECT_DWELL_SECONDS = 2;
-const DETECT_TIMEOUT_MS = 30_000;
-const EVENT_THUMB_MAX_WIDTH = 640;
-const DETECTION_THUMB_MAX_WIDTH = 640;
-const DETECTION_THUMB_MIN_CROP = 160;
-const DETECTION_THUMB_HQ_MAX_WIDTH = 640;
-const DETECTION_THUMB_HQ_MIN_CROP = 640;
-const DETECTION_THUMB_HQ_QUALITY = 80;
-const ATTRIBUTE_THUMB_MAX_WIDTH = 640;
-const ATTRIBUTE_THUMB_MIN_CROP = 128;
-const EVENT_THUMB_HQ_MAX_WIDTH = 960;
-const EVENT_THUMB_HQ_QUALITY = 75;
-const HQ_FRAME_MAX_AGE_MS = 500;
-async function withTimeout(promise, ms, label) {
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => reject(new Error(`${label} detection timed out after ${ms}ms`)), ms);
-    });
-    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
-}
+const SECONDARY_BBOX_TTL_MS = 2000;
 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;
+    plugins = new PluginRegistry();
+    pipeline;
+    stationary;
+    secondaries;
+    thumbnailer;
+    audioLoop;
     ptzAutotracker;
     eventManager;
     cascade = new CascadeManager();
     dwell = new DwellManager();
-    pipeline;
+    videoBackoff = new ReconnectBackoff();
+    loopRunning = false;
+    loopPromise;
+    videoStopPromise;
     adHocVideoLoop = false;
     processingExternalSecondary = false;
-    hqSnapshotSource;
-    hqUpgradeInflight = false;
-    hqAspectWarned = false;
     cascadeUnsubscribe;
     dwellUnsubscribe;
-    seenStationaryTracks = new Set();
     activeSensorTriggerTypes = new Map();
+    secondaryBboxSeen = 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;
@@ -165,25 +66,42 @@ let DetectionCoordinator = class DetectionCoordinator {
             snapshotUrl: config.snapshotUrl,
             fps: this.config.frameWorkerSettings.fps,
         };
+        if (config.controllerSnapshotSourceId) {
+            const sourceId = config.controllerSnapshotSourceId;
+            const controllerProxy = this.proxy.createProxy(NamespaceManager.cameraNamespaces(config.cameraId).cameraControllerRpc);
+            frameSourceConfig.snapshotProvider = async () => {
+                const jpeg = await controllerProxy.snapshot(sourceId, true);
+                if (!jpeg || jpeg.byteLength === 0)
+                    return null;
+                return Buffer.from(jpeg);
+            };
+        }
         this.frameSource = new FrameSource(frameSourceConfig, logger);
         this.frameScaler = new FrameScaler(null, logger);
         this.pipeline = new DetectionPipeline(config.zones, config.detectionSettings);
-        const hqUrl = this.resolveHqSourceUrl(config.availableSources);
-        if (hqUrl) {
-            this.hqSnapshotSource = new SnapshotSource({ url: hqUrl }, logger);
-        }
-        this.syncHqSnapshotSource();
+        this.stationary = new StationarySuppressor(logger);
+        this.secondaries = new SecondaryStage(this.plugins, this.pipeline, this.frameScaler, this.proxy, logger, () => !this.loopRunning);
         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.thumbnailer = new EventThumbnailer({ frameSource: this.frameSource, frameScaler: this.frameScaler, eventManager: this.eventManager, logger }, config.availableSources);
+        this.thumbnailer.sync(this.config.frameWorkerSettings.hqSnapshots === true);
+        this.audioLoop = new AudioDetectionLoop({
+            cameraId: config.cameraId,
+            getPlugin: () => this.plugins.get(SensorType.Audio),
+            getStreamUrl: () => this.config.audioStreamUrl,
+            getMinDecibels: () => this.config.detectionSettings.audio.minDecibels,
+            onResult: (sensorId, result) => this.handleAudioLoopResult(sensorId, result),
+        }, logger);
         this.ptzAutotracker = new PtzAutotracker({
             logger: this.logger,
             proxy: this.proxy,
             cameraId: this.config.cameraId,
             settings: this.config.ptzAutotrack,
-            onSuppressionActivated: () => this.clearMotionStateForSuppression(),
+            getFps: () => this.targetFps,
+            onSuppressionActivated: () => this.handleSuppressionActivated(),
         });
         this.cascadeUnsubscribe = this.cascade.onChange((event) => {
             if (event.type === 'activated') {
@@ -199,8 +117,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         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.
+                // sensor triggers (contact/switch/light) manage their own detected/blocked
                 if (!isSensorTrigger) {
                     this.writeSensorProperties(event.sensorId, {
                         detected: true,
@@ -220,8 +137,204 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         });
     }
+    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;
+        this.thumbnailer.sync(settings.hqSnapshots === true);
+    }
+    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.audioLoop.stop();
+        await this.thumbnailer.stop();
+        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 reportSensorWrite(sensorId, sensorType, properties) {
+        if (sensorType === SensorType.Object) {
+            const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+            // presence feed keeps the autotracker's return-home timer alive even while
+            // suppression gates everything below
+            const externalDetections = filtered.detections ?? [];
+            this.ptzAutotracker.handlePresenceDetections(externalDetections);
+            if (this.ptzAutotracker.suppressionActive)
+                return;
+            this.ingestDetectionResult(SensorType.Object, sensorId, filtered);
+            this.eventManager.processResults(this.buildSnapshot());
+            if (!this.plugins.hasFrameBasedSecondary()) {
+                // re-shoot the event thumbnail: smart-camera reports arrive after the
+                // motion-start shot, often before the subject fully entered the frame
+                if (filtered.detected === true && this.eventManager.hasActiveEvent()) {
+                    this.thumbnailer.fetchEventThumbnailAsync();
+                }
+                return;
+            }
+            if (this.processingExternalSecondary)
+                return; // previous RPC still running
+            this.processingExternalSecondary = true;
+            try {
+                // processExternal only adapts the shape, external boxes get no real tracking
+                const rawExternal = filtered.detections ?? [];
+                const objectDetections = this.pipeline.processExternal(rawExternal);
+                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;
+                }
+                const fetched = await this.frameSource.fetchSnapshotFrame();
+                if (!fetched)
+                    return;
+                try {
+                    const results = { timestamp: Date.now() };
+                    const sceneJpeg = await this.secondaries.detectFullFrame(fetched.frame, results);
+                    this.ingestResultsForAllSecondaries(results);
+                    const snapshot = this.buildSnapshot();
+                    if (sceneJpeg)
+                        snapshot.eventThumbnail = sceneJpeg;
+                    const wantsEventThumb = this.eventManager.needsThumbnail() || this.snapshotWillStartEvent(snapshot);
+                    this.eventManager.processResults(snapshot);
+                    if (wantsEventThumb) {
+                        this.thumbnailer.upgradeEventThumbnailAsync();
+                    }
+                }
+                finally {
+                    await fetched[Symbol.asyncDispose]();
+                }
+            }
+            finally {
+                this.processingExternalSecondary = false;
+            }
+            return;
+        }
+        if (sensorType === SensorType.Motion) {
+            // frame-diff is garbage while the PTZ repositions
+            if (this.ptzAutotracker.suppressionActive)
+                return;
+            const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+            this.ingestDetectionResult(SensorType.Motion, sensorId, filtered);
+            this.eventManager.processResults(this.buildSnapshot());
+            this.thumbnailer.fetchEventThumbnailAsync();
+            return;
+        }
+        // classifier is multi-provider, buffer keying needs the owning pluginId
+        let pluginId;
+        if (sensorType === SensorType.Classifier) {
+            pluginId = this.plugins.getAll(SensorType.Classifier).find((p) => p.sensorId === sensorId)?.pluginId;
+        }
+        const filtered = this.applyExternalDetectionFilters(sensorType, properties);
+        this.ingestDetectionResult(sensorType, sensorId, filtered, pluginId);
+        this.eventManager.processResults(this.buildSnapshot());
+    }
+    reportSensorTrigger(sensorId, triggerType, action, _sustained, timeoutSeconds) {
+        // namespaced so trigger dwells don't overwrite the sensor's own detected/blocked
+        const dwellKey = `trigger:${sensorId}`;
+        if (action === 'activate') {
+            this.activeSensorTriggerTypes.set(dwellKey, triggerType);
+        }
+        this.dwell.refresh(dwellKey, timeoutSeconds);
+        if (action === 'activate' && this.cascadeEnabled) {
+            this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
+        }
+        this.eventManager.processResults(this.buildSnapshot());
+        // no loop frame to encode from, fetch async (no-op if already captured)
+        if (action === 'activate') {
+            this.thumbnailer.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);
+            }
+        }
+    }
+    hasPlugin(sensorType) {
+        return this.plugins.has(sensorType);
+    }
+    get cascadeEnabled() {
+        return this.config.detectionSettings.cascadeDetection !== false;
+    }
+    get cascadeTimeoutSeconds() {
+        return this.config.detectionSettings.cascadeTimeout ?? DEFAULT_CASCADE_TIMEOUT;
+    }
+    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;
+    }
     handleCascadeDeactivated() {
-        // Clear cascade-gated buffer slots but keep motion/audio intact
+        // clear cascade-gated buffer slots, keep motion/audio
         const cs = this.currentDetectionState;
         cs.object = undefined;
         cs.face = undefined;
@@ -230,31 +343,46 @@ let DetectionCoordinator = class DetectionCoordinator {
         cs.clip = undefined;
         cs.lineCrossings = undefined;
         cs.cascadeTriggered = undefined;
-        // Publish empty detections for all cascade-gated sensors so UI clears bboxes
+        // publish empty detections so the UI clears stale 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 });
-            }
+        for (const type of [SensorType.Object, SensorType.Face, SensorType.LicensePlate]) {
+            const plugin = this.plugins.get(type);
+            if (plugin)
+                clearTargets.push(plugin.sensorId);
         }
-        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 plugin of this.plugins.getAll(SensorType.Classifier)) {
+            clearTargets.push(plugin.sensorId);
         }
-        for (const { sensorId } of clearTargets) {
+        for (const sensorId of clearTargets) {
             this.writeSensorProperties(sensorId, { detected: false, detections: [] });
+            this.secondaryBboxSeen.delete(sensorId);
         }
-        // Tick EventManager — segment ends but event continues (motion still active)
+        // segment ends here, the event itself continues while motion is active
         this.eventManager.processResults(this.buildSnapshot());
     }
     handleEventEnded() {
-        this.pipeline.cleanup();
-        this.seenStationaryTracks.clear();
+        if (this.config.detectionSettings.object.suppressStatic ?? true) {
+            this.stationary.retainAcrossEvent((trackIds) => this.pipeline.retainTracks(trackIds));
+        }
+        else {
+            this.pipeline.cleanup();
+            this.stationary.clear();
+        }
+        this.stationary.resetEventState();
         this.activeSensorTriggerTypes.clear();
         this.currentDetectionState = {};
     }
+    handleAudioLoopResult(sensorId, result) {
+        // only the cascade trigger lives here, the audio dwell is handled in ingest
+        if (result.detected && this.cascadeEnabled) {
+            this.cascade.triggerMomentary(this.config.detectionSettings.audio.timeout);
+        }
+        this.ingestDetectionResult(SensorType.Audio, sensorId, {
+            detected: result.detected,
+            detections: result.detections ?? [],
+            ...(result.decibels !== undefined ? { decibels: result.decibels } : {}),
+        });
+    }
     writeSensorProperties(sensorId, properties) {
         const msg = {
             sensorId,
@@ -301,9 +429,12 @@ let DetectionCoordinator = class DetectionCoordinator {
         return result;
     }
     applyExternalDetectionFilters(sensorType, properties) {
-        const detections = properties.detections;
-        if (!Array.isArray(detections) || detections.length === 0)
+        const raw = properties.detections;
+        if (!Array.isArray(raw) || raw.length === 0)
             return properties;
+        // older/third-party plugins can send box-less detections, but the zone
+        // filter and rust merge assume a box on every detection
+        const detections = raw.map((detection) => (detection.box ? detection : { ...detection, box: { x: 0, y: 0, width: 1, height: 1 } }));
         let filtered;
         switch (sensorType) {
             case SensorType.Face:
@@ -318,7 +449,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                 filtered = this.pipeline.runZoneFilter(detections);
                 break;
             default:
-                return properties; // Audio etc — no zone filter
+                return { ...properties, detections }; // audio etc, no zone filter
         }
         return {
             ...properties,
@@ -326,13 +457,10 @@ let DetectionCoordinator = class DetectionCoordinator {
             detected: filtered.length > 0,
         };
     }
-    // PTZ-suppression gating happens upstream — callers decide whether a write
-    // belongs in the full pipeline or autotracker-only.
+    // PTZ-suppression gating happens upstream, callers decide what gets in here
     ingestDetectionResult(sensorType, sensorId, properties, pluginId) {
         this.updateBufferForType(sensorType, properties, pluginId);
         const detected = properties.detected === true;
-        // Motion/Audio: dwell drives the detected/blocked/lastTriggered lifecycle
-        // entirely (see dwell.onChange in the constructor); motion also cascades.
         if (sensorType === SensorType.Motion && detected) {
             const motionTimeout = this.config.detectionSettings.motion.timeout;
             this.dwell.refresh(sensorId, motionTimeout);
@@ -348,44 +476,25 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         }
         else if (sensorType === SensorType.Object && detected) {
-            // Object dwell — anti-chatter: a single missed frame must not split the
-            // event. Stationary tracks refresh the dwell only ONCE (first sighting);
-            // afterwards they're in seenStationaryTracks and don't count, so parked
-            // cars/bikes can't keep events alive forever. Moving tracks always count.
-            // The set is cleared on cascade deactivate (event boundary).
+            // the dwell bridges single missed frames; anchored stationary tracks
+            // don't refresh it, so parked objects can't hold events open
             const detections = properties.detections ?? [];
-            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)) {
-                        this.seenStationaryTracks.add(t.trackId);
-                        hasActiveTrack = true;
-                    }
-                }
-                else {
-                    hasActiveTrack = true;
-                }
-            }
-            if (hasActiveTrack) {
+            if (this.stationary.evaluate(detections)) {
                 this.dwell.refresh(sensorId, OBJECT_DWELL_SECONDS);
             }
             else {
-                // Only known stationary tracks — suppress detected and clear buffered
-                // detections so the EventManager doesn't open a new segment; the UI
-                // still gets the bboxes via the property publish below.
+                // clear detected + buffer so no segment opens, the UI still gets
+                // the bboxes via the property publish below
                 properties.detected = false;
                 if (this.currentDetectionState.object) {
                     this.currentDetectionState.object.detected = false;
                     this.currentDetectionState.object.detections = [];
                 }
+                this.stationary.logSuppressedOnce(detections);
             }
         }
-        // Dwell is the SOLE owner of detected/blocked/lastTriggered for these
-        // types — a "no detection" frame must not overwrite the dwell-set state,
-        // so strip them from the publish; dwell.onChange is the only writer.
+        // dwell owns detected/blocked/lastTriggered for these types, a no-detection
+        // frame would overwrite the dwell-set state, so strip before publishing
         let publishProps = properties;
         if (sensorType === SensorType.Motion || sensorType === SensorType.Audio || sensorType === SensorType.Object) {
             const { detected: _d, blocked: _b, lastTriggered: _t, ...rest } = properties;
@@ -394,7 +503,16 @@ let DetectionCoordinator = class DetectionCoordinator {
         if (Object.keys(publishProps).length > 0) {
             this.writeSensorProperties(sensorId, publishProps);
         }
-        // EventManager is NOT ticked here — processDetection flushes once per frame.
+        if (sensorType === SensorType.Face || sensorType === SensorType.LicensePlate || sensorType === SensorType.Classifier) {
+            const detections = properties.detections ?? [];
+            if (detections.length > 0) {
+                this.secondaryBboxSeen.set(sensorId, Date.now());
+            }
+            else {
+                this.secondaryBboxSeen.delete(sensorId);
+            }
+        }
+        // no EventManager tick here, processDetection flushes once per frame
     }
     updateBufferForType(sensorType, properties, pluginId) {
         const cs = this.currentDetectionState;
@@ -431,374 +549,104 @@ let DetectionCoordinator = class DetectionCoordinator {
                 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;
-        this.syncHqSnapshotSource();
-    }
-    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();
-        await this.hqSnapshotSource?.stop();
-        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 registerDetectionPluginInternal(sensor) {
+        if (this.videoStopPromise)
+            await this.videoStopPromise;
+        await this.audioLoop.waitForStop();
+        const wasVideoNeeded = this.plugins.shouldVideoBeActive();
+        const wasAudioNeeded = this.plugins.shouldAudioBeActive();
+        const namespaces = NamespaceManager.sensorProviderNamespaces(sensor.pluginId, this.config.cameraId, sensor.sensorId);
+        const sensorProxy = this.proxy.createProxy(namespaces.sensorRpc);
+        const registered = this.plugins.register({
+            pluginId: sensor.pluginId,
+            sensorId: sensor.sensorId,
+            sensorType: sensor.sensorType,
+            requiresFrames: sensor.requiresFrames,
+            modelSpec: sensor.modelSpec,
+            proxy: sensorProxy,
+        });
+        if (!registered)
+            return;
+        this.logger.trace(`Plugin registered: ${sensor.pluginId} for ${sensor.sensorType}`);
+        if (!wasVideoNeeded && this.plugins.shouldVideoBeActive()) {
+            this.adHocVideoLoop = false;
+            this.startVideoLoop();
+        }
+        if (!wasAudioNeeded && this.plugins.shouldAudioBeActive()) {
+            this.audioLoop.start();
+        }
+        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)
+        const wasVideoNeeded = this.plugins.shouldVideoBeActive();
+        const wasAudioNeeded = this.plugins.shouldAudioBeActive();
+        const removed = this.plugins.removeBySensor(sensorId);
+        if (removed.length === 0)
             return;
-        if (!this.singlePlugins.has(SensorType.Object)) {
+        for (const plugin of removed) {
+            this.logger.trace(`Plugin unregistered: ${plugin.pluginId} (${plugin.sensorType})`);
+        }
+        if (!this.plugins.has(SensorType.Object)) {
             this.adHocVideoLoop = false;
         }
-        // Hot-reload: uses needsAdHocLoop() (not shouldVideoBeActive) so a loop
-        // still needed by a frame-based object plugin isn't stopped accidentally.
-        if (this.adHocVideoLoop && !this.needsAdHocLoop()) {
+        // needsAdHocLoop, not shouldVideoBeActive: a loop still needed by a
+        // frame-based object plugin must survive plugin hot-reloads
+        if (this.adHocVideoLoop && !this.plugins.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, otherwise a rapid re-register starts a second loop while the
+        // old one is still shutting down
+        if (wasVideoNeeded && !this.plugins.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 (even during suppression, so it can decide
-            // when to stop). External writes are presence-only — the presence channel
-            // holds the return-to-home timer without driving the motor.
-            const externalDetections = filtered.detections ?? [];
-            this.ptzAutotracker.handlePresenceDetections(externalDetections);
-            // During suppression tracker/pipeline/events stay gated — no stale
-            // bboxes or false events from the camera pose change.
-            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 external boxes as TrackedDetection (shape adapter, no real
-                // tracking) so the secondary pipeline treats them like loop 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: no loop frame yet → snapshot fetch, secondaries run
-                // full-frame (no per-detection crops).
-                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;
-                    const wantsEventThumb = this.eventManager.needsThumbnail() || this.snapshotWillStartEvent(snapshot);
-                    this.eventManager.processResults(snapshot);
-                    if (wantsEventThumb) {
-                        this.upgradeEventThumbnailAsync();
-                    }
-                }
-                finally {
-                    await fetched[Symbol.asyncDispose]();
-                }
-            }
-            finally {
-                this.processingExternalSecondary = false;
-            }
-            return;
-        }
-        if (sensorType === SensorType.Motion) {
-            // Fully gated during suppression — frame-diff is fake while the camera repositions.
-            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: direct ingest, no pixel work. Classifier (multi-
-        // provider) needs 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) {
-        // Namespaced dwell key so trigger dwells don't overwrite the sensor's own
-        // detected/blocked properties (contact/switch/light manage those themselves).
-        const dwellKey = `trigger:${sensorId}`;
-        if (action === 'activate') {
-            this.activeSensorTriggerTypes.set(dwellKey, triggerType);
-        }
-        this.dwell.refresh(dwellKey, timeoutSeconds);
-        if (action === 'activate' && this.cascadeEnabled) {
-            this.cascade.triggerMomentary(this.cascadeTimeoutSeconds);
-        }
-        this.eventManager.processResults(this.buildSnapshot());
-        // Trigger-only path (doorbell, contact) has no loop frame to encode from —
-        // fetch the event thumb async; no-op if one was already captured.
-        if (action === 'activate') {
-            this.fetchEventThumbnailAsync();
+        if (wasAudioNeeded && !this.plugins.shouldAudioBeActive()) {
+            await this.audioLoop.stop();
         }
     }
-    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() {
+    handleSuppressionActivated() {
         const cs = this.currentDetectionState;
         cs.motion = undefined;
-        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
-        if (motionPlugin) {
+        cs.object = undefined;
+        // motion is garbage during ego-motion and face/lpd inference pauses, their
+        // boxes would float frozen through the pan; object keeps publishing live
+        const motionPlugin = this.plugins.get(SensorType.Motion);
+        if (motionPlugin)
             this.writeSensorProperties(motionPlugin.sensorId, { detections: [] });
+        for (const type of [SensorType.Face, SensorType.LicensePlate]) {
+            const plugin = this.plugins.get(type);
+            if (plugin)
+                this.clearSecondaryBboxes(plugin.sensorId);
         }
-    }
-    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()) : [];
+        for (const plugin of this.plugins.getAll(SensorType.Classifier)) {
+            this.clearSecondaryBboxes(plugin.sensorId);
         }
-        const plugin = this.singlePlugins.get(sensorType);
-        return plugin ? [plugin] : [];
+        // image-space anchors don't survive a camera move, they re-form after
+        this.stationary.dropForCameraMove();
     }
-    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;
+    clearSecondaryBboxes(sensorId) {
+        this.writeSensorProperties(sensorId, { detections: [] });
+        this.secondaryBboxSeen.delete(sensorId);
     }
-    hasAnyPlugins() {
-        if (this.singlePlugins.size > 0)
-            return true;
-        for (const typePlugins of this.multiPlugins.values()) {
-            if (typePlugins.size > 0)
-                return true;
+    clearStaleSecondaryBboxes() {
+        if (this.secondaryBboxSeen.size === 0)
+            return;
+        const now = Date.now();
+        for (const [sensorId, ts] of this.secondaryBboxSeen) {
+            if (now - ts > SECONDARY_BBOX_TTL_MS) {
+                this.clearSecondaryBboxes(sensorId);
+            }
         }
-        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.videoBackoff.reset();
         this.loopPromise = this.runDetectionLoop();
     }
     async stopVideoLoop() {
@@ -822,316 +670,27 @@ let DetectionCoordinator = class DetectionCoordinator {
             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()) {
+        if (!this.loopRunning && this.plugins.needsAdHocLoop()) {
             this.adHocVideoLoop = true;
             this.logger.debug('Starting ad-hoc video loop for sensor cascade trigger');
             this.startVideoLoop();
         }
     }
     stopAdHocVideoLoopIfIdle() {
-        if (this.adHocVideoLoop && !this.shouldVideoBeActive()) {
+        if (this.adHocVideoLoop && !this.plugins.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 hqJpeg = await this.hqSnapshotSource?.snapshotJpeg(EVENT_THUMB_HQ_MAX_WIDTH, EVENT_THUMB_HQ_QUALITY);
-                    if (hqJpeg) {
-                        this.eventManager.publishEventThumbnail(hqJpeg);
-                        return;
-                    }
-                    const handle = __addDisposableResource(env_1, await this.frameSource.fetchSnapshotFrame(), true);
-                    if (!handle)
-                        return;
-                    const jpeg = await this.frameScaler.frameToJPEG(handle.frame, EVENT_THUMB_MAX_WIDTH);
-                    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);
-            }
-        })();
-    }
-    // Fallback: async snapshot replacement of a substream event thumbnail —
-    // only reached when the HQ source couldn't deliver a frame inline at event
-    // start (still connecting, buffer not warm yet).
-    upgradeEventThumbnailAsync() {
-        const source = this.hqSnapshotSource;
-        if (!source?.isRunning || !source.hasBuffer || this.hqUpgradeInflight)
-            return;
-        this.hqUpgradeInflight = true;
-        void (async () => {
-            try {
-                const jpeg = await source.snapshotJpeg(EVENT_THUMB_HQ_MAX_WIDTH, EVENT_THUMB_HQ_QUALITY);
-                if (jpeg && this.eventManager.hasActiveEvent()) {
-                    this.eventManager.publishEventThumbnail(jpeg);
-                }
-            }
-            catch (error) {
-                this.logger.debug('Snapshot event thumbnail upgrade failed:', error);
-            }
-            finally {
-                this.hqUpgradeInflight = false;
-            }
-        })();
-    }
-    // Recent snapshot frame + its scaler (own hardware context); caller disposes
-    // the frame. With a reference size the aspect ratios must match — normalized
-    // boxes only transfer between streams showing the same sensor area.
-    async acquireHqFrame(reference) {
-        const source = this.hqSnapshotSource;
-        if (!source?.isRunning || !source.hasBuffer)
-            return null;
-        const scaler = source.scaler;
-        if (!scaler)
-            return null;
-        const frame = await source.getFrame(HQ_FRAME_MAX_AGE_MS);
-        if (!frame)
-            return null;
-        if (reference) {
-            const refAspect = reference.width / reference.height;
-            const hqAspect = frame.width / frame.height;
-            if (Math.abs(refAspect - hqAspect) / refAspect > 0.02) {
-                if (!this.hqAspectWarned) {
-                    this.hqAspectWarned = true;
-                    this.logger.warn(`[hq-thumb] aspect mismatch (detection ${reference.width}x${reference.height} vs snapshot ${frame.width}x${frame.height}) — detection crops stay on the substream`);
-                }
-                frame[Symbol.dispose]?.();
-                return null;
-            }
-        }
-        return { frame, scaler };
-    }
-    resolveHqSourceUrl(sources) {
-        if (!sources?.length)
-            return undefined;
-        const order = ['high-resolution', 'mid-resolution', 'low-resolution'];
-        const byRole = new Map(sources.map((s) => [s.role, s]));
-        // Detection consumes the LOWEST available role (worker: lowRes ?? midRes
-        // ?? streamSource) — the HQ companion is only worth a session when a
-        // strictly higher-resolution role exists.
-        const detectionRole = [...order].reverse().find((role) => byRole.has(role));
-        const hqRole = order.find((role) => byRole.has(role));
-        if (!detectionRole || !hqRole || hqRole === detectionRole)
-            return undefined;
-        return byRole.get(hqRole).url;
-    }
-    syncHqSnapshotSource() {
-        if (!this.hqSnapshotSource)
-            return;
-        const wanted = this.config.frameWorkerSettings.hqSnapshots === true;
-        if (wanted && !this.hqSnapshotSource.isRunning) {
-            this.hqSnapshotSource.start();
-        }
-        else if (!wanted && this.hqSnapshotSource.isRunning) {
-            void this.hqSnapshotSource.stop();
-        }
-    }
-    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
-                        }
-                    }
-                }
-                const streamError = this.audioSource.lastError;
-                await this.audioSource.stop();
-                if (this.audioLoopRunning && streamError) {
-                    this.audioReconnectCount = Math.min(this.audioReconnectCount + 1, this.maxReconnectCount);
-                    const delay = this.audioReconnectCount >= this.maxReconnectCount ? this.maxReconnectDelay : this.normalReconnectDelay;
-                    this.logger.warn(`Audio stream ended with read error, reconnecting in ${delay / 1000}s: ${streamError.message}`);
-                    await new Promise((resolve) => setTimeout(resolve, delay));
-                }
-                else 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;
+                this.videoBackoff.reset();
                 let frameCount = 0;
                 let lastFrameId = -1;
                 while (this.loopRunning) {
@@ -1148,7 +707,7 @@ let DetectionCoordinator = class DetectionCoordinator {
                             snap.frame[Symbol.dispose]?.();
                         }
                         catch {
-                            // Best effort
+                            // best-effort
                         }
                     }
                 }
@@ -1156,14 +715,13 @@ let DetectionCoordinator = class DetectionCoordinator {
                 await this.frameSource.stop();
                 this.frameScaler.clearCache();
                 if (this.loopRunning && streamError) {
-                    this.reconnectCount = Math.min(this.reconnectCount + 1, this.maxReconnectCount);
-                    const delay = this.reconnectCount >= this.maxReconnectCount ? this.maxReconnectDelay : this.normalReconnectDelay;
+                    const delay = this.videoBackoff.nextDelayMs();
                     this.logger.warn(`Stream ended with read error, reconnecting in ${delay / 1000}s: ${streamError.message}`);
-                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    await sleep(delay);
                 }
                 else if (this.loopRunning && frameCount === 0) {
                     this.logger.debug('Stream ended without frames, waiting before reconnect...');
-                    await new Promise((resolve) => setTimeout(resolve, this.normalReconnectDelay));
+                    await sleep(this.videoBackoff.idleDelayMs);
                 }
             }
             catch (error) {
@@ -1171,10 +729,9 @@ let DetectionCoordinator = class DetectionCoordinator {
                     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;
+                const delay = this.videoBackoff.nextDelayMs();
                 this.logger.warn(`Stream error, reconnecting in ${delay / 1000}s: ${error.message}`);
-                await new Promise((resolve) => setTimeout(resolve, delay));
+                await sleep(delay);
             }
         }
         await this.frameSource.stop();
@@ -1182,7 +739,7 @@ let DetectionCoordinator = class DetectionCoordinator {
         this.logger.debug('Detection loop ended');
     }
     async processRawFrame(rawFrame) {
-        if (!this.loopRunning || !this.hasAnyPlugins())
+        if (!this.loopRunning || !this.plugins.hasAny())
             return;
         try {
             await this.processDetection(rawFrame);
@@ -1196,21 +753,18 @@ let DetectionCoordinator = class DetectionCoordinator {
         let motionDetected = false;
         let objectDetections = [];
         const results = { timestamp: t0 };
-        // Refresh ReID every frame while cascade is active so dead tracks never
-        // expire during the cascade window.
+        // keeps dead tracks from expiring during the cascade window
         if (this.cascade.isActive) {
             this.pipeline.refreshReid();
         }
-        // PTZ suppression: motion is skipped entirely (frame-diff is garbage while
-        // the camera repositions); object keeps running — Norfair gets the pose
-        // delta so track ids survive pans, and the autotracker gates motor
-        // commands on its own isPtzMoving state.
+        // while the PTZ repositions: motion and object keep running so the
+        // background model and track ids survive the pan, but nothing below
+        // reaches dwell/events until the settle window ends
         const ptzSuppressed = this.ptzAutotracker.suppressionActive;
-        // 1. Motion — every frame regardless of cascade state: keeps UI bboxes
-        // fresh AND re-triggers the cascade so sustained motion keeps it alive.
-        // The cascade gates OBJECT detection, not motion.
-        const motionPlugin = this.singlePlugins.get(SensorType.Motion);
-        if (motionPlugin?.requiresFrames && !ptzSuppressed) {
+        // motion runs every frame and re-arms the cascade; the cascade gates
+        // object detection, not motion
+        const motionPlugin = this.plugins.get(SensorType.Motion);
+        if (motionPlugin?.requiresFrames) {
             const motionFrame = await this.scaleForMotion(rawFrame);
             if (!this.loopRunning)
                 return;
@@ -1219,13 +773,18 @@ let DetectionCoordinator = class DetectionCoordinator {
                     const result = await motionPlugin.proxy.detectMotion(motionFrame);
                     if (!this.loopRunning)
                         return;
-                    if (result.detections.length > 0) {
+                    if (ptzSuppressed) {
+                        // fed for the background model only, results discarded: frame-diff
+                        // is garbage during ego-motion, but skipping frames would leave a
+                        // stale background that lights up the whole scene after the move
+                    }
+                    else 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
+                        // record empty so the UI clears stale bboxes
                         results.motion = { detected: false, detections: [] };
                     }
                 }
@@ -1237,22 +796,20 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         }
         else if (this.cascade.isActive) {
-            // No frame-based motion plugin — cascade is the only motion-equivalent signal
+            // no frame-based motion plugin, the cascade is the only motion-equivalent signal
             motionDetected = true;
             results.cascadeTriggered = true;
         }
-        // `detected` is re-derived from post-zone-filter detections — the plugin's
-        // own flag is ignored on purpose, zone filtering wins.
+        // detected is re-derived after zone filtering, the plugin's own flag is ignored
         if (results.motion && motionPlugin) {
             this.ingestDetectionResult(SensorType.Motion, motionPlugin.sensorId, {
                 detected: motionDetected,
                 detections: results.motion.detections,
             });
         }
-        // 2. Object — gated by the cascade (wake sources: motion, audio, sensor
-        // trigger), always-on when cascade is disabled, and kept running during
-        // PTZ suppression so the tracker holds its lock across pans.
-        const objectPlugin = this.singlePlugins.get(SensorType.Object);
+        // object is cascade-gated, but keeps running during PTZ suppression so
+        // the tracker holds its lock across pans
+        const objectPlugin = this.plugins.get(SensorType.Object);
         const shouldDetectObjects = objectPlugin?.requiresFrames === true && (ptzSuppressed || !this.cascadeEnabled || this.cascade.isActive);
         if (shouldDetectObjects) {
             const objectFrame = await this.scaleForObject(rawFrame);
@@ -1260,17 +817,24 @@ let DetectionCoordinator = class DetectionCoordinator {
                 return;
             if (objectFrame) {
                 try {
-                    const result = await withTimeout(objectPlugin.proxy.detectObjects(objectFrame), DETECT_TIMEOUT_MS, 'Object');
+                    const result = await PromiseTimeout(objectPlugin.proxy.detectObjects(objectFrame), DETECT_TIMEOUT_MS, undefined, `Object detection timed out after ${DETECT_TIMEOUT_MS}ms`);
                     if (!this.loopRunning)
                         return;
-                    // Full pipeline even on empty frames so Norfair advances Kalman
-                    // state; the PTZ pose delta keeps predictions world-stable across
-                    // pans (track ids survive instead of LOST → REACQUIRE).
+                    // 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 pipelineResult = this.pipeline.process(result.detections, objectFrame, poseDelta);
-                    // Extrapolated (Kalman-only) tracks smooth single-frame detector
-                    // misses in the UI, but are dropped once they drift off-frame —
-                    // otherwise ghost bboxes float outside the stream.
+                    // track id churn is invisible in the event log without this
+                    if (pipelineResult.created.length > 0 || pipelineResult.removed.length > 0) {
+                        const born = pipelineResult.created.map((id) => {
+                            const t = pipelineResult.tracked.find((d) => d.trackId === id);
+                            return `${t?.label ?? 'unknown'}#${id}`;
+                        });
+                        const died = pipelineResult.removed.map((id) => `#${id}${this.stationary.isAnchored(id) ? ' (anchored!)' : ''}`);
+                        this.logger.trace(`[tracker] ${born.length ? `born: ${born.join(', ')}` : ''}${born.length && died.length ? ' — ' : ''}${died.length ? `died: ${died.join(', ')}` : ''}`);
+                    }
+                    // extrapolated (Kalman-only) tracks smooth single-frame misses in
+                    // the UI, but must not float off-frame as ghost bboxes
                     const visibleTracks = pipelineResult.tracked.filter((t) => {
                         if (!t.trackLost)
                             return true;
@@ -1282,9 +846,8 @@ let DetectionCoordinator = class DetectionCoordinator {
                     results.object = { ...result, detections: visibleTracks };
                     if (pipelineResult.crossings.length > 0)
                         results.lineCrossings = pipelineResult.crossings;
-                    // Feed the autotracker ALL tracked detections incl. extrapolated —
-                    // a single missed detector frame must not flip it into LOST/REACQUIRE
-                    // churn. It gates motor decisions on its own isPtzMoving flag.
+                    // incl. extrapolated tracks, otherwise a single missed detector
+                    // frame flips the autotracker into LOST/REACQUIRE churn
                     this.ptzAutotracker.handleObjectDetections(pipelineResult.tracked);
                 }
                 catch (error) {
@@ -1294,14 +857,25 @@ let DetectionCoordinator = class DetectionCoordinator {
                 }
             }
         }
+        // tracker and autotracker are fed, everything event-facing stays quiet
+        if (ptzSuppressed) {
+            // object boxes stay live in the UI through the move, bbox publish only
+            if (objectPlugin && results.object) {
+                this.writeSensorProperties(objectPlugin.sensorId, { detections: results.object.detections });
+            }
+            // keep an already-running object dwell alive so a chase doesn't end its
+            // own event, but never activate it from suppressed frames
+            if (objectPlugin && objectDetections.length > 0 && this.dwell.isActive(objectPlugin.sensorId)) {
+                this.dwell.refresh(objectPlugin.sensorId, OBJECT_DWELL_SECONDS);
+            }
+            return;
+        }
         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)}`);
+                this.logger.trace(`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;
         }
-        // Same rule as motion: detected is re-derived from post-pipeline detections.
         if (results.object && objectPlugin) {
             this.ingestDetectionResult(SensorType.Object, objectPlugin.sensorId, {
                 detected: objectDetections.length > 0,
@@ -1310,227 +884,67 @@ let DetectionCoordinator = class DetectionCoordinator {
         }
         if (!this.loopRunning)
             return;
-        // 3. Secondary detectors + per-detection thumbnails. Result-collection
-        // only — the shared ingest below keeps loop tick and external-RPC path
-        // on the same helper.
         if (objectDetections.length > 0) {
             await this.runSecondariesAndThumbnails(rawFrame, objectDetections, results);
         }
         if (!this.loopRunning)
             return;
-        // 4. Unified ingest.
         this.ingestResultsForAllSecondaries(results);
-        // 5. Single flush per frame, AFTER all detectors + thumbnails — so
-        // segment-start messages already carry thumbnails and secondary data.
+        this.clearStaleSecondaryBboxes();
+        // one flush per frame, after detectors and thumbnails, so segment-start
+        // messages already carry them
         if (!this.loopRunning)
             return;
         const snapshot = this.buildSnapshot();
         if (results.thumbnails && results.thumbnails.length > 0) {
             snapshot.thumbnails = results.thumbnails;
         }
-        // Event-level thumbnail — generated lazily when the EventManager still
-        // needs one OR this frame's triggers will start an event (pre-encode so
-        // the 'start' message carries it inline). Attaching is harmless either
-        // way; EventManager only consumes it while needsEventThumbnail is true.
-        // Full frame prefers the snapshot source (no aspect constraint needed).
+        // pre-encode the event thumbnail when this frame starts an event, so the
+        // start message carries it inline; attaching is harmless otherwise
         const wantsEventThumb = this.eventManager.needsThumbnail() || this.snapshotWillStartEvent(snapshot);
         let hqThumbAttached = false;
         if (wantsEventThumb) {
             try {
-                const hq = await this.acquireHqFrame();
-                try {
-                    if (hq) {
-                        const jpeg = await hq.scaler.frameToJPEG(hq.frame, EVENT_THUMB_HQ_MAX_WIDTH, EVENT_THUMB_HQ_QUALITY);
-                        if (jpeg) {
-                            snapshot.eventThumbnail = jpeg;
-                            hqThumbAttached = true;
-                        }
-                    }
-                    if (!snapshot.eventThumbnail) {
-                        const jpeg = await this.frameScaler.frameToJPEG(rawFrame, EVENT_THUMB_MAX_WIDTH);
-                        if (jpeg)
-                            snapshot.eventThumbnail = jpeg;
-                    }
-                }
-                finally {
-                    hq?.frame[Symbol.dispose]?.();
-                }
+                const thumb = await this.thumbnailer.captureEventThumbnail(rawFrame);
+                if (thumb.jpeg)
+                    snapshot.eventThumbnail = thumb.jpeg;
+                hqThumbAttached = thumb.fromHq;
             }
             catch (error) {
                 this.logger.error('Event thumbnail generation error:', error);
             }
         }
         this.eventManager.processResults(snapshot);
-        // Inline HQ succeeded → nothing to upgrade; otherwise the async path
-        // covers the window where the HQ source wasn't ready at event start.
+        // covers the window where the HQ source wasn't ready at event start
         if (wantsEventThumb && !hqThumbAttached) {
-            this.upgradeEventThumbnailAsync();
+            this.thumbnailer.upgradeEventThumbnailAsync();
         }
     }
-    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)
+    async runSecondariesAndThumbnails(rawFrame, objectDetections, results) {
+        objectDetections = this.stationary.excludeSealed(objectDetections);
+        if (objectDetections.length === 0)
             return;
+        await this.secondaries.detect(rawFrame, objectDetections, results);
         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();
-        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 (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;
-            // Consumers with identical dimensions share one scaled region
-            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);
-                }
+            // detectors ran on the substream frame, thumbnails prefer the HQ frame
+            const hq = await this.thumbnailer.acquireHqFrame({ width: rawFrame.width, height: rawFrame.height });
+            try {
+                results.thumbnails = await this.secondaries.generateThumbnails(hq?.frame ?? rawFrame, hq?.scaler ?? this.frameScaler, hq !== null, objectDetections, results);
             }
-            const regions = await this.frameScaler.cropAndScaleMulti(rawFrame, detection, uniqueTargets);
-            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]);
-                    }
-                }
+            finally {
+                hq?.frame[Symbol.dispose]?.();
             }
         }
-        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;
+            this.logger.error('Thumbnail generation error:', error);
         }
     }
     ingestResultsForAllSecondaries(results) {
         if (results.face) {
-            const facePlugin = this.singlePlugins.get(SensorType.Face);
+            if (results.faceEmbeddingModel) {
+                this.currentDetectionState.faceEmbeddingModel = results.faceEmbeddingModel;
+            }
+            const facePlugin = this.plugins.get(SensorType.Face);
             if (facePlugin) {
                 this.ingestDetectionResult(SensorType.Face, facePlugin.sensorId, {
                     detected: results.face.detected,
@@ -1539,7 +953,7 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         }
         if (results.licensePlate) {
-            const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
+            const lpdPlugin = this.plugins.get(SensorType.LicensePlate);
             if (lpdPlugin) {
                 this.ingestDetectionResult(SensorType.LicensePlate, lpdPlugin.sensorId, {
                     detected: results.licensePlate.detected,
@@ -1548,345 +962,54 @@ let DetectionCoordinator = class DetectionCoordinator {
             }
         }
         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);
-                    }
+            for (const [pluginId, classifierResult] of Object.entries(results.classifiers)) {
+                const plugin = this.plugins.getAll(SensorType.Classifier).find((p) => p.pluginId === 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.
+            // clip has no sensor, embeddings flow through the 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 {
-            // Detectors consumed the substream frame above; images destined for the
-            // event (chips, scene) prefer the snapshot frame when available.
-            const hq = await this.acquireHqFrame({ width: rawFrame.width, height: rawFrame.height });
-            try {
-                results.thumbnails = await this.generateThumbnails(hq?.frame ?? rawFrame, hq?.scaler ?? this.frameScaler, hq !== null, objectDetections, results);
-            }
-            finally {
-                hq?.frame[Symbol.dispose]?.();
-            }
-        }
-        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, EVENT_THUMB_MAX_WIDTH);
-        }
-        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 withTimeout(facePlugin.proxy.detectFaces(this.prepareSecondaryFrames(croppedRegions)), DETECT_TIMEOUT_MS, 'Face');
-        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 };
+    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 runLicensePlateDetection(croppedRegions) {
-        const lpdPlugin = this.singlePlugins.get(SensorType.LicensePlate);
-        if (!lpdPlugin || croppedRegions.length === 0)
+    async scaleForMotion(rawFrame) {
+        const motionPlugin = this.plugins.get(SensorType.Motion);
+        if (!motionPlugin?.requiresFrames)
             return undefined;
-        const batchResults = await withTimeout(lpdPlugin.proxy.detectLicensePlates(this.prepareSecondaryFrames(croppedRegions)), DETECT_TIMEOUT_MS, 'License plate');
-        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 withTimeout(classifierPlugin.proxy.detectClassifications(this.prepareSecondaryFrames(croppedRegions)), DETECT_TIMEOUT_MS, 'Classifier');
-                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;
+        const maxWidth = MOTION_WIDTH_MAP[this.motionResolution];
+        const scaled = await this.frameScaler.scaleProportional(rawFrame, maxWidth, 'gray');
+        return scaled ? this.frameScaler.toVideoFrameData(scaled) : undefined;
     }
-    async runClipDetection(croppedRegions) {
-        const clipPlugin = this.singlePlugins.get(SensorType.Clip);
-        if (!clipPlugin || croppedRegions.length === 0)
-            return undefined;
-        const batchResults = await withTimeout(clipPlugin.proxy.detectEmbeddings(this.prepareSecondaryFrames(croppedRegions)), DETECT_TIMEOUT_MS, 'CLIP');
-        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)
+    async scaleForObject(rawFrame) {
+        const objectPlugin = this.plugins.get(SensorType.Object);
+        if (!objectPlugin?.requiresFrames)
             return undefined;
-        const embeddingModel = clipPlugin.modelSpec?.embeddingModel ?? '';
-        return { embeddings: allEmbeddings, embeddingModel };
-    }
-    async generateThumbnails(sourceFrame, scaler, usingHq, objectDetections, results) {
-        const thumbnails = [];
-        const attributePadding = usingHq ? 0.4 : 0.75;
-        const detectionMaxWidth = usingHq ? DETECTION_THUMB_HQ_MAX_WIDTH : DETECTION_THUMB_MAX_WIDTH;
-        const detectionMinCrop = usingHq ? DETECTION_THUMB_HQ_MIN_CROP : DETECTION_THUMB_MIN_CROP;
-        const detectionQuality = usingHq ? DETECTION_THUMB_HQ_QUALITY : undefined;
-        // Object thumbnails — objectDetections are TrackedDetection[] when tracker ran
-        const objectCrops = await scaler.cropToJPEG(sourceFrame, objectDetections, {
-            maxWidth: detectionMaxWidth,
-            padding: 0.3,
-            minCrop: detectionMinCrop,
-            quality: detectionQuality,
-        });
-        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 scaler.cropToJPEG(sourceFrame, results.face.detections, {
-                maxWidth: ATTRIBUTE_THUMB_MAX_WIDTH,
-                padding: attributePadding,
-                minCrop: ATTRIBUTE_THUMB_MIN_CROP,
-            });
-            for (const crop of faceCrops) {
-                const detection = results.face.detections[crop.index];
-                if (detection) {
-                    // Inline on the detection so enrichSegment can persist unknown
-                    // faces to the face store.
-                    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 scaler.cropToJPEG(sourceFrame, results.licensePlate.detections, {
-                maxWidth: ATTRIBUTE_THUMB_MAX_WIDTH,
-                padding: attributePadding,
-                minCrop: ATTRIBUTE_THUMB_MIN_CROP,
-            });
-            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 scaler.cropToJPEG(sourceFrame, classifierResult.detections, {
-                    maxWidth: detectionMaxWidth,
-                    padding: 0.3,
-                    minCrop: detectionMinCrop,
-                    quality: detectionQuality,
-                });
-                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);
+        const inputSpec = objectPlugin.modelSpec?.input;
+        if (!isVideoInputSpec(inputSpec))
             return undefined;
-        }
+        const scaled = await this.frameScaler.scaleToSpec(rawFrame, inputSpec);
+        return scaled ? this.frameScaler.toVideoFrameData(scaled) : undefined;
     }
 };
 __decorate([