@camera.ui/server 0.0.70 → 0.0.71

package/dist/server/src/api/services/cameras.service.js

@@ -7,14 +7,18 @@ 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);
 };
-import { createSourceName, isEqual, mergeWith } from '@camera.ui/common/utils';
-import TTLCache from '@isaacs/ttlcache';
+import { isEqual, mergeWith } from '@camera.ui/common/utils';
+import { canCreateCameras, isHub, PluginRole, SensorType } from '@camera.ui/sdk';
+import { TTLCache } from '@isaacs/ttlcache';
 import { container, delay, registry } from 'tsyringe';
-import { CAMERA_EXTENSIONS } from '../../plugins/types.js';
+import { getMultiProviderTypes, getValidSensorTypes, SENSOR_TYPE_CONFIG } from '../../camera/sensors/types.js';
 import { ConfigService } from '../../services/config/index.js';
+import { createSourceName } from '../../utils/camera.js';
 import { Database } from '../database/index.js';
 import { PluginsService } from './plugins.service.js';
 import { UsersService } from './users.service.js';
+const VALID_SENSOR_TYPES = [...getValidSensorTypes(), 'cameraController', 'hub'];
+const MULTI_PROVIDER_ASSIGNMENT_TYPES = new Set([...getMultiProviderTypes(), 'hub']);
 const cameraSourceProbeCache = new TTLCache({ max: 100, ttl: Infinity });
 let CamerasService = class CamerasService {
     configService;
@@ -32,335 +36,454 @@ let CamerasService = class CamerasService {
         this.pluginsService = new PluginsService();
     }
     async createCamera(cameraData) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const plugin = this.pluginsService.getPluginById(cameraData.pluginInfo?.id ?? '');
         if (plugin) {
-            plugin.contract.extensions.forEach((extensionType) => {
-                if (extensionType !== 'hub') {
-                    cameraData.extensions[extensionType] = {
-                        id: plugin.id,
-                        name: plugin.pluginName,
-                    };
+            if (!canCreateCameras(plugin.contract)) {
+                throw new Error(`Plugin ${plugin.pluginName} is not allowed to create cameras.`);
+            }
+            const assignmentTypes = this.getAssignmentTypesFromContract(plugin.contract);
+            const pluginExtension = { id: plugin.id, name: plugin.pluginName };
+            if (!cameraData.plugins.some((p) => p.id === plugin.id)) {
+                cameraData.plugins.push(pluginExtension);
+            }
+            for (const assignmentType of assignmentTypes) {
+                if (this.isMultiProviderType(assignmentType)) {
+                    const key = assignmentType;
+                    if (!Array.isArray(cameraData.assignments[key])) {
+                        cameraData.assignments[assignmentType] = [];
+                    }
+                    const arr = cameraData.assignments[key];
+                    if (!arr.some((p) => p.id === plugin.id)) {
+                        arr.push(pluginExtension);
+                    }
                 }
                 else {
-                    cameraData.extensions[extensionType] ??= [];
-                    cameraData.extensions[extensionType].push({
-                        id: plugin.id,
-                        name: plugin.pluginName,
-                    });
+                    cameraData.assignments[assignmentType] = pluginExtension;
                 }
-            });
+            }
         }
         await this.addCameraSourcesToConfig(cameraData._id, cameraData.name, cameraData.sources);
-        cameras.push(cameraData);
-        await this.dbs.camerasDB.put('cameras', cameras);
+        await this.dbs.camerasDB.put(cameraData._id, cameraData);
         const transformedCamera = this.transformCamera(cameraData);
         await this.api.addCamera(transformedCamera);
         return cameraData;
     }
     async patchZones(cameraname, zoneData) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        if (camera) {
-            camera.detectionZones = zoneData;
-            await this.dbs.camerasDB.put('cameras', cameras);
-            this.api.updateCamera(this.transformCamera(camera));
-        }
+        const camera = this.findByName(cameraname);
+        if (!camera)
+            return undefined;
+        camera.detectionZones = zoneData;
+        await this.dbs.camerasDB.put(camera._id, camera);
+        this.api.updateCamera(this.transformCamera(camera));
+        return camera;
+    }
+    async patchLines(cameraname, lineData) {
+        const camera = this.findByName(cameraname);
+        if (!camera)
+            return undefined;
+        camera.detectionLines = lineData;
+        await this.dbs.camerasDB.put(camera._id, camera);
+        this.api.updateCamera(this.transformCamera(camera));
         return camera;
     }
     list() {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras;
-    }
-    async discoverCameras(type, src) {
-        switch (type?.toLowerCase()) {
-            case 'homekit':
-                return this.go2rtcApi.discoverApi.discoverHomekit();
-            case 'onvif':
-                return this.go2rtcApi.discoverApi.discoverOnvif(src ? { src } : undefined);
-            case 'hass':
-                return this.go2rtcApi.discoverApi.discoverHass();
-            case 'gopro':
-                return this.go2rtcApi.discoverApi.discoverGopro();
-            case 'ffmpeg':
-                return this.go2rtcApi.discoverApi.discoverFFmpeg();
-            case 'dvrip':
-                return this.go2rtcApi.discoverApi.discoverDvrip();
-            case 'webtorrent':
-                return this.go2rtcApi.discoverApi.discoverWebtorrent();
+        return [...this.dbs.camerasDB.getRange()].map(({ value }) => this.migrateAssignments(value));
+    }
+    getGo2rtcConnectionSchema(type) {
+        const baseSchema = [
+            {
+                key: 'name',
+                type: 'string',
+                title: 'Camera Name',
+                description: 'A unique name for this camera',
+                required: true,
+                minLength: 1,
+            },
+        ];
+        switch (type) {
+            case 'Onvif':
+                return [
+                    ...baseSchema,
+                    {
+                        key: 'username',
+                        type: 'string',
+                        title: 'Username',
+                        description: 'Camera username (if required)',
+                    },
+                    {
+                        key: 'password',
+                        type: 'string',
+                        title: 'Password',
+                        description: 'Camera password (if required)',
+                        format: 'password',
+                    },
+                ];
+            case 'HomeKit':
+                return [
+                    ...baseSchema,
+                    {
+                        key: 'pin',
+                        type: 'string',
+                        title: 'HomeKit PIN',
+                        description: 'The 8-digit HomeKit pairing PIN',
+                        required: true,
+                        minLength: 8,
+                        maxLength: 8,
+                    },
+                ];
+            case 'DVRip':
+                return [
+                    ...baseSchema,
+                    {
+                        key: 'username',
+                        type: 'string',
+                        title: 'Username',
+                        description: 'DVR username (if required)',
+                    },
+                    {
+                        key: 'password',
+                        type: 'string',
+                        title: 'Password',
+                        description: 'DVR password (if required)',
+                        format: 'password',
+                    },
+                ];
+            case 'Hass':
+            case 'GoPro':
+            case 'FFmpeg':
+            case 'Webtorrent':
             default:
-                return this.go2rtcApi.discoverApi.discoverSources();
+                return baseSchema;
         }
     }
     listTransformed() {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const transformedCameras = cameras.map((camera) => this.transformCamera(camera));
-        return transformedCameras;
+        return this.list().map((camera) => this.transformCamera(camera));
+    }
+    // Called once at startup to remove references to uninstalled plugins
+    async cleanupNonExistentPlugins() {
+        const existingPluginNames = new Set(this.pluginsService.listPlugins().map((p) => p.pluginName));
+        const tasks = [];
+        for (const { value: camera } of this.dbs.camerasDB.getRange()) {
+            let processedCamera = this.migrateAssignments(camera);
+            const { camera: afterNonExistent, modified: mod1 } = this.cleanupPlugins(processedCamera, existingPluginNames);
+            processedCamera = afterNonExistent;
+            const { camera: afterDeselected, modified: mod2 } = this.cleanupDeselectedPluginAssignments(processedCamera);
+            processedCamera = afterDeselected;
+            if (mod1 || mod2) {
+                tasks.push(this.dbs.camerasDB.put(processedCamera._id, processedCamera));
+            }
+        }
+        await Promise.all(tasks);
     }
     listByPluginId(pluginId) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras.filter((camera) => camera.pluginInfo?.id === pluginId);
+        const result = [];
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.pluginInfo?.id === pluginId)
+                result.push(value);
+        }
+        return result;
     }
     listTransformedByPluginId(pluginId) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const filteredCameras = cameras.filter((camera) => camera.pluginInfo?.id === pluginId);
