@camera.ui/server 2.0.22 → 2.0.24

package/dist/server/src/sensors/registry.js

@@ -0,0 +1,814 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { RPCClass, RPCMethod } from '@camera.ui/rpc';
+import { canProvideSensorsToAnyCameras, SensorType } from '@camera.ui/sdk';
+import { randomUUID } from 'node:crypto';
+import { container } from 'tsyringe';
+import { PluginsService } from '../api/services/plugins.service.js';
+import { NamespaceManager } from '../rpc/namespaces.js';
+import { ServerSensor } from '../sensors/sensor.js';
+import { isVirtualSensorType, SENSOR_TYPE_CONFIG, VIRTUAL_SENSOR_DEFAULT_CAPABILITIES, VIRTUAL_SENSOR_DEFAULT_PROPERTIES, VIRTUAL_SENSOR_OWNER_ID, VIRTUAL_SENSOR_OWNER_NAME, } from '../sensors/types.js';
+import { disposeVirtualSensorHost, registerVirtualSensorHost } from './virtual.js';
+const HISTORY_MAX_ENTRIES = 500;
+const HISTORY_COALESCE_MS = 1000;
+let SensorRegistry = class SensorRegistry {
+    proxy;
+    logger;
+    records = new Map();
+    runtime = new Map();
+    propertyValues = new Map();
+    coordinators = new Map();
+    pluginsService;
+    context;
+    disposables = [];
+    operationQueue = Promise.resolve();
+    historyWrites = 0;
+    historyLastEntry = new Map();
+    constructor(proxy, logger) {
+        this.proxy = proxy;
+        this.logger = logger;
+        this.pluginsService = new PluginsService();
+        this.context = {
+            logger: this.logger,
+            propertyValues: this.propertyValues,
+            assignedCameraIds: (sensorId) => this.records.get(sensorId)?.assignedCameraIds ?? [],
+            cameraDetectionSettings: (cameraId) => this.dbs.camerasDB.get(cameraId)?.detectionSettings.sensor,
+            getCoordinator: (cameraId) => this.coordinatorFor(cameraId),
+            publishSensorEvent: (sensorId, event) => {
+                const ns = NamespaceManager.sensorEventNamespaces(sensorId);
+                this.safePublish(ns.sensorSubject, event);
+            },
+            emitBus: (event, payload) => this.emitBus(event, payload),
+            createPluginSensorRpc: (pluginId, sensorId) => {
+                const ns = NamespaceManager.sensorProviderNamespaces(pluginId, sensorId).sensorRpc;
+                return this.proxy.createProxy(ns);
+            },
+            persistDisplayName: (sensorId, displayName) => this.persistRecord(sensorId, (record) => (record.displayName = displayName)),
+            persistState: (sensorId, delta) => this.persistRecord(sensorId, (record) => (record.state = { ...record.state, ...delta })),
+            appendHistory: (sensorId, delta) => this.appendHistory(sensorId, delta),
+        };
+        container.registerInstance('sensorRegistry', this);
+    }
+    get dbs() {
+        return container.resolve('dbs');
+    }
+    async init() {
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        const closeHandler = await this.proxy.registerHandler(ns.sensorsRpc, this, { isolatedConnection: true });
+        this.disposables.push(closeHandler);
+        const bus = container.resolve('internalBus');
+        const onCameraRemoved = (payload) => {
+            const { cameraId } = payload;
+            if (cameraId)
+                this.onCameraRemoved(cameraId);
+        };
+        bus.onEvent('camera:removed', onCameraRemoved);
+        this.disposables.push(() => bus.offEvent('camera:removed', onCameraRemoved));
+        for (const { key, value } of this.dbs.sensorsDB.getRange()) {
+            const record = value;
+            this.records.set(String(key), record);
+            this.seedPropertyValues(record._id, record.state ?? {});
+            if (record.pluginInfo.id === VIRTUAL_SENSOR_OWNER_ID) {
+                this.runtime.set(record._id, { capabilities: this.virtualCapabilities(record.type) });
+                await registerVirtualSensorHost(this, record._id, record.type);
+            }
+            this.announceAdded(record);
+        }
+    }
+    async destroy() {
+        for (const dispose of this.disposables.reverse()) {
+            try {
+                await dispose();
+            }
+            catch (error) {
+                this.logger.warn('Sensor registry disposal failed:', error);
+            }
+        }
+        this.disposables.length = 0;
+        this.records.clear();
+        this.runtime.clear();
+        this.propertyValues.clear();
+        this.coordinators.clear();
+        this.historyLastEntry.clear();
+    }
+    registerSensor(sensor, pluginId, options) {
+        this.validateContract(sensor, pluginId, options);
+        let record = this.reconcile(sensor, pluginId);
+        const created = !record;
+        if (!record) {
+            record = {
+                _id: randomUUID(),
+                nativeId: sensor.nativeId,
+                pluginInfo: { id: pluginId, name: this.getPluginContract(pluginId)?.name ?? pluginId },
+                type: sensor.type,
+                name: sensor.name,
+                assignedCameraIds: options?.assignCameraId ? [options.assignCameraId] : [],
+                boundCameraId: options?.assignCameraId,
+                exposed: true,
+                state: {},
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            this.records.set(record._id, record);
+        }
+        else if (this.runtime.has(record._id)) {
+            this.logger.debug(`Sensor "${sensor.name}" (${sensor.type}) of plugin "${pluginId}" re-registered, replacing runtime binding`);
+            this.runtime.delete(record._id);
+        }
+        record.name = sensor.name;
+        // camera.addSensor re-registration re-binds (also backfills migrated records)
+        if (options?.assignCameraId) {
+            record.boundCameraId = options.assignCameraId;
+            // camera-bound means assigned to its camera, restore an assignment a plugin toggle removed
+            if (!record.assignedCameraIds.includes(options.assignCameraId)) {
+                record.assignedCameraIds.push(options.assignCameraId);
+                this.announceAssignment(record, options.assignCameraId, true);
+            }
+        }
+        record.updatedAt = Date.now();
+        this.persistRecord(record._id, () => { });
+        this.runtime.set(record._id, {
+            capabilities: sensor.capabilities ? [...new Set(sensor.capabilities)] : [],
+            requiresFrames: sensor.requiresFrames,
+            modelSpec: sensor.modelSpec,
+        });
+        // fresh plugin state wins over persisted last-known state
+        this.seedPropertyValues(record._id, { ...record.state, ...sensor.properties });
+        this.context.persistState(record._id, sensor.properties);
+        this.logger.log(`Sensor registered: "${record.displayName ?? record.name}" (${record.type}) by plugin "${pluginId}"${created ? ' [new]' : ''}`);
+        if (created)
+            this.announceAdded(record);
+        this.announceConnected(record, true);
+        for (const cameraId of record.assignedCameraIds) {
+            this.enqueue(() => this.pushSensorToCoordinator(record, cameraId));
+        }
+        return {
+            id: record._id,
+            assignedCameraIds: [...record.assignedCameraIds],
+            active: true,
+        };
+    }
+    resolveSensor(sensor, pluginId, options) {
+        this.validateContract(sensor, pluginId, options);
+        let record = this.reconcile(sensor, pluginId);
+        if (!record) {
+            record = {
+                _id: randomUUID(),
+                nativeId: sensor.nativeId,
+                pluginInfo: { id: pluginId, name: this.getPluginContract(pluginId)?.name ?? pluginId },
+                type: sensor.type,
+                name: sensor.name,
+                assignedCameraIds: options?.assignCameraId ? [options.assignCameraId] : [],
+                boundCameraId: options?.assignCameraId,
+                exposed: true,
+                state: {},
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            this.records.set(record._id, record);
+            this.persistRecord(record._id, () => { });
+            this.announceAdded(record);
+        }
+        return record._id;
+    }
+    unregisterSensor(sensorId) {
+        const record = this.records.get(sensorId);
+        if (!record || !this.runtime.has(sensorId))
+            return;
+        this.logger.log(`Sensor disconnected: "${record.displayName ?? record.name}" (${record.type})`);
+        this.disconnectSensor(sensorId);
+    }
+    removePluginSensors(pluginId) {
+        for (const record of this.records.values()) {
+            if (record.pluginInfo.id === pluginId && this.runtime.has(record._id)) {
+                this.disconnectSensor(record._id);
+            }
+        }
+    }
+    async deleteSensor(sensorId) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            return;
+        // a connected plugin sensor re-registers with a fresh id, delete is for leftovers
+        if (this.runtime.has(sensorId) && record.pluginInfo.id !== VIRTUAL_SENSOR_OWNER_ID) {
+            throw new Error(`Sensor "${record.displayName ?? record.name}" is still provided by plugin "${record.pluginInfo.name}"`);
+        }
+        if (this.runtime.has(sensorId))
+            this.disconnectSensor(sensorId);
+        if (record.pluginInfo.id === VIRTUAL_SENSOR_OWNER_ID)
+            await disposeVirtualSensorHost(sensorId);
+        this.records.delete(sensorId);
+        await this.dbs.sensorsDB.remove(sensorId);
+        this.pruneHistory(sensorId, 0);
+        this.logger.log(`Sensor deleted: "${record.displayName ?? record.name}" (${record.type})`);
+    }
+    async createVirtualSensor(input) {
+        const duplicate = this.getRecords().find((r) => r.pluginInfo.id === VIRTUAL_SENSOR_OWNER_ID && r.type === input.type && r.name === input.name);
+        if (duplicate) {
+            throw new Error(`A virtual ${input.type} sensor named "${input.name}" already exists`);
+        }
+        const defaults = isVirtualSensorType(input.type) ? VIRTUAL_SENSOR_DEFAULT_PROPERTIES[input.type] : {};
+        const record = {
+            _id: randomUUID(),
+            pluginInfo: { id: VIRTUAL_SENSOR_OWNER_ID, name: VIRTUAL_SENSOR_OWNER_NAME },
+            type: input.type,
+            name: input.name,
+            assignedCameraIds: input.assignCameraId ? [input.assignCameraId] : [],
+            exposed: true,
+            state: { ...defaults },
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        this.records.set(record._id, record);
+        await this.dbs.sensorsDB.put(record._id, record);
+        this.runtime.set(record._id, { capabilities: this.virtualCapabilities(record.type) });
+        this.seedPropertyValues(record._id, record.state ?? {});
+        await registerVirtualSensorHost(this, record._id, record.type);
+        this.logger.log(`Virtual sensor created: ${record.name} (${record.type})`);
+        this.announceAdded(record);
+        for (const cameraId of record.assignedCameraIds) {
+            this.enqueue(() => this.pushSensorToCoordinator(record, cameraId));
+        }
+        return record;
+    }
+    async assignCamera(sensorId, cameraId) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            throw new Error(`Sensor ${sensorId} not found`);
+        if (record.assignedCameraIds.includes(cameraId))
+            return;
+        if (SENSOR_TYPE_CONFIG[record.type].cameraBound && record.assignedCameraIds.length > 0) {
+            throw new Error(`Sensor type "${record.type}" is camera-bound and already assigned`);
+        }
+        record.assignedCameraIds.push(cameraId);
+        this.persistRecord(sensorId, () => { });
+        this.announceAssignment(record, cameraId, true);
+        if (this.runtime.has(sensorId))
+            this.enqueue(() => this.pushSensorToCoordinator(record, cameraId));
+    }
+    async unassignCamera(sensorId, cameraId) {
+        const record = this.records.get(sensorId);
+        if (!record?.assignedCameraIds.includes(cameraId))
+            return;
+        record.assignedCameraIds = record.assignedCameraIds.filter((id) => id !== cameraId);
+        this.persistRecord(sensorId, () => { });
+        this.announceAssignment(record, cameraId, false);
+        this.enqueue(() => this.removeSensorFromCoordinator(sensorId, cameraId));
+    }
+    async setAssignedCameras(sensorId, cameraIds) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            throw new Error(`Sensor ${sensorId} not found`);
+        const target = new Set(cameraIds);
+        const current = new Set(record.assignedCameraIds);
+        if (record.boundCameraId) {
+            const unchanged = target.size === current.size && [...target].every((id) => current.has(id));
+            if (unchanged)
+                return;
+            throw new Error(`Sensor "${record.displayName ?? record.name}" was registered on its camera by plugin "${record.pluginInfo.id}", its assignment cannot be changed`);
+        }
+        for (const cameraId of current) {
+            if (!target.has(cameraId))
+                await this.unassignCamera(sensorId, cameraId);
+        }
+        for (const cameraId of target) {
+            if (!current.has(cameraId))
+                await this.assignCamera(sensorId, cameraId);
+        }
+    }
+    async setHidden(sensorId, hidden) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            throw new Error(`Sensor ${sensorId} not found`);
+        if ((record.hidden ?? false) === hidden)
+            return;
+        record.hidden = hidden;
+        this.persistRecord(sensorId, () => { });
+    }
+    async setExposed(sensorId, exposed) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            throw new Error(`Sensor ${sensorId} not found`);
+        if (record.exposed === exposed)
+            return;
+        record.exposed = exposed;
+        this.persistRecord(sensorId, () => { });
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        this.safePublish(ns.sensorsSubject, {
+            type: 'sensor:exposed:changed',
+            data: { sensorId: record._id, sensorType: record.type, exposed },
+        });
+        this.emitBus('sensor:exposed:changed', {
+            sensorId: record._id,
+            sensorType: String(record.type),
+            sensorName: record.name,
+            assignedCameraIds: [...record.assignedCameraIds],
+            exposed,
+        });
+    }
+    async unassignPluginFromCamera(pluginId, cameraId) {
+        for (const record of this.records.values()) {
+            if (record.pluginInfo.id === pluginId && record.assignedCameraIds.includes(cameraId)) {
+                await this.unassignCamera(record._id, cameraId);
+            }
+        }
+    }
+    onCameraRemoved(cameraId) {
+        for (const record of this.records.values()) {
+            if (record.assignedCameraIds.includes(cameraId)) {
+                record.assignedCameraIds = record.assignedCameraIds.filter((id) => id !== cameraId);
+                this.persistRecord(record._id, () => { });
+            }
+        }
+    }
+    getSensor(sensorId, options = {}) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            return undefined;
+        if (options.connectedOnly && !this.runtime.has(sensorId))
+            return undefined;
+        return new ServerSensor(this.toStoredData(record), this.context);
+    }
+    getAllSensors(options = { connectedOnly: true }) {
+        return Array.from(this.records.values())
+            .filter((record) => !options.connectedOnly || this.runtime.has(record._id))
+            .filter((record) => !options.cameraId || record.assignedCameraIds.includes(options.cameraId))
+            .filter((record) => !options.pluginId || record.pluginInfo.id === options.pluginId)
+            .map((record) => new ServerSensor(this.toStoredData(record), this.context));
+    }
+    getRecord(sensorId) {
+        return this.records.get(sensorId);
+    }
+    getRecords() {
+        return Array.from(this.records.values());
+    }
+    isConnected(sensorId) {
+        return this.runtime.has(sensorId);
+    }
+    updatePropertyValues(sensorId, properties) {
+        this.getSensor(sensorId)?.applyPropertyWrites(properties);
+    }
+    updateCapabilities(sensorId, capabilities) {
+        const runtime = this.runtime.get(sensorId);
+        const sensor = this.getSensor(sensorId);
+        if (!runtime || !sensor)
+            return;
+        runtime.capabilities = [...new Set(capabilities)];
+        sensor.applyCapabilityUpdate(runtime.capabilities);
+        this.pushCapabilitiesToCoordinators(sensorId, runtime.capabilities);
+    }
+    getPropertyValue(sensorId, property) {
+        return this.propertyValues.get(`${sensorId}:${property}`);
+    }
+    getAllPropertyValues(sensorId) {
+        const result = {};
+        const prefix = `${sensorId}:`;
+        for (const [key, value] of this.propertyValues) {
+            if (key.startsWith(prefix))
+                result[key.substring(prefix.length)] = value;
+        }
+        return result;
+    }
+    getSensorState(sensorId) {
+        return this.getSensor(sensorId, { connectedOnly: true })?.getState();
+    }
+    getSensorStates() {
+        const result = {};
+        for (const sensor of this.getAllSensors()) {
+            result[sensor.id] = sensor.getState();
+        }
+        return result;
+    }
+    getSensors(pluginId) {
+        // disconnected entities included, the connected flag tells consumers apart
+        return this.getAllSensors({ connectedOnly: false })
+            .filter((s) => this.canPluginAccessSensor(s.data, pluginId))
+            .map((s) => s.data);
+    }
+    getSensorRpc(sensorId, pluginId) {
+        const sensor = this.getSensor(sensorId);
+        if (!sensor || !this.canPluginAccessSensor(sensor.data, pluginId))
+            return undefined;
+        return sensor.data;
+    }
+    getSensorByType(sensorType, pluginId) {
+        return this.getAllSensors().find((s) => s.type === sensorType && this.canPluginAccessSensor(s.data, pluginId))?.data;
+    }
+    getSensorsByTypeRpc(sensorType, pluginId) {
+        return this.getAllSensors()
+            .filter((s) => s.type === sensorType && this.canPluginAccessSensor(s.data, pluginId))
+            .map((s) => s.data);
+    }
+    async setDisplayName(sensorId, displayName) {
+        const sensor = this.getSensor(sensorId);
+        if (!sensor)
+            throw new Error(`Sensor ${sensorId} not found`);
+        await sensor.setDisplayNameAsync(displayName);
+    }
+    toStoredData(record) {
+        const runtime = this.runtime.get(record._id);
+        return {
+            id: record._id,
+            type: record.type,
+            name: record.name,
+            displayName: record.displayName ?? record.name,
+            nativeId: record.nativeId,
+            pluginId: record.pluginInfo.id,
+            assignedCameraIds: [...record.assignedCameraIds],
+            boundCameraId: record.boundCameraId,
+            exposed: record.exposed,
+            connected: this.runtime.has(record._id),
+            properties: this.getAllPropertyValues(record._id),
+            capabilities: runtime?.capabilities ?? [],
+            requiresFrames: runtime?.requiresFrames ?? false,
+            modelSpec: runtime?.modelSpec,
+        };
+    }
+    coordinatorFor(cameraId) {
+        let coordinator = this.coordinators.get(cameraId);
+        if (!coordinator) {
+            const ns = NamespaceManager.frameWorkerDetectionNamespaces(cameraId);
+            coordinator = this.proxy.createProxy(ns.detectionRpc);
+            this.coordinators.set(cameraId, coordinator);
+        }
+        return coordinator;
+    }
+    validateContract(sensor, pluginId, options) {
+        if (pluginId === VIRTUAL_SENSOR_OWNER_ID)
+            return;
+        const contract = this.getPluginContract(pluginId);
+        if (!contract)
+            return;
+        if (!contract.provides.includes(sensor.type)) {
+            throw new Error(`Plugin "${pluginId}" cannot provide sensor type "${sensor.type}" - not declared in contract.provides`);
+        }
+        if (options?.assignCameraId) {
+            const camera = this.dbs.camerasDB.get(options.assignCameraId);
+            const isOwnCamera = camera?.pluginInfo?.id === pluginId;
+            if (!isOwnCamera && !canProvideSensorsToAnyCameras(contract)) {
+                throw new Error(`Plugin "${pluginId}" cannot provide sensors to cameras it didn't create. Role "${contract.role}" only allows providing sensors to own cameras.`);
+            }
+        }
+        else if (!canProvideSensorsToAnyCameras(contract)) {
+            throw new Error(`Plugin "${pluginId}" cannot register standalone sensors. Role "${contract.role}" only allows sensors on own cameras.`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+        if (!options?.assignCameraId && (sensor.type === SensorType.PTZ || sensor.type === SensorType.Battery)) {
+            throw new Error(`Sensor type "${sensor.type}" requires a camera, register it via camera.addSensor()`);
+        }
+    }
+    reconcile(sensor, pluginId) {
+        for (const record of this.records.values()) {
+            if (record.pluginInfo.id !== pluginId)
+                continue;
+            if (sensor.nativeId && record.nativeId) {
+                if (record.nativeId === sensor.nativeId)
+                    return record;
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+            if (record.type === sensor.type && record.name === sensor.name)
+                return record;
+        }
+        return undefined;
+    }
+    disconnectSensor(sensorId) {
+        const record = this.records.get(sensorId);
+        this.runtime.delete(sensorId);
+        // propertyValues stay as last-known state, the entity outlives the plugin
+        if (record) {
+            this.announceConnected(record, false);
+            for (const cameraId of record.assignedCameraIds) {
+                this.enqueue(() => this.removeSensorFromCoordinator(sensorId, cameraId));
+            }
+        }
+    }
+    async reconcileCamera(cameraId, maxRetries = 1) {
+        for (const record of this.records.values()) {
+            if (!record.assignedCameraIds.includes(cameraId) || !this.runtime.has(record._id))
+                continue;
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    await this.coordinatorFor(cameraId).onSensorAdded(this.coordinatorInfoFor(record, cameraId));
+                    break;
+                }
+                catch (error) {
+                    if (attempt < maxRetries) {
+                        this.logger.debug(`Re-sync sensor ${record._id} failed (attempt ${attempt}/${maxRetries}), retrying...`);
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                    }
+                    else {
+                        this.logger.warn(`Failed to re-sync sensor ${record._id} to coordinator:`, error);
+                    }
+                }
+            }
+        }
+        // replay sustained cascade triggers that are currently in trigger-state,
+        // otherwise a contact sensor open during the crash stays silently lost
+        const settings = this.context.cameraDetectionSettings(cameraId);
+        for (const sensorId of settings?.triggers ?? []) {
+            const record = this.records.get(sensorId);
+            if (!record || !this.runtime.has(sensorId))
+                continue;
+            const trigger = SENSOR_TYPE_CONFIG[record.type]?.cascadeTrigger;
+            if (!trigger)
+                continue;
+            const currentValue = this.propertyValues.get(`${sensorId}:${trigger.property}`);
+            if (currentValue !== trigger.value)
+                continue;
+            try {
+                await this.coordinatorFor(cameraId).reportSensorTrigger(sensorId, SENSOR_TYPE_CONFIG[record.type].assignmentKey, 'activate', trigger.sustained, settings?.timeout ?? 0);
+            }
+            catch (error) {
+                this.logger.warn(`Failed to re-sync cascade trigger for sensor ${sensorId}:`, error);
+            }
+        }
+    }
+    async pushSensorToCoordinator(record, cameraId) {
+        try {
+            await this.coordinatorFor(cameraId).onSensorAdded(this.coordinatorInfoFor(record, cameraId));
+        }
+        catch {
+            // worker not running, reconcileCamera replays on start
+        }
+    }
+    async removeSensorFromCoordinator(sensorId, cameraId) {
+        try {
+            await this.coordinatorFor(cameraId).onSensorRemoved(sensorId);
+        }
+        catch {
+            // worker not running
+        }
+    }
+    coordinatorInfoFor(record, cameraId) {
+        const runtime = this.runtime.get(record._id);
+        return {
+            pluginId: record.pluginInfo.id,
+            sensorId: record._id,
+            sensorType: this.coordinatorSensorType(record, cameraId),
+            capabilities: [...(runtime?.capabilities ?? [])],
+            requiresFrames: runtime?.requiresFrames ?? false,
+            modelSpec: runtime?.modelSpec,
+        };
+    }
+    coordinatorSensorType(record, cameraId) {
+        if (record.type !== SensorType.Object)
+            return record.type;
+        const assignments = this.dbs.camerasDB.get(cameraId)?.assignments;
+        if (!assignments)
+            return record.type;
+        const isAssigned = (key) => {
+            const assignment = assignments[key];
+            if (Array.isArray(assignment))
+                return assignment.some((p) => p.id === record.pluginInfo.id);
+            return assignment?.id === record.pluginInfo.id;
+        };
+        if (isAssigned('object'))
+            return SensorType.Object;
+        return isAssigned('objectAssist') ? SensorType.ObjectAssist : record.type;
+    }
+    enqueue(fn) {
+        const op = this.operationQueue.then(fn, fn);
+        this.operationQueue = op.then(() => { }, () => { });
+        return op;
+    }
+    announceAdded(record) {
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        const data = this.toStoredData(record);
+        this.safePublish(ns.sensorsSubject, {
+            type: 'sensor:added',
+            data: { sensor: data, state: { type: data.type, properties: data.properties, capabilities: data.capabilities } },
+        });
+        this.emitBus('sensor:added', {
+            sensorId: record._id,
+            sensorType: String(record.type),
+            sensorName: record.name,
+            assignedCameraIds: [...record.assignedCameraIds],
+            connected: data.connected,
+        });
+    }
+    announceDeleted(record) {
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        this.safePublish(ns.sensorsSubject, { type: 'sensor:deleted', data: { sensorId: record._id, sensorType: record.type } });
+        this.emitBus('sensor:deleted', {
+            sensorId: record._id,
+            sensorType: String(record.type),
+            sensorName: record.name,
+            assignedCameraIds: [...record.assignedCameraIds],
+        });
+    }
+    announceConnected(record, connected) {
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        this.safePublish(ns.sensorsSubject, {
+            type: 'sensor:connected:changed',
+            data: { sensorId: record._id, sensorType: record.type, connected },
+        });
+        this.emitBus('sensor:connected:changed', {
+            sensorId: record._id,
+            sensorType: String(record.type),
+            sensorName: record.name,
+            assignedCameraIds: [...record.assignedCameraIds],
+            connected,
+        });
+    }
+    announceAssignment(record, cameraId, assigned) {
+        const ns = NamespaceManager.sensorRegistryNamespaces();
+        this.safePublish(ns.sensorsSubject, {
+            type: 'sensor:assignment:changed',
+            data: { sensorId: record._id, sensorType: record.type, cameraId, assigned },
+        });
+        this.emitBus('sensor:assignment:changed', {
+            sensorId: record._id,
+            sensorType: String(record.type),
+            sensorName: record.name,
+            assignedCameraIds: [...record.assignedCameraIds],
+        });
+    }
+    pushCapabilitiesToCoordinators(sensorId, capabilities) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            return;
+        for (const cameraId of record.assignedCameraIds) {
+            this.coordinatorFor(cameraId)
+                .onSensorCapabilitiesChanged(sensorId, capabilities)
+                .catch(() => { });
+        }
+    }
+    seedPropertyValues(sensorId, properties) {
+        for (const [key, value] of Object.entries(properties)) {
+            this.propertyValues.set(`${sensorId}:${key}`, value);
+        }
+    }
+    virtualCapabilities(type) {
+        return [...(VIRTUAL_SENSOR_DEFAULT_CAPABILITIES[type] ?? [])];
+    }
+    appendHistory(sensorId, delta) {
+        const now = Date.now();
+        let appended = false;
+        for (const [property, value] of Object.entries(delta)) {
+            if (value !== null && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean')
+                continue;
+            const coalesceKey = `${sensorId}:${property}`;
+            const previous = this.historyLastEntry.get(coalesceKey);
+            if (previous && now - previous.timestamp < HISTORY_COALESCE_MS) {
+                this.dbs.sensorHistoryDB.remove(previous.key).catch(() => { });
+            }
+            const key = `${sensorId}:${String(now).padStart(15, '0')}:${property}`;
+            this.dbs.sensorHistoryDB.put(key, { sensorId, property, value, timestamp: now }).catch(() => { });
+            this.historyLastEntry.set(coalesceKey, { key, timestamp: now });
+            appended = true;
+        }
+        if (appended && ++this.historyWrites % 50 === 0) {
+            this.pruneHistory(sensorId, HISTORY_MAX_ENTRIES);
+        }
+    }
+    getHistory(sensorId, limit = 200) {
+        const entries = [];
+        // reverse ranges iterate from `start` downwards, so start is the HIGH bound
+        for (const { value } of this.dbs.sensorHistoryDB.getRange({ start: `${sensorId};`, end: `${sensorId}:`, reverse: true, limit })) {
+            entries.push({ property: value.property, value: value.value, timestamp: value.timestamp });
+        }
+        return entries;
+    }
+    pruneHistory(sensorId, keep) {
+        const keys = [];
+        for (const { key } of this.dbs.sensorHistoryDB.getRange({ start: `${sensorId};`, end: `${sensorId}:`, reverse: true })) {
+            keys.push(String(key));
+        }
+        for (const key of keys.slice(keep)) {
+            this.dbs.sensorHistoryDB.remove(key).catch(() => { });
+        }
+    }
+    persistRecord(sensorId, mutate) {
+        const record = this.records.get(sensorId);
+        if (!record)
+            return;
+        mutate(record);
+        record.updatedAt = Date.now();
+        this.dbs.sensorsDB.put(record._id, record).catch((error) => {
+            this.logger.warn(`Failed to persist sensor ${sensorId}:`, error);
+        });
+    }
+    canPluginAccessSensor(sensor, requestingPluginId) {
+        if (!requestingPluginId)
+            return true;
+        if (sensor.pluginId === requestingPluginId)
+            return true;
+        const contract = this.getPluginContract(requestingPluginId);
+        return contract?.consumes.includes(sensor.type) ?? false;
+    }
+    getPluginContract(pluginId) {
+        return this.pluginsService.getPluginById(pluginId)?.contract;
+    }
+    emitBus(event, payload) {
+        try {
+            const bus = container.resolve('internalBus');
+            bus.emitEvent(event, payload);
+        }
+        catch {
+            // ignore
+        }
+    }
+    safePublish(subject, data) {
+        if (!this.proxy.isConnected)
+            return;
+        this.proxy.publish(subject, data).catch(() => { });
+    }
+};
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "registerSensor", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", String)
+], SensorRegistry.prototype, "resolveSensor", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], SensorRegistry.prototype, "unregisterSensor", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], SensorRegistry.prototype, "updatePropertyValues", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:returntype", void 0)
+], SensorRegistry.prototype, "updateCapabilities", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getPropertyValue", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getAllPropertyValues", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getSensorState", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getSensorStates", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Array)
+], SensorRegistry.prototype, "getSensors", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getSensorRpc", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Object)
+], SensorRegistry.prototype, "getSensorByType", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Array)
+], SensorRegistry.prototype, "getSensorsByTypeRpc", null);
+__decorate([
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SensorRegistry.prototype, "setDisplayName", null);
+SensorRegistry = __decorate([
+    RPCClass,
+    __metadata("design:paramtypes", [Object, Function])
+], SensorRegistry);
+export { SensorRegistry };
+//# sourceMappingURL=registry.js.map