-        const transformedCameras = filteredCameras.map((camera) => this.transformCamera(camera));
-        return transformedCameras;
+        return this.listByPluginId(pluginId).map((c) => this.transformCamera(c));
+    }
+    listByPlugin(pluginName) {
+        const result = [];
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.plugins.some((p) => p.name === pluginName))
+                result.push(value);
+        }
+        return result;
     }
-    listByExtension(pluginName) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras.filter((camera) => camera.extensions.plugins.some((p) => p.name === pluginName));
+    listTransformedByPlugin(pluginName) {
+        return this.listByPlugin(pluginName).map((c) => this.transformCamera(this.migrateAssignments(c)));
     }
-    listTransformedByExtension(pluginName, extensions) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    listTransformedByAssignment(pluginName, assignmentTypes) {
         const camerasMap = new Map();
-        for (const type of extensions) {
-            let dbCameras = [];
-            if (type === 'hub') {
-                dbCameras = cameras.filter((camera) => camera.extensions[type]?.some((p) => p.name === pluginName));
+        for (const { value: camera } of this.dbs.camerasDB.getRange()) {
+            for (const type of assignmentTypes) {
+                const assignment = camera.assignments[type];
+                const matches = this.isMultiProviderType(type)
+                    ? Array.isArray(assignment) && assignment.some((p) => p.name === pluginName)
+                    : !!assignment && !Array.isArray(assignment) && assignment.name === pluginName;
+                if (matches) {
+                    camerasMap.set(camera._id, this.transformCamera(this.migrateAssignments(camera)));
+                    break;
+                }
             }
-            else {
-                dbCameras = cameras.filter((camera) => camera.extensions[type]?.name === pluginName);
+        }
+        return [...camerasMap.values()];
+    }
+    listTransformedByContract(pluginName, contract) {
+        const assignmentTypes = this.getAssignmentTypesFromContract(contract);
+        return this.listTransformedByAssignment(pluginName, assignmentTypes);
+    }
+    getRooms() {
+        const seen = new Map();
+        for (const { value: camera } of this.dbs.camerasDB.getRange()) {
+            const room = camera.room;
+            if (room) {
+                const key = room.toLowerCase();
+                if (!seen.has(key))
+                    seen.set(key, room);
             }
-            dbCameras.forEach((camera) => camerasMap.set(camera._id, this.transformCamera(camera)));
         }
-        return Array.from(camerasMap.values());
+        return [...seen.values()].sort((a, b) => a.localeCompare(b));
     }
     findById(id) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras?.find((cameraObj) => cameraObj._id === id);
+        return this.dbs.camerasDB.get(id);
     }
     findTransformedById(id) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras?.find((cameraObj) => cameraObj._id === id);
-        if (camera) {
-            return this.transformCamera(camera);
-        }
+        const camera = this.findById(id);
+        return camera ? this.transformCamera(camera) : undefined;
     }
     findByName(cameraname) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras?.find((cameraObj) => cameraObj.name === cameraname);
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.name === cameraname)
+                return value;
+        }
+        return undefined;
     }
     findTransformedByName(cameraname) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname);
-        if (camera) {
-            return this.transformCamera(camera);
-        }
+        const camera = this.findByName(cameraname);
+        return camera ? this.transformCamera(camera) : undefined;
     }
     findByPluginAndName(cameraname, pluginId) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginInfo?.id === pluginId);
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.name === cameraname && value.pluginInfo?.id === pluginId)
+                return value;
+        }
+        return undefined;
     }
     findTransformedByPluginAndName(cameraname, pluginId) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginInfo?.id === pluginId);
-        if (camera) {
-            return this.transformCamera(camera);
-        }
+        const camera = this.findByPluginAndName(cameraname, pluginId);
+        return camera ? this.transformCamera(camera) : undefined;
     }
     async patchCameraByName(cameraname, cameraData) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        const cameraController = this.api.getCamera(camera?._id ?? '');
+        const camera = this.findByName(cameraname);
+        if (!camera)
+            return undefined;
+        const cameraController = this.api.getCamera(camera._id);
         const cameraOld = structuredClone(camera);
-        if (camera && cameraOld) {
-            mergeWith(camera, cameraData, (source, target, key) => {
-                if (key === 'sources') {
-                    return target.map((srcItem) => {
-                        const objItem = source.find((o) => o.name === srcItem.name);
-                        const sourceId = objItem?._id ?? srcItem._id;
-                        return objItem ? { ...objItem, ...srcItem, _id: sourceId, name: objItem.name } : srcItem;
-                    });
-                }
-                if (key === 'extensions') {
-                    return cameraOld.extensions;
-                }
-                if (Array.isArray(source)) {
-                    return target;
-                }
-            });
-            if (!isEqual(cameraOld, camera, true)) {
-                if (cameraOld.name !== camera.name) {
-                    await this.removeCameraSourcesFromConfig(cameraOld.name, cameraOld.sources);
-                }
-                const orphanedSources = cameraOld.sources.filter((source) => !camera.sources.find((s) => s.name === source.name));
-                await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
+        mergeWith(camera, cameraData, (source, target, key) => {
+            if (key === 'sources') {
+                return target.map((srcItem) => {
+                    const objItem = source.find((o) => o.name === srcItem.name);
+                    const sourceId = objItem?._id ?? srcItem._id;
+                    return objItem ? { ...objItem, ...srcItem, _id: sourceId, name: objItem.name } : srcItem;
+                });
             }
-            await this.addCameraSourcesToConfig(camera._id, camera.name, camera.sources);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            const sourcesChanged = !isEqual(cameraOld.sources, camera.sources, true);
-            if (sourcesChanged) {
-                cameraController?.streamInfos.clear();
+            if (key === 'plugins' || key === 'assignments') {
+                return source;
             }
-            this.api.updateCamera(this.transformCamera(camera));
+            if (Array.isArray(source)) {
+                return target;
+            }
+        });
+        if (!isEqual(cameraOld, camera, true)) {
+            if (cameraOld.name !== camera.name) {
+                await this.removeCameraSourcesFromConfig(cameraOld.name, cameraOld.sources);
+            }
+            const orphanedSources = cameraOld.sources.filter((source) => !camera.sources.find((s) => s.name === source.name));
+            await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
+        }
+        await this.addCameraSourcesToConfig(camera._id, camera.name, camera.sources);
+        await this.dbs.camerasDB.put(camera._id, camera);
+        if (!isEqual(cameraOld.sources, camera.sources, true)) {
+            cameraController?.streamInfos.clear();
         }
+        this.api.updateCamera(this.transformCamera(camera));
         return camera;
     }
-    async enableExtensionByName(cameraname, pluginNameOrId, extensionType) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    async enableAssignmentByName(cameraname, pluginNameOrId, assignmentType) {
+        const camera = this.findByName(cameraname);
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && plugin) {
-            if (CAMERA_EXTENSIONS.includes(extensionType) &&
-                extensionType !== 'hub' &&
-                extensionType !== 'cameraController' &&
-                camera.extensions[extensionType]?.name !== plugin.pluginName &&
-                camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
-                const oldExtension = camera.extensions[extensionType]?.name;
-                const oldPlugin = oldExtension ? this.pluginsService.getPluginByName(oldExtension) : undefined;
-                camera.extensions[extensionType] = {
-                    id: plugin.id,
-                    name: plugin.pluginName,
-                };
-                const transformedCamera = this.transformCamera(camera);
-                await this.dbs.camerasDB.put('cameras', cameras);
-                if (oldPlugin && oldExtension) {
-                    await this.api.deselectCamera(oldPlugin.id, transformedCamera, extensionType);
-                }
-                this.api.updateCamera(transformedCamera);
-                await this.api.selectCamera(plugin.id, transformedCamera, extensionType);
+        if (!camera || !plugin || !VALID_SENSOR_TYPES.includes(assignmentType) || !camera.plugins.some((p) => p.name === plugin.pluginName)) {
+            return camera;
+        }
+        const pluginInfo = { id: plugin.id, name: plugin.pluginName };
+        let mutated = false;
+        if (this.isMultiProviderType(assignmentType)) {
+            const key = assignmentType;
+            if (!Array.isArray(camera.assignments[key])) {
+                camera.assignments[assignmentType] = [];
+            }
+            const arr = camera.assignments[key];
+            if (!arr.some((p) => p.name === plugin.pluginName)) {
+                arr.push(pluginInfo);
+                mutated = true;
+            }
+        }
+        else {
+            const currentAssignment = camera.assignments[assignmentType];
+            const currentName = currentAssignment && !Array.isArray(currentAssignment) ? currentAssignment.name : undefined;
+            if (currentName !== plugin.pluginName) {
+                camera.assignments[assignmentType] = pluginInfo;
+                mutated = true;
             }
         }
+        if (mutated) {
+            await this.dbs.camerasDB.put(camera._id, camera);
+            this.api.updateCamera(this.transformCamera(camera));
+        }
         return camera;
     }
-    async disableExtensionByName(cameraname, pluginNameOrId, extensionType) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    async disableAssignmentByName(cameraname, pluginNameOrId, assignmentType) {
+        const camera = this.findByName(cameraname);
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && plugin) {
-            if (CAMERA_EXTENSIONS.includes(extensionType) &&
-                extensionType !== 'hub' &&
-                extensionType !== 'cameraController' &&
-                camera.extensions[extensionType]?.name === plugin.pluginName &&
-                camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
-                camera.extensions[extensionType] = undefined;
-                const transformedCamera = this.transformCamera(camera);
-                await this.dbs.camerasDB.put('cameras', cameras);
-                await this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
-                this.api.updateCamera(transformedCamera);
-                setTimeout(() => {
-                    this.api.resetCameraState(camera._id, extensionType);
-                }, 100);
+        if (!camera || !plugin || !VALID_SENSOR_TYPES.includes(assignmentType) || !camera.plugins.some((p) => p.name === plugin.pluginName)) {
+            return camera;
+        }
+        let mutated = false;
+        if (this.isMultiProviderType(assignmentType)) {
+            const key = assignmentType;
+            const currentAssignments = camera.assignments[key];
+            if (Array.isArray(currentAssignments) && currentAssignments.some((p) => p.name === plugin.pluginName)) {
+                camera.assignments[assignmentType] = currentAssignments.filter((p) => p.name !== plugin.pluginName);
+                mutated = true;
             }
         }
+        else {
+            const currentAssignment = camera.assignments[assignmentType];
+            const currentName = currentAssignment && !Array.isArray(currentAssignment) ? currentAssignment.name : undefined;
+            if (currentName === plugin.pluginName) {
+                camera.assignments[assignmentType] = undefined;
+                mutated = true;
+            }
+        }
+        if (mutated) {
+            await this.dbs.camerasDB.put(camera._id, camera);
+            this.api.updateCamera(this.transformCamera(camera));
+        }
         return camera;
     }
-    async addExtensionByName(cameraname, pluginNameOrId, extension) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    // All-in-one: add plugin and enable all its assignments (used by the "More" tab toggle)
+    async activatePluginByName(cameraname, pluginNameOrId) {
+        const camera = this.findByName(cameraname);
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && plugin && !camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
-            camera.extensions.plugins.push({
-                id: plugin.id,
-                name: plugin.pluginName,
-            });
-            const addedExtensions = [];
-            if (extension !== 'hub') {
-                if (!camera.extensions[extension]) {
-                    camera.extensions[extension] = {
-                        id: plugin.id,
-                        name: plugin.pluginName,
-                    };
-                    addedExtensions.push(extension);
+        if (!camera || !plugin)
+            return camera;
+        const isNewPlugin = !camera.plugins.some((p) => p.name === plugin.pluginName);
+        const pluginInfo = { id: plugin.id, name: plugin.pluginName };
+        if (isNewPlugin) {
+            camera.plugins.push(pluginInfo);
+        }
+        const contract = plugin.contract;
+        const assignmentTypes = contract.role === PluginRole.Hub ? ['hub'] : contract.provides;
+        for (const assignmentType of assignmentTypes) {
+            if (assignmentType === 'hub') {
+                if (!Array.isArray(camera.assignments.hub)) {
+                    camera.assignments.hub = [];
+                }
+                if (!camera.assignments.hub.some((p) => p.name === plugin.pluginName)) {
+                    camera.assignments.hub.push(pluginInfo);
                 }
             }
-            else {
-                camera.extensions[extension] ??= [];
-                camera.extensions[extension].push({
-                    id: plugin.id,
-                    name: plugin.pluginName,
-                });
-                addedExtensions.push(extension);
+            else if (this.isMultiProviderType(assignmentType)) {
+                const key = assignmentType;
+                if (!Array.isArray(camera.assignments[key])) {
+                    camera.assignments[assignmentType] = [];
+                }
+                const arr = camera.assignments[key];
+                if (!arr.some((p) => p.name === plugin.pluginName)) {
+                    arr.push(pluginInfo);
+                }
             }
-            const transformedCamera = this.transformCamera(camera);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            this.api.updateCamera(transformedCamera);
-            await Promise.allSettled(addedExtensions.map((extensionType) => this.api.selectCamera(plugin.id, transformedCamera, extensionType)));
+            else if (VALID_SENSOR_TYPES.includes(assignmentType)) {
+                // only assign if not already assigned to another plugin
+                const existing = camera.assignments[assignmentType];
+                if (!existing?.name) {
+                    camera.assignments[assignmentType] = pluginInfo;
+                }
+            }
+        }
+        const transformedCamera = this.transformCamera(camera);
+        await this.dbs.camerasDB.put(camera._id, camera);
+        this.api.updateCamera(transformedCamera);
+        if (isNewPlugin) {
+            await this.api.selectCamera(plugin.id, transformedCamera);
         }
         return camera;
     }
-    async removeExtensionByName(cameraname, pluginNameOrId, extension) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    async addPluginByName(cameraname, pluginNameOrId, _assignmentType) {
+        const camera = this.findByName(cameraname);
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
-            camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
-            const removedExtensions = new Set();
-            if (extension !== 'hub') {
-                if (camera.extensions[extension]?.name === plugin.pluginName) {
-                    camera.extensions[extension] = undefined;
-                    removedExtensions.add(extension);
-                }
+        if (!camera || !plugin || camera.plugins.some((p) => p.name === plugin.pluginName)) {
+            return camera;
+        }
+        camera.plugins.push({
+            id: plugin.id,
+            name: plugin.pluginName,
+        });
+        const transformedCamera = this.transformCamera(camera);
+        await this.dbs.camerasDB.put(camera._id, camera);
+        this.api.updateCamera(transformedCamera);
+        // backend filters which sensors are shown based on assignments
+        await this.api.selectCamera(plugin.id, transformedCamera);
+        return camera;
+    }
+    async removePluginByName(cameraname, pluginNameOrId) {
+        const camera = this.findByName(cameraname);
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+        if (!camera || !plugin || !camera.plugins.some((p) => p.name === plugin.pluginName)) {
+            return camera;
+        }
+        camera.plugins = camera.plugins.filter((p) => p.name !== plugin.pluginName);
+        const singleProviderKeys = ['motion', 'object', 'audio', 'face', 'licensePlate', 'ptz', 'battery', 'cameraController'];
+        for (const key of singleProviderKeys) {
+            const assignment = camera.assignments[key];
+            if (assignment && !Array.isArray(assignment) && assignment.name === plugin.pluginName) {
+                camera.assignments[key] = undefined;
             }
-            else {
-                camera.extensions[extension] ??= [];
-                camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
-                removedExtensions.add(extension);
+        }
+        for (const sensorType of [...getMultiProviderTypes(), 'hub']) {
+            const key = sensorType === 'hub' ? 'hub' : SENSOR_TYPE_CONFIG[sensorType].assignmentKey;
+            const assignments = camera.assignments[key];
+            if (Array.isArray(assignments)) {
+                camera.assignments[key] = assignments.filter((p) => p.name !== plugin.pluginName);
             }
-            const transformedCamera = this.transformCamera(camera);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
-            this.api.updateCamera(transformedCamera);
         }
+        const transformedCamera = this.transformCamera(camera);
+        await this.dbs.camerasDB.put(camera._id, camera);
+        await this.api.deselectCamera(plugin.id, transformedCamera);
+        this.api.updateCamera(transformedCamera);
         return camera;
     }
-    async removeExtension(pluginNameOrId, extension) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        for (const camera of cameras) {
-            const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-            if (plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
-                camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
-                const removedExtensions = new Set();
-                if (extension !== 'hub') {
-                    if (camera.extensions[extension]?.name === plugin.pluginName) {
-                        camera.extensions[extension] = undefined;
-                        removedExtensions.add(extension);
-                    }
+    async removePluginAssignments(pluginNameOrId, assignmentType) {
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+        if (!plugin)
+            return;
+        for (const { value: camera } of this.dbs.camerasDB.getRange()) {
+            if (!camera.plugins.some((p) => p.name === plugin.pluginName))
+                continue;
+            camera.plugins = camera.plugins.filter((p) => p.name !== plugin.pluginName);
+            if (this.isMultiProviderType(assignmentType)) {
+                const key = assignmentType;
+                const currentAssignments = camera.assignments[key];
+                if (Array.isArray(currentAssignments)) {
+                    camera.assignments[assignmentType] = currentAssignments.filter((p) => p.name !== plugin.pluginName);
                 }
-                else {
-                    camera.extensions[extension] ??= [];
-                    camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
-                    removedExtensions.add(extension);
+            }
+            else {
+                const assignment = camera.assignments[assignmentType];
+                if (assignment && !Array.isArray(assignment) && assignment.name === plugin.pluginName) {
+                    camera.assignments[assignmentType] = undefined;
                 }
-                const transformedCamera = this.transformCamera(camera);
-                await this.dbs.camerasDB.put('cameras', cameras);
-                await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
-                this.api.updateCamera(this.transformCamera(camera));
             }
+            const transformedCamera = this.transformCamera(camera);
+            await this.dbs.camerasDB.put(camera._id, camera);
+            await this.api.deselectCamera(plugin.id, transformedCamera);
+            this.api.updateCamera(transformedCamera);
         }
     }
     async removeByName(cameraname) {
-        let cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname);
-        if (camera) {
-            cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
-            for (const source of camera.sources) {
-                cameraSourceProbeCache.delete(source._id);
-            }
-            await this.usersService.removeCameraFromPreferences(camera._id);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
-            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
-        }
+        const camera = this.findByName(cameraname);
+        if (camera)
+            await this.removeOne(camera);
     }
     async removeById(id) {
-        let cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((cameraObj) => cameraObj._id === id);
-        if (camera) {
-            cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
-            for (const source of camera.sources) {
-                cameraSourceProbeCache.delete(source._id);
-            }
-            await this.usersService.removeCameraFromPreferences(camera._id);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
-            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
-        }
+        const camera = this.findById(id);
+        if (camera)
+            await this.removeOne(camera);
     }
     async removeByPluginName(pluginName) {
         const plugin = this.pluginsService.getPluginDbByName(pluginName);
@@ -369,47 +492,48 @@ let CamerasService = class CamerasService {
         }
     }
     async removeByPluginId(pluginId) {
-        let cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((cameraObj) => cameraObj.pluginInfo?.id === pluginId);
-        if (camera) {
-            cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
-            for (const source of camera.sources) {
-                cameraSourceProbeCache.delete(source._id);
+        let target;
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.pluginInfo?.id === pluginId) {
+                target = value;
+                break;
             }
-            await this.usersService.removeCameraFromPreferences(camera._id);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
-            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
         }
+        if (target)
+            await this.removeOne(target);
     }
     async removeByPluginIdAndName(cameraname, pluginId) {
-        let cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginInfo?.id === pluginId);
-        if (camera) {
-            cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
-            for (const source of camera.sources) {
-                cameraSourceProbeCache.delete(source._id);
-            }
-            await this.usersService.removeCameraFromPreferences(camera._id);
-            await this.dbs.camerasDB.put('cameras', cameras);
-            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
-            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
-        }
+        const camera = this.findByPluginAndName(cameraname, pluginId);
+        if (camera)
+            await this.removeOne(camera);
     }
     async removeAll() {
-        let cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camerasToRemove = [];
-        cameras.forEach((camera) => camerasToRemove.push(camera));
-        cameras = [];
+        const camerasToRemove = [...this.dbs.camerasDB.getRange()].map(({ value }) => value);
         cameraSourceProbeCache.clear();
         await this.usersService.resetAllPreferences();
-        await this.dbs.camerasDB.put('cameras', cameras);
+        await this.dbs.camerasDB.clearAsync();
         await Promise.all(camerasToRemove.map((camera) => this.removeCameraSourcesFromConfig(camera.name, camera.sources)));
-        await Promise.all(camerasToRemove.map((camera) => this.api.removeCamera(this.transformCamera(camera), camera.extensions)));
+        await Promise.all(camerasToRemove.map((camera) => this.api.removeCamera(this.transformCamera(camera), camera.assignments)));
+    }
+    listByAgentId(agentId) {
+        const result = [];
+        for (const { value } of this.dbs.camerasDB.getRange()) {
+            if (value.workerAgentId === agentId)
+                result.push(value);
+        }
+        return result;
+    }
+    async setWorkerAgentId(cameraId, agentId) {
+        const camera = this.findById(cameraId);
+        if (!camera)
+            return undefined;
+        camera.workerAgentId = agentId;
+        await this.dbs.camerasDB.put(camera._id, camera);
+        return camera;
     }
     async streamSourceInfo(camera, source) {
         const src = createSourceName(camera.name, source.name);
-        return this.go2rtcApi.streamsApi.getStreamInfo({ src });
+        return this.go2rtcApi.streamsRoute.getStreamInfo({ src });
     }
     async probeCameraSource(camera, source, probeData) {
         cameraSourceProbeCache.purgeStale();
@@ -418,7 +542,7 @@ let CamerasService = class CamerasService {
             return inCache;
         }
         const src = createSourceName(camera.name, source.name);
-        const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src }, probeData);
+        const probe = await this.go2rtcApi.streamsRoute.probeStreamSource({ src }, probeData);
         cameraSourceProbeCache.set(source._id, probe);
         return probe;
     }
@@ -432,6 +556,8 @@ let CamerasService = class CamerasService {
                 useForSnapshot: source.useForSnapshot,
                 hotMode: source.hotMode,
                 preload: source.preload,
+                prebuffer: source.prebuffer,
+                childSourceId: source.childSourceId,
                 urls: {
                     ws: this.generateWsUrls(camera, source),
                     rtsp: this.generateRTSPUrls(camera, source),
@@ -441,48 +567,64 @@ let CamerasService = class CamerasService {
         };
         return transformedCamera;
     }
+    async removeOne(camera) {
+        for (const source of camera.sources) {
+            cameraSourceProbeCache.delete(source._id);
+        }
+        await this.usersService.removeCameraFromPreferences(camera._id);
+        await this.dbs.camerasDB.remove(camera._id);
+        await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+        await this.api.removeCamera(this.transformCamera(camera), camera.assignments);
+    }
     async addCameraSourcesToConfig(cameraId, cameraname, sources) {
         for (const source of sources) {
             source.urls = source.urls.map((url) => {
                 if (url.startsWith('cui://')) {
                     url = `cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${cameraId}/${source.name}`;
                 }
-                const regex = /#gop=\d+/;
-                if (source.preload && !regex.test(url)) {
+                const gopRegex = /#gop=\d+/;
+                if (source.preload && !gopRegex.test(url)) {
                     url += '#gop=1';
                 }
-                else if (!source.preload && regex.test(url)) {
+                else if (!source.preload && gopRegex.test(url)) {
                     url = url.replace(/#gop=\d+/, '');
                 }
+                const prebufferRegex = /#prebuffer=\d+/;
+                if (source.prebuffer && !prebufferRegex.test(url)) {
+                    url += '#prebuffer=5';
+                }
+                else if (!source.prebuffer && prebufferRegex.test(url)) {
+                    url = url.replace(/#prebuffer=\d+/, '');
+                }
                 return url;
             });
             const sourceName = createSourceName(cameraname, source.name);
-            const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac`;
-            const baseUrls = [...source.urls];
+            const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac#noVideo#noBackchannel#requirePrevAudio`;
+            let baseUrls = [...source.urls];
             const hasFFmpegUrl = baseUrls.some((url) => url.startsWith('ffmpeg:') && url.includes('#cameraui'));
             if (!hasFFmpegUrl && source.role !== 'snapshot') {
                 baseUrls.push(ffmpegUrl);
             }
+            else if (hasFFmpegUrl) {
+                baseUrls = baseUrls.map((url) => {
+                    if (url.startsWith('ffmpeg:') && url.includes('#cameraui')) {
+                        return ffmpegUrl;
+                    }
+                    return url;
+                });
+            }
             const cameraSource = {
                 name: sourceName,
                 src: baseUrls,
             };
-            if (!this.sourceExistAndEqual(sourceName, baseUrls)) {
+            if (!this.sourcesAreEqual(sourceName, baseUrls)) {
                 this.configService.go2rtcConfig.streams ??= {};
-                await this.go2rtcApi.streamsApi.createStream({
+                await this.go2rtcApi.streamsRoute.createStream({
                     name: cameraSource.name,
                     src: cameraSource.src,
                 });
                 this.configService.go2rtcConfig.streams[cameraSource.name] = cameraSource.src;
             }
-            if (source.hotMode) {
-                this.configService.go2rtcConfig.preload ??= {};
-                await this.go2rtcApi.streamsApi.addPreloadStream({ src: cameraSource.name }, { video: true, silent: true });
-                this.configService.go2rtcConfig.preload[cameraSource.name] = 'video#silent';
-            }
-            else {
-                await this.go2rtcApi.streamsApi.startStopPreloadStream({ src: cameraSource.name }, 'stop');
-            }
         }
     }
     async removeCameraSourcesFromConfig(cameraname, oldSources) {
@@ -499,11 +641,11 @@ let CamerasService = class CamerasService {
             this.configService.go2rtcConfig.streams ??= {};
             this.configService.go2rtcConfig.preload ??= {};
             for (const src of preloadsToRemove) {
-                await this.go2rtcApi.streamsApi.deletePreloadStream({ src });
+                await this.go2rtcApi.streamsRoute.deletePreloadStream({ src });
                 delete this.configService.go2rtcConfig.preload?.[src];
             }
             for (const src of sourcesToRemove) {
-                await this.go2rtcApi.streamsApi.deleteStream({ src });
+                await this.go2rtcApi.streamsRoute.deleteStream({ src });
                 delete this.configService.go2rtcConfig.streams?.[src];
             }
             let rewriteConfig = false;
@@ -520,7 +662,7 @@ let CamerasService = class CamerasService {
             }
         }
     }
-    sourceExistAndEqual(sourceName, source) {
+    sourcesAreEqual(sourceName, source) {
         if (this.configService.go2rtcConfig.streams?.[sourceName]) {
             let configSource = this.configService.go2rtcConfig.streams[sourceName];
             configSource = typeof configSource === 'string' ? [configSource] : configSource;
@@ -544,12 +686,15 @@ let CamerasService = class CamerasService {
         const baseRtspUrl = `${go2rtcAddress}/${sourceName}`;
         const baseOnvifUrl = `${onvifAddress}/${sourceName}`;
         return {
-            base: baseRtspUrl,
-            default: `${baseRtspUrl}?video&audio&backchannel=1&timeout=15`,
+            base: `${baseRtspUrl}?video&audio&timeout=15`,
+            default: `${baseRtspUrl}?video&audio&backchannel=opus,pcma,pcmu&timeout=15`,
             muted: `${baseRtspUrl}?video&timeout=15`,
-            aac: `${baseRtspUrl}?video&audio=aac&backchannel=1&timeout=15`,
-            opus: `${baseRtspUrl}?video&audio=opus&backchannel=1&timeout=15`,
-            pcma: `${baseRtspUrl}?video&audio=pcma&backchannel=1&timeout=15`,
+            audioOnly: `${baseRtspUrl}?audio&timeout=15`,
+            aac: `${baseRtspUrl}?video&audio=aac&backchannel=opus,pcma,pcmu&timeout=15`,
+            opus: `${baseRtspUrl}?video&audio=opus&backchannel=opus,pcma,pcmu&timeout=15`,
+            pcma: `${baseRtspUrl}?video&audio=pcma&backchannel=opus,pcma,pcmu&timeout=15`,
+            prebuffered: `${baseRtspUrl}?video&audio&prebuffer&timeout=15`,
+            noGop: `${baseRtspUrl}?video&audio&timeout=15&gop=0`,
             onvif: baseOnvifUrl,
         };
     }
@@ -565,6 +710,88 @@ let CamerasService = class CamerasService {
             mjpeg: baseMjpegStreamUrl,
         };
     }
+    isMultiProviderType(type) {
+        return MULTI_PROVIDER_ASSIGNMENT_TYPES.has(type);
+    }
+    migrateAssignments(camera) {
+        if (!camera.assignments) {
+            camera.assignments = {};
+            return camera;
+        }
+        const arrayTypes = getMultiProviderTypes().map((type) => SENSOR_TYPE_CONFIG[type].assignmentKey);
+        for (const type of arrayTypes) {
+            const assignment = camera.assignments[type];
+            if (assignment && !Array.isArray(assignment)) {
+                camera.assignments[type] = [assignment];
+            }
+        }
+        return camera;
+    }
+    cleanupDeselectedPluginAssignments(camera) {
+        let modified = false;
+        const selectedPluginNames = new Set(camera.plugins.map((p) => p.name));
+        if (camera.assignments) {
+            for (const key of Object.keys(camera.assignments)) {
+                const assignment = camera.assignments[key];
+                if (Array.isArray(assignment)) {
+                    const originalLength = assignment.length;
+                    const filtered = assignment.filter((p) => selectedPluginNames.has(p.name));
+                    if (filtered.length !== originalLength) {
+                        camera.assignments[key] = filtered;
+                        modified = true;
+                    }
+                }
+                else if (assignment && typeof assignment === 'object' && 'name' in assignment) {
+                    if (!selectedPluginNames.has(assignment.name)) {
+                        camera.assignments[key] = undefined;
+                        modified = true;
+                    }
+                }
+            }
+        }
+        return { camera, modified };
+    }
+    cleanupPlugins(camera, existingPluginNames) {
+        let modified = false;
+        const originalPluginsLength = camera.plugins.length;
+        camera.plugins = camera.plugins.filter((p) => existingPluginNames.has(p.name));
+        if (camera.plugins.length !== originalPluginsLength) {
+            modified = true;
+        }
+        if (camera.assignments) {
+            for (const key of Object.keys(camera.assignments)) {
+                const assignment = camera.assignments[key];
+                if (Array.isArray(assignment)) {
+                    const originalLength = assignment.length;
+                    const filtered = assignment.filter((p) => existingPluginNames.has(p.name));
+                    if (filtered.length !== originalLength) {
+                        camera.assignments[key] = filtered;
+                        modified = true;
+                    }
+                }
+                else if (assignment && typeof assignment === 'object' && 'name' in assignment) {
+                    if (!existingPluginNames.has(assignment.name)) {
+                        camera.assignments[key] = undefined;
+                        modified = true;
+                    }
+                }
+            }
+        }
+        return { camera, modified };
+    }
+    getAssignmentTypesFromContract(contract) {
+        const types = [];
+        for (const sensorType of contract.provides) {
+            types.push(sensorType);
+        }
+        if (isHub(contract)) {
+            types.push('hub');
+        }
+        if (canCreateCameras(contract)) {
+            types.push('cameraController');
+        }
+        return types;
+    }
 };
 CamerasService = __decorate([
     registry([