@camera.ui/browser 0.0.147 → 0.0.148

package/dist/index.d.ts

@@ -86,7 +86,7 @@ import { TemperatureProperty } from '@camera.ui/sdk';
 import { WatchSource } from 'vue';
 import { WsTransport } from '@camera.ui/transport/transports/ws';
 
-export declare function acquireSensorManager(cameraId: string, rpcOrContext: RPCClient | ReactiveCameraDeviceContext): CachedSensorManager;
+export declare function acquireSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext): CachedSensorManager;
 
 export declare interface ActivityMode extends ActivityModeState, ActivityModeActions {
 }
@@ -288,7 +288,7 @@ export declare function createCameraUiPlugin(input: CameraUiContext | CameraUiPl
 
 export declare function createReactiveCameraDevice(rpcOrContext: RPCClient | ReactiveCameraDeviceContext, initialCamera: Camera): Promise<ReactiveCameraDevice>;
 
-export declare function createSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext, cameraId: string, sensorSubjectNamespace: string, sensorRpcNamespace: string): ReactiveSensorManager;
+export declare function createSensorManager(rpcOrContext: RPCClient | ReactiveCameraDeviceContext): ReactiveSensorManager;
 
 declare interface DBCamera extends BaseCamera {
     sources: CameraInputSettings[];
@@ -394,6 +394,12 @@ export declare const isReactiveTemperatureInfo: (sensor: ReactiveSensor<any>) =>
 
 /* Excluded from this release type: LeakSensorProperties */
 
+/** @deprecated stub window for pre-standalone plugins, remove in the first minor after the standalone-sensors release */
+declare interface LegacySensorNamespaces {
+    sensorSubject: string;
+    sensorRpc: string;
+}
+
 /* Excluded from this release type: LicensePlateProperty */
 
 /* Excluded from this release type: LicensePlateSensorProperties */
@@ -468,29 +474,42 @@ export declare class NamespaceManager {
         };
     }
 
-    static pluginSensorNamespaces(pluginId: string, cameraId: string, sensorId: string): PluginSensorNamespaces {
+    static pluginSensorNamespaces(pluginId: string, sensorId: string): PluginSensorNamespaces {
         return {
-            sensorStorageRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.storage.rpc`,
+            sensorStorageRpc: `plugin.${pluginId}.sensor.${sensorId}.storage.rpc`,
         };
     }
 
-    static sensorControllerNamespaces(cameraId: string): SensorControllerNamespaces {
+    static sensorRegistryNamespaces(): SensorRegistryNamespaces {
+        return {
+            sensorsSubject: 'sensors.subject',
+            sensorsRpc: 'sensors.rpc',
+        };
+    }
+
+    static sensorCameraViewNamespaces(cameraId: string): SensorCameraViewNamespaces {
         return {
-            sensorSubject: `camera.${cameraId}.sensors.subject`,
-            sensorRpc: `camera.${cameraId}.sensors.rpc`,
             sensorWriteSubject: `camera.${cameraId}.sensors.writes`,
         };
     }
 
-    static sensorEventNamespaces(cameraId: string, sensorId: string): SensorEventNamespaces {
+    static sensorEventNamespaces(sensorId: string): SensorEventNamespaces {
         return {
-            sensorSubject: `camera.${cameraId}.sensor.${sensorId}.subject`,
+            sensorSubject: `sensor.${sensorId}.subject`,
         };
     }
 
-    static sensorProviderNamespaces(pluginId: string, cameraId: string, sensorId: string): SensorProviderNamespaces {
+    static sensorProviderNamespaces(pluginId: string, sensorId: string): SensorProviderNamespaces {
         return {
-            sensorRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.rpc`,
+            sensorRpc: `plugin.${pluginId}.sensor.${sensorId}.rpc`,
+        };
+    }
+
+    /** @deprecated stub window for pre-standalone plugins, remove in the first minor after the standalone-sensors release */
+    static legacySensorNamespaces(cameraId: string): LegacySensorNamespaces {
+        return {
+            sensorSubject: `camera.${cameraId}.sensors.subject`,
+            sensorRpc: `camera.${cameraId}.sensors.rpc`,
         };
     }
 
@@ -506,10 +525,6 @@ export declare class NamespaceManager {
         };
     }
 
-    static sensorControllerRpc(cameraId: string): string {
-        return `camera.${cameraId}.sensors.controller.rpc`;
-    }
-
     static terminalManagerNamespaces(): TerminalManagerNamespaces {
         return {
             terminalManagerSubject: 'terminalManager.subscriber',
@@ -784,7 +799,11 @@ export declare interface ReactiveSensor<TProperties extends object = Record<stri
     readonly type: SensorType;
     readonly name: string;
     readonly displayName: Ref<string>;
+    readonly nativeId?: string;
     readonly pluginId: string;
+    readonly assignedCameraIds: Ref<string[]>;
+    readonly exposed: Ref<boolean>;
+    readonly connected: Ref<boolean>;
     readonly capabilities: Ref<string[]>;
     readonly properties: TProperties;
     getProperty<T = unknown>(property: string): T | undefined;
@@ -886,7 +905,7 @@ declare interface RefreshedStates {
     sensorStates: Record<string, SensorRefreshedState>;
 }
 
-export declare function releaseSensorManager(cameraId: string): void;
+export declare function releaseSensorManager(): void;
 
 export declare function resetClientState(): void;
 
@@ -908,50 +927,57 @@ export { RPCClient }
 /* Excluded from this release type: SecuritySystemProperty */
 
 declare interface SensorAddedEvent {
-    cameraId: string;
     sensor: StoredSensorData;
     state: SensorRefreshedState;
 }
 
-declare interface SensorCapabilitiesChangedEvent {
+declare interface SensorAssignmentChangedEvent {
+    sensorId: string;
+    sensorType: SensorType;
     cameraId: string;
+    assigned: boolean;
+}
+
+export declare interface SensorCameraViewNamespaces {
+    sensorWriteSubject: string;
+}
+
+declare interface SensorCapabilitiesChangedEvent {
     sensorId: string;
     capabilities: string[];
 }
 
-export declare interface SensorControllerNamespaces {
-    sensorSubject: string;
-    sensorRpc: string;
-    sensorWriteSubject: string;
+declare interface SensorConnectedChangedEvent {
+    sensorId: string;
+    sensorType: SensorType;
+    connected: boolean;
 }
 
-export declare interface SensorControllerRPC {
-    getSensors(): StoredSensorData[];
-    getSensor(sensorId: string): StoredSensorData | undefined;
-    getSensorByType(sensorType: SensorType): StoredSensorData | undefined;
-    getSensorsByType(sensorType: SensorType): StoredSensorData[];
-    getSensorState(sensorId: string): SensorRefreshedState;
-    getSensorStates(): Record<string, SensorRefreshedState>;
-    getPropertyValue(sensorId: string, property: string): unknown;
-    getAllPropertyValues(sensorId: string): Record<string, unknown>;
-    setDisplayName(sensorId: string, displayName: string): void;
+declare interface SensorDeletedEvent {
+    sensorId: string;
+    sensorType: SensorType;
 }
 
 declare interface SensorDisplayNameChangedEvent {
-    cameraId: string;
     sensorId: string;
     displayName: string;
 }
 
 export declare interface SensorEventMessage {
-    type: 'property:changed' | 'sensor:added' | 'sensor:removed' | 'sensor:displayName:changed' | 'sensor:capabilities:changed';
-    data: PropertyChangedEvent | SensorAddedEvent | SensorRemovedEvent | SensorDisplayNameChangedEvent | SensorCapabilitiesChangedEvent;
+    type: 'property:changed' | 'sensor:added' | 'sensor:deleted' | 'sensor:connected:changed' | 'sensor:displayName:changed' | 'sensor:capabilities:changed' | 'sensor:assignment:changed' | 'sensor:exposed:changed';
+    data: PropertyChangedEvent | SensorAddedEvent | SensorDeletedEvent | SensorConnectedChangedEvent | SensorDisplayNameChangedEvent | SensorCapabilitiesChangedEvent | SensorAssignmentChangedEvent | SensorExposedChangedEvent;
 }
 
 export declare interface SensorEventNamespaces {
     sensorSubject: string;
 }
 
+declare interface SensorExposedChangedEvent {
+    sensorId: string;
+    sensorType: SensorType;
+    exposed: boolean;
+}
+
 export declare interface SensorProviderNamespaces {
     sensorRpc: string;
 }
@@ -963,10 +989,19 @@ export declare interface SensorRefreshedState {
     displayName?: string;
 }
 
-declare interface SensorRemovedEvent {
-    cameraId: string;
-    sensorId: string;
-    sensorType: SensorType;
+export declare interface SensorRegistryNamespaces {
+    sensorsSubject: string;
+    sensorsRpc: string;
+}
+
+export declare interface SensorRegistryRPC {
+    getSensors(): StoredSensorData[];
+    getSensorRpc(sensorId: string): StoredSensorData | undefined;
+    getSensorState(sensorId: string): SensorRefreshedState;
+    getSensorStates(): Record<string, SensorRefreshedState>;
+    getPropertyValue(sensorId: string, property: string): unknown;
+    getAllPropertyValues(sensorId: string): Record<string, unknown>;
+    setDisplayName(sensorId: string, displayName: string): void;
 }
 
 /* Excluded from this release type: SirenControlProperties */
@@ -995,12 +1030,15 @@ export declare interface StorageRPC {
 
 export declare interface StoredSensorData {
     id: string;
-    stableId: string;
-    globalId: string;
     type: SensorType;
     name: string;
     displayName: string;
+    nativeId?: string;
     pluginId: string;
+    assignedCameraIds: string[];
+    boundCameraId?: string;
+    exposed: boolean;
+    connected: boolean;
     properties: Record<string, unknown>;
     capabilities: string[];
     requiresFrames?: boolean;
@@ -1077,6 +1115,8 @@ export declare interface TerminalSessionInfo {
     dimensions: { cols: number; rows: number };
 }
 
+export declare function useAllSensors(): UseSensorsReturn;
+
 export declare function useAudioSensor(camera: CameraIdentifier): UseSensorTypedReturn<ReactiveAudioSensor>;
 
 export declare function useCameraById(cameraIdOrName: MaybeRefOrGetter<string>): UseCameraByIdReturn;
@@ -1212,7 +1252,7 @@ export declare interface UseSensorsReturn {
     error: Ref<Error | undefined>;
 }
 
-export declare function useSensorStorage(camera: CameraIdentifier, sensorId: MaybeRefOrGetter<string | undefined>, pluginId: MaybeRefOrGetter<string | undefined>): UseStorageReturn;
+export declare function useSensorStorage(sensorId: MaybeRefOrGetter<string | undefined>, pluginId: MaybeRefOrGetter<string | undefined>): UseStorageReturn;
 
 export declare interface UseSensorsTypedReturn<T extends ReactiveSensor<any> = ReactiveSensor> {
     sensors: ComputedRef<T[]>;

package/dist/index.js

@@ -149,21 +149,30 @@ var NamespaceManager = class {
 			cameraImplRpc: `plugin.${pluginId}.camera.${cameraId}.impl.rpc`
 		};
 	}
-	static pluginSensorNamespaces(pluginId, cameraId, sensorId) {
-		return { sensorStorageRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.storage.rpc` };
+	static pluginSensorNamespaces(pluginId, sensorId) {
+		return { sensorStorageRpc: `plugin.${pluginId}.sensor.${sensorId}.storage.rpc` };
 	}
-	static sensorControllerNamespaces(cameraId) {
+	static sensorRegistryNamespaces() {
 		return {
-			sensorSubject: `camera.${cameraId}.sensors.subject`,
-			sensorRpc: `camera.${cameraId}.sensors.rpc`,
-			sensorWriteSubject: `camera.${cameraId}.sensors.writes`
+			sensorsSubject: "sensors.subject",
+			sensorsRpc: "sensors.rpc"
 		};
 	}
-	static sensorEventNamespaces(cameraId, sensorId) {
-		return { sensorSubject: `camera.${cameraId}.sensor.${sensorId}.subject` };
+	static sensorCameraViewNamespaces(cameraId) {
+		return { sensorWriteSubject: `camera.${cameraId}.sensors.writes` };
+	}
+	static sensorEventNamespaces(sensorId) {
+		return { sensorSubject: `sensor.${sensorId}.subject` };
 	}
-	static sensorProviderNamespaces(pluginId, cameraId, sensorId) {
-		return { sensorRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.rpc` };
+	static sensorProviderNamespaces(pluginId, sensorId) {
+		return { sensorRpc: `plugin.${pluginId}.sensor.${sensorId}.rpc` };
+	}
+	/** @deprecated stub window for pre-standalone plugins, remove in the first minor after the standalone-sensors release */
+	static legacySensorNamespaces(cameraId) {
+		return {
+			sensorSubject: `camera.${cameraId}.sensors.subject`,
+			sensorRpc: `camera.${cameraId}.sensors.rpc`
+		};
 	}
 	static frameWorkerDetectionNamespaces(cameraId) {
 		return { detectionRpc: `camera.${cameraId}.frameWorker.detection.rpc` };
@@ -171,9 +180,6 @@ var NamespaceManager = class {
 	static detectionEventNamespaces(cameraId) {
 		return { detectionEventSubject: `camera.${cameraId}.events.subject` };
 	}
-	static sensorControllerRpc(cameraId) {
-		return `camera.${cameraId}.sensors.controller.rpc`;
-	}
 	static terminalManagerNamespaces() {
 		return {
 			terminalManagerSubject: "terminalManager.subscriber",
@@ -602,7 +608,7 @@ function useSnapshot(cameraIdOrName) {
 //#region src/composables/useCamera.ts
 async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 	const cameraNamespaces = NamespaceManager.cameraNamespaces(initialCamera._id);
-	const sensorNamespaces = NamespaceManager.sensorControllerNamespaces(initialCamera._id);
+	const sensorNamespaces = NamespaceManager.sensorRegistryNamespaces();
 	const ctx = "rpc" in rpcOrContext && "value" in rpcOrContext.rpc ? rpcOrContext : void 0;
 	const rpcRef = ctx ? ctx.rpc : shallowRef(rpcOrContext);
 	let closeSubscription;
@@ -696,30 +702,47 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 			case "frameWorkerState":
 				frameWorkerConnected.value = event.data;
 				break;
-			case "snapshot:updated":
-				setSnapshot(initialCamera._id, event.data.snapshot, Date.now());
-				break;
+			case "snapshot:updated": setSnapshot(initialCamera._id, event.data.snapshot, Date.now());
 		}
 	}
 	function handleSensorEvent(event) {
 		if (event.type === "sensor:added") {
 			const addedEvent = event.data;
+			if (!addedEvent.sensor.assignedCameraIds.includes(initialCamera._id)) return;
+			if (!addedEvent.sensor.connected) return;
 			sensorStates.value = {
 				...sensorStates.value,
 				[addedEvent.sensor.id]: addedEvent.state
 			};
-		} else if (event.type === "sensor:removed") {
-			const removedEvent = event.data;
+		} else if (event.type === "sensor:deleted") {
+			const deletedEvent = event.data;
 			const newStates = { ...sensorStates.value };
-			delete newStates[removedEvent.sensorId];
+			delete newStates[deletedEvent.sensorId];
 			sensorStates.value = newStates;
+		} else if (event.type === "sensor:connected:changed") {
+			const connectedEvent = event.data;
+			if (connectedEvent.connected) refreshStates().catch(() => {});
+			else {
+				const newStates = { ...sensorStates.value };
+				delete newStates[connectedEvent.sensorId];
+				sensorStates.value = newStates;
+			}
+		} else if (event.type === "sensor:assignment:changed") {
+			const assignmentEvent = event.data;
+			if (assignmentEvent.cameraId !== initialCamera._id) return;
+			if (assignmentEvent.assigned) refreshStates().catch(() => {});
+			else {
+				const newStates = { ...sensorStates.value };
+				delete newStates[assignmentEvent.sensorId];
+				sensorStates.value = newStates;
+			}
 		}
 	}
 	async function init() {
 		closeSubscription?.();
 		closeSensorSubscription?.();
 		closeSubscription = await rpcCall(rpcRef, (client) => client.subscribe(cameraNamespaces.cameraSubject, handleCameraEvent));
-		closeSensorSubscription = await rpcCall(rpcRef, (client) => client.subscribe(sensorNamespaces.sensorSubject, handleSensorEvent));
+		closeSensorSubscription = await rpcCall(rpcRef, (client) => client.subscribe(sensorNamespaces.sensorsSubject, handleSensorEvent));
 		await refreshStates();
 	}
 	async function close() {
@@ -1112,9 +1135,12 @@ var isReactiveOccupancySensor = createSensorTypeGuard(SensorType.Occupancy);
 var isReactiveSmokeSensor = createSensorTypeGuard(SensorType.Smoke);
 var isReactiveLeakSensor = createSensorTypeGuard(SensorType.Leak);
 var isReactiveGarageControl = createSensorTypeGuard(SensorType.Garage);
-function createReactiveSensor(data, state, rpcRef, cameraId) {
+function createReactiveSensor(data, state, rpcRef) {
 	const displayName = ref(state.displayName ?? data.displayName ?? data.name);
 	const capabilities = ref(state.capabilities ?? data.capabilities ?? []);
+	const assignedCameraIds = ref([...data.assignedCameraIds]);
+	const exposed = ref(data.exposed);
+	const connected = ref(data.connected);
 	const properties = reactive({ ...state.properties });
 	const capabilityCallbacks = [];
 	return {
@@ -1122,19 +1148,23 @@ function createReactiveSensor(data, state, rpcRef, cameraId) {
 		type: data.type,
 		name: data.name,
 		displayName,
+		nativeId: data.nativeId,
 		pluginId: data.pluginId,
+		assignedCameraIds,
+		exposed,
+		connected,
 		capabilities,
 		properties,
 		getProperty(property) {
 			return properties[property];
 		},
 		async setProperty(property, value) {
-			const sensorNamespace = `plugin.${data.pluginId}.camera.${cameraId}.sensor.${data.id}.rpc`;
+			const sensorNamespace = `plugin.${data.pluginId}.sensor.${data.id}.rpc`;
 			await rpcCall(rpcRef, (client) => client.createProxy(sensorNamespace).updateValue(property, value));
 		},
 		async setDisplayName(newDisplayName) {
-			const namespace = NamespaceManager.sensorControllerNamespaces(cameraId);
-			await rpcCall(rpcRef, (client) => client.createProxy(namespace.sensorRpc).setDisplayName(data.id, newDisplayName));
+			const namespace = NamespaceManager.sensorRegistryNamespaces();
+			await rpcCall(rpcRef, (client) => client.createProxy(namespace.sensorsRpc).setDisplayName(data.id, newDisplayName));
 		},
 		hasCapability(capability) {
 			return capabilities.value.includes(capability);
@@ -1151,7 +1181,8 @@ function createReactiveSensor(data, state, rpcRef, cameraId) {
 		}
 	};
 }
-function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sensorRpcNamespace) {
+function createSensorManager(rpcOrContext) {
+	const { sensorsSubject, sensorsRpc } = NamespaceManager.sensorRegistryNamespaces();
 	const ctx = "rpc" in rpcOrContext && "value" in rpcOrContext.rpc ? rpcOrContext : void 0;
 	const rpcRef = ctx ? ctx.rpc : shallowRef(rpcOrContext);
 	const sensorMap = shallowRef(/* @__PURE__ */ new Map());
@@ -1176,7 +1207,7 @@ function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sen
 	}
 	async function subscribeToSensorEvents(sensorId) {
 		if (sensorSubscriptions.has(sensorId)) return;
-		const namespace = NamespaceManager.sensorEventNamespaces(cameraId, sensorId);
+		const namespace = NamespaceManager.sensorEventNamespaces(sensorId);
 		const unsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(namespace.sensorSubject, (msg) => handlePerSensorEvent(sensorId, msg)));
 		sensorSubscriptions.set(sensorId, unsubscribe);
 	}
@@ -1191,17 +1222,33 @@ function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sen
 		if (message.type === "sensor:added") {
 			const event = message.data;
 			if (sensorMap.value.has(event.sensor.id)) return;
-			const reactiveSensor = createReactiveSensor(event.sensor, event.state, rpcRef, cameraId);
+			const reactiveSensor = createReactiveSensor(event.sensor, event.state, rpcRef);
 			const newMap = new Map(sensorMap.value);
 			newMap.set(event.sensor.id, reactiveSensor);
 			sensorMap.value = newMap;
 			subscribeToSensorEvents(event.sensor.id);
-		} else if (message.type === "sensor:removed") {
+		} else if (message.type === "sensor:deleted") {
 			const event = message.data;
 			unsubscribeFromSensorEvents(event.sensorId);
 			const newMap = new Map(sensorMap.value);
 			newMap.delete(event.sensorId);
 			sensorMap.value = newMap;
+		} else if (message.type === "sensor:connected:changed") {
+			const event = message.data;
+			const sensor = sensorMap.value.get(event.sensorId);
+			if (sensor) sensor.connected.value = event.connected;
+		} else if (message.type === "sensor:assignment:changed") {
+			const event = message.data;
+			const sensor = sensorMap.value.get(event.sensorId);
+			if (!sensor) return;
+			const cameras = new Set(sensor.assignedCameraIds.value);
+			if (event.assigned) cameras.add(event.cameraId);
+			else cameras.delete(event.cameraId);
+			sensor.assignedCameraIds.value = [...cameras];
+		} else if (message.type === "sensor:exposed:changed") {
+			const event = message.data;
+			const sensor = sensorMap.value.get(event.sensorId);
+			if (sensor) sensor.exposed.value = event.exposed;
 		}
 	}
 	async function doInit() {
@@ -1211,12 +1258,12 @@ function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sen
 		sensorSubscriptions.clear();
 		sensorMap.value = /* @__PURE__ */ new Map();
 		let pendingEvents = [];
-		globalUnsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(sensorSubjectNamespace, (msg) => {
+		globalUnsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(sensorsSubject, (msg) => {
 			if (pendingEvents) pendingEvents.push(msg);
 			else handleGlobalSensorEvent(msg);
 		}));
 		const [sensors, states] = await rpcCall(rpcRef, async (c) => {
-			const proxy = c.createProxy(sensorRpcNamespace);
+			const proxy = c.createProxy(sensorsRpc);
 			return Promise.all([proxy.getSensors(), proxy.getSensorStates()]);
 		});
 		const newMap = /* @__PURE__ */ new Map();
@@ -1225,7 +1272,7 @@ function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sen
 				properties: {},
 				capabilities: [],
 				type: sensor.type
-			}, rpcRef, cameraId);
+			}, rpcRef);
 			newMap.set(sensor.id, reactiveSensor);
 		}
 		sensorMap.value = newMap;
@@ -1281,7 +1328,7 @@ function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sen
 			return sensors.value.some((s) => s.type === type);
 		},
 		async setDisplayName(sensorId, displayName) {
-			await rpcCall(rpcRef, (c) => c.createProxy(sensorRpcNamespace).setDisplayName(sensorId, displayName));
+			await rpcCall(rpcRef, (c) => c.createProxy(sensorsRpc).setDisplayName(sensorId, displayName));
 		},
 		ensureInitialized,
 		reconnect,
@@ -1300,33 +1347,29 @@ function reconnectAllSensorManagers() {
 		cached.initPromise = cached.manager.reconnect();
 	});
 }
-function acquireSensorManager(cameraId, rpcOrContext) {
-	return sensorManagerCache.acquire(cameraId, () => {
-		const namespaces = NamespaceManager.sensorControllerNamespaces(cameraId);
-		return { manager: createSensorManager(rpcOrContext, cameraId, namespaces.sensorSubject, namespaces.sensorRpc) };
-	});
+var GLOBAL_SENSOR_MANAGER_KEY = "sensors";
+function acquireSensorManager(rpcOrContext) {
+	return sensorManagerCache.acquire(GLOBAL_SENSOR_MANAGER_KEY, () => ({ manager: createSensorManager(rpcOrContext) }));
 }
-function releaseSensorManager(cameraId) {
-	sensorManagerCache.release(cameraId);
+function releaseSensorManager() {
+	sensorManagerCache.release(GLOBAL_SENSOR_MANAGER_KEY);
 }
 function createSensorComposableState() {
 	return {
-		currentCameraId: void 0,
+		acquired: false,
 		cachedManager: void 0
 	};
 }
-async function ensureSensorManager(state, cameraUi, isConnected, cameraId, isLoading, error) {
+function sensorsForCamera(manager, cameraId) {
+	return manager.sensors.value.filter((sensor) => sensor.assignedCameraIds.value.includes(cameraId));
+}
+async function ensureSensorManager(state, cameraUi, isConnected, isLoading, error) {
 	if (!cameraUi.rpc.value || !isConnected) return void 0;
-	if (state.currentCameraId && state.currentCameraId !== cameraId) {
-		releaseSensorManager(state.currentCameraId);
-		state.currentCameraId = void 0;
-		state.cachedManager = void 0;
-	}
 	isLoading.value = true;
 	error.value = void 0;
 	try {
-		const cached = acquireSensorManager(cameraId, cameraUi);
-		state.currentCameraId = cameraId;
+		const cached = acquireSensorManager(cameraUi);
+		state.acquired = true;
 		state.cachedManager = cached.manager;
 		if (!cached.initPromise) cached.initPromise = cached.manager.ensureInitialized();
 		await cached.initPromise;
@@ -1339,9 +1382,9 @@ async function ensureSensorManager(state, cameraUi, isConnected, cameraId, isLoa
 	}
 }
 function cleanupSensorComposable(state) {
-	if (state.currentCameraId) {
-		releaseSensorManager(state.currentCameraId);
-		state.currentCameraId = void 0;
+	if (state.acquired) {
+		releaseSensorManager();
+		state.acquired = false;
 		state.cachedManager = void 0;
 	}
 }
@@ -1359,7 +1402,7 @@ function useSensorById(camera, sensorId) {
 		() => toValue(sensorId)
 	], async ([connected, camId, senId]) => {
 		if (connected && camId && senId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
 			sensor.value = manager?.getSensor(senId);
 			initialLoadDone.value = true;
 		} else {
@@ -1391,8 +1434,8 @@ function useSensorByType(camera, sensorType) {
 		() => toValue(sensorType)
 	], async ([connected, camId, type]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
-			sensor.value = manager?.getSensorsByType(type)[0];
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			sensor.value = manager ? sensorsForCamera(manager, camId).find((s) => s.type === type) : void 0;
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1424,9 +1467,9 @@ function useSensorsByType(camera, sensorType) {
 		() => toValue(sensorType)
 	], async ([connected, camId, type]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
 			cachedManager.value = manager;
-			sensorsRef.value = manager?.getSensorsByType(type) ?? [];
+			sensorsRef.value = manager ? sensorsForCamera(manager, camId).filter((s) => s.type === type) : [];
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1436,8 +1479,10 @@ function useSensorsByType(camera, sensorType) {
 	}, { immediate: true });
 	const sensors = computed(() => {
 		if (!cachedManager.value) return [];
+		const camId = extractCameraId(toValue(camera));
 		const type = toValue(sensorType);
-		return cachedManager.value.sensors.value.filter((s) => s.type === type);
+		if (!camId) return [];
+		return sensorsForCamera(cachedManager.value, camId).filter((s) => s.type === type);
 	});
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
@@ -1460,9 +1505,9 @@ function useSensors(camera) {
 	const state = createSensorComposableState();
 	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
 			cachedManager.value = manager;
-			sensorsRef.value = manager?.sensors.value ?? [];
+			sensorsRef.value = manager ? sensorsForCamera(manager, camId) : [];
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1470,7 +1515,12 @@ function useSensors(camera) {
 			cachedManager.value = void 0;
 		}
 	}, { immediate: true });
-	const sensors = computed(() => cachedManager.value?.sensors.value ?? []);
+	const sensors = computed(() => {
+		if (!cachedManager.value) return [];
+		const camId = extractCameraId(toValue(camera));
+		if (!camId) return [];
+		return sensorsForCamera(cachedManager.value, camId);
+	});
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensorsRef.value = [];
@@ -1481,6 +1531,33 @@ function useSensors(camera) {
 		error
 	};
 }
+function useAllSensors() {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const cachedManager = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([isConnected], async ([connected]) => {
+		if (connected) {
+			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			cachedManager.value = void 0;
+		}
+	}, { immediate: true });
+	const sensors = computed(() => cachedManager.value?.sensors.value ?? []);
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+	});
+	return {
+		sensors,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
 function useTypedSensor(camera, sensorType) {
 	const cameraUi = useCameraUi();
 	const { isConnected } = cameraUi;
@@ -1492,9 +1569,9 @@ function useTypedSensor(camera, sensorType) {
 	const state = createSensorComposableState();
 	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
 			cachedManager.value = manager;
-			sensor.value = manager?.getSensorsByType(sensorType)[0];
+			sensor.value = manager ? sensorsForCamera(manager, camId).find((s) => s.type === sensorType) : void 0;
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1503,11 +1580,13 @@ function useTypedSensor(camera, sensorType) {
 	}, { immediate: true });
 	watch(() => {
 		if (!cachedManager.value) return void 0;
-		return cachedManager.value.getSensorsByType(sensorType)[0]?.id;
+		const camId = extractCameraId(toValue(camera));
+		if (!camId) return void 0;
+		return sensorsForCamera(cachedManager.value, camId).find((s) => s.type === sensorType)?.id;
 	}, () => {
 		if (cachedManager.value) {
-			const sensors = cachedManager.value.getSensorsByType(sensorType);
-			sensor.value = sensors[0];
+			const camId = extractCameraId(toValue(camera));
+			sensor.value = camId ? sensorsForCamera(cachedManager.value, camId).find((s) => s.type === sensorType) : void 0;
 		}
 	});
 	tryOnScopeDispose(() => {
@@ -1549,9 +1628,9 @@ function useClassifierSensors(camera) {
 	const state = createSensorComposableState();
 	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
 			cachedManager.value = manager;
-			sensorsRef.value = manager?.getSensorsByType(SensorType.Classifier) ?? [];
+			sensorsRef.value = manager ? sensorsForCamera(manager, camId).filter((s) => s.type === SensorType.Classifier) : [];
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1559,7 +1638,12 @@ function useClassifierSensors(camera) {
 			cachedManager.value = void 0;
 		}
 	}, { immediate: true });
-	const sensors = computed(() => cachedManager.value?.getSensorsByType(SensorType.Classifier) ?? []);
+	const sensors = computed(() => {
+		if (!cachedManager.value) return [];
+		const camId = extractCameraId(toValue(camera));
+		if (!camId) return [];
+		return sensorsForCamera(cachedManager.value, camId).filter((s) => s.type === SensorType.Classifier);
+	});
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensorsRef.value = [];
@@ -1663,8 +1747,8 @@ function getPluginStorageKey(pluginId) {
 function getCameraStorageKey(pluginId, cameraId) {
 	return `plugin:${pluginId}:camera:${cameraId}`;
 }
-function getSensorStorageKey(pluginId, cameraId, sensorId) {
-	return `plugin:${pluginId}:camera:${cameraId}:sensor:${sensorId}`;
+function getSensorStorageKey(pluginId, sensorId) {
+	return `plugin:${pluginId}:sensor:${sensorId}`;
 }
 function acquireStorage(key, createProxy) {
 	return storageCache.acquire(key, () => {
@@ -1874,7 +1958,7 @@ function useCameraStorage(camera, pluginName) {
 		submitValue: operations.submitValue
 	};
 }
-function useSensorStorage(camera, sensorId, pluginId) {
+function useSensorStorage(sensorId, pluginId) {
 	const { rpc, isConnected: clientConnected } = useCameraUi();
 	const config = shallowRef();
 	const _isLoading = ref(false);
@@ -1883,14 +1967,14 @@ function useSensorStorage(camera, sensorId, pluginId) {
 	const isConnected = ref(false);
 	const state = createStorageState();
 	const operations = createStorageOperations(state, config, _isLoading, error);
-	function connect(cameraId, senId, plugId) {
+	function connect(senId, plugId) {
 		if (!rpc.value || !clientConnected.value) return false;
 		try {
-			const storageKey = getSensorStorageKey(plugId, cameraId, senId);
+			const storageKey = getSensorStorageKey(plugId, senId);
 			if (state.currentStorageKey && state.currentStorageKey !== storageKey) releaseStorage(state.currentStorageKey);
 			state.currentStorageKey = storageKey;
 			state.cachedStorage = acquireStorage(storageKey, () => {
-				const namespaces = NamespaceManager.pluginSensorNamespaces(plugId, cameraId, senId);
+				const namespaces = NamespaceManager.pluginSensorNamespaces(plugId, senId);
 				return rpc.value.createProxy(namespaces.sensorStorageRpc);
 			});
 			isConnected.value = true;
@@ -1902,23 +1986,21 @@ function useSensorStorage(camera, sensorId, pluginId) {
 		}
 	}
 	async function getConfig() {
-		const cameraId = extractCameraId(toValue(camera));
 		const senId = toValue(sensorId);
 		const plugId = toValue(pluginId);
-		if (!cameraId || !senId || !plugId) return void 0;
+		if (!senId || !plugId) return void 0;
 		if (!state.cachedStorage) {
-			if (!connect(cameraId, senId, plugId)) return void 0;
+			if (!connect(senId, plugId)) return void 0;
 		}
 		return operations.getConfig();
 	}
 	watch([
 		clientConnected,
-		() => extractCameraId(toValue(camera)),
 		() => toValue(sensorId),
 		() => toValue(pluginId)
-	], ([connected, cameraId, senId, plugId]) => {
-		if (connected && cameraId && senId && plugId) {
-			connect(cameraId, senId, plugId);
+	], ([connected, senId, plugId]) => {
+		if (connected && senId && plugId) {
+			connect(senId, plugId);
 			operations.getConfig();
 		} else cleanupStorage(state, isConnected, config);
 		initialSetupDone.value = true;
@@ -2106,14 +2188,12 @@ function createActivityMode(options) {
 					startIdleTimer();
 				}
 				break;
-			case "activity":
-				if (hasActivity.value) {
-					inStandby.value = false;
-					if (!isStreamPlaying()) onStreamStart();
-				} else activityTimeout = setTimeout(() => {
-					if (mode.value === "activity" && !hasActivity.value) goToStandby();
-				}, resolvedConfig.activityTimeout);
-				break;
+			case "activity": if (hasActivity.value) {
+				inStandby.value = false;
+				if (!isStreamPlaying()) onStreamStart();
+			} else activityTimeout = setTimeout(() => {
+				if (mode.value === "activity" && !hasActivity.value) goToStandby();
+			}, resolvedConfig.activityTimeout);
 		}
 	}
 	function startIdleTimer() {
@@ -2154,7 +2234,6 @@ function createActivityMode(options) {
 				if (!hasActivity.value) activityTimeout = setTimeout(() => {
 					goToStandby();
 				}, resolvedConfig.activityTimeout);
-				break;
 		}
 	}
 	function resetIdleTimer() {
@@ -2293,7 +2372,7 @@ var STREAM_CONFIG = {
 		ICE_SERVERS: [{ urls: "stun:stun.l.google.com:19302" }]
 	},
 	MSE: {
-		BUFFER_SIZE: 2 * 1024 * 1024,
+		BUFFER_SIZE: 2097152,
 		BUFFER_WINDOW: 5
 	},
 	CODECS: {
@@ -2755,9 +2834,7 @@ async function processWebRTCMessage(handler, msg) {
 		case "webrtc/answer":
 			await handler.handleAnswer(msg.value);
 			break;
-		case "webrtc/candidate":
-			if (msg.value) await handler.handleCandidate(msg.value);
-			break;
+		case "webrtc/candidate": if (msg.value) await handler.handleCandidate(msg.value);
 	}
 }
 //#endregion
@@ -3390,12 +3467,10 @@ var StreamConnection = class {
 			case "mse":
 				if (this.mseHandler && typeof msg.value === "string") this.mseHandler.initializeBuffer(msg.value);
 				break;
-			case "error":
-				if (this.requestedMode.value !== "auto") {
-					this.error.value = new Error(msg.value);
-					this.status.value = "error";
-				}
-				break;
+			case "error": if (this.requestedMode.value !== "auto") {
+				this.error.value = new Error(msg.value);
+				this.status.value = "error";
+			}
 		}
 	}
 	async startWebRTC(mode) {
@@ -4575,4 +4650,4 @@ function useTerminal() {
 	};
 }
 //#endregion
-export { CAMERA_UI_INJECTION_KEY, NamespaceManager, STREAM_CONFIG, acquireSensorManager, clearCameraCache, clearOAuthCache, clearPluginCache, clearSensorCache, clearSnapshotCache, clearStorageCache, createActivityMode, createCameraUiPlugin, createReactiveCameraDevice, createSensorManager, getSnapshotUrl, isReactiveAudioSensor, isReactiveBatteryInfo, isReactiveClassifierSensor, isReactiveContactSensor, isReactiveDoorbellTrigger, isReactiveFaceSensor, isReactiveGarageControl, isReactiveHumidityInfo, isReactiveLeakSensor, isReactiveLicensePlateSensor, isReactiveLightControl, isReactiveLockControl, isReactiveMotionSensor, isReactiveObjectSensor, isReactiveOccupancySensor, isReactivePTZControl, isReactiveSecuritySystem, isReactiveSirenControl, isReactiveSmokeSensor, isReactiveSwitchControl, isReactiveTemperatureInfo, refreshClientSubscriptions, releaseSensorManager, resetClientState, rpcCall, useAudioSensor, useCameraById, useCameraStorage, useCameraStream, useCameraUi, useClassifierSensors, useCoreManager, useCuiFullscreen, useDeviceManager, useFaceSensor, useLicensePlateSensor, useMotionSensor, useOAuth, useObjectSensor, usePTZControl, usePlugin, usePluginStorage, useRpcCall, useRpcSubscription, useSensorById, useSensorByType, useSensorStorage, useSensors, useSensorsByType, useSnapshot, useTabVisibility, useTerminal, useTopmostFullscreenElement };
+export { CAMERA_UI_INJECTION_KEY, NamespaceManager, STREAM_CONFIG, acquireSensorManager, clearCameraCache, clearOAuthCache, clearPluginCache, clearSensorCache, clearSnapshotCache, clearStorageCache, createActivityMode, createCameraUiPlugin, createReactiveCameraDevice, createSensorManager, getSnapshotUrl, isReactiveAudioSensor, isReactiveBatteryInfo, isReactiveClassifierSensor, isReactiveContactSensor, isReactiveDoorbellTrigger, isReactiveFaceSensor, isReactiveGarageControl, isReactiveHumidityInfo, isReactiveLeakSensor, isReactiveLicensePlateSensor, isReactiveLightControl, isReactiveLockControl, isReactiveMotionSensor, isReactiveObjectSensor, isReactiveOccupancySensor, isReactivePTZControl, isReactiveSecuritySystem, isReactiveSirenControl, isReactiveSmokeSensor, isReactiveSwitchControl, isReactiveTemperatureInfo, refreshClientSubscriptions, releaseSensorManager, resetClientState, rpcCall, useAllSensors, useAudioSensor, useCameraById, useCameraStorage, useCameraStream, useCameraUi, useClassifierSensors, useCoreManager, useCuiFullscreen, useDeviceManager, useFaceSensor, useLicensePlateSensor, useMotionSensor, useOAuth, useObjectSensor, usePTZControl, usePlugin, usePluginStorage, useRpcCall, useRpcSubscription, useSensorById, useSensorByType, useSensorStorage, useSensors, useSensorsByType, useSnapshot, useTabVisibility, useTerminal, useTopmostFullscreenElement };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camera.ui/browser",
-  "version": "0.0.147",
+  "version": "0.0.148",
   "description": "camera.ui browser client",
   "author": "seydx (https://github.com/cameraui/clients)",
   "type": "module",
@@ -31,15 +31,15 @@
   "peerDependencies": {
     "@camera.ui/logger": ">=0.0.2",
     "@camera.ui/rpc": ">=1.0.10",
-    "@camera.ui/sdk": ">=0.0.33",
+    "@camera.ui/sdk": ">=1.2.0",
     "@camera.ui/transport": ">=0.0.1",
-    "@vueuse/core": ">=14.3.0",
+    "@vueuse/core": ">=14.4.0",
     "vue": ">=3.5.40"
   },
   "devDependencies": {
     "@camera.ui/logger": "file:../../packages/logger",
     "@camera.ui/rpc": "^1.0.10",
-    "@camera.ui/sdk": "~0.0.33",
+    "@camera.ui/sdk": "~1.2.0",
     "@camera.ui/transport": "file:../../packages/transport",
     "@eneris/push-receiver": "^4.3.1",
     "@microsoft/api-extractor": "^7.58.12",
@@ -51,7 +51,7 @@
     "@vue/eslint-config-typescript": "^14.9.0",
     "@vue/language-core": "^3.3.8",
     "@vue/tsconfig": "^0.9.1",
-    "@vueuse/core": "^14.3.0",
+    "@vueuse/core": "^14.4.0",
     "@webgpu/types": "^0.1.71",
     "eslint": "9.39.2",
     "eslint-plugin-vue": "^10.10.0",
@@ -61,8 +61,8 @@
     "typescript": "5.9.3",
     "typescript-eslint": "^8.65.0",
     "unplugin-dts": "^1.0.3",
-    "updates": "^17.19.2",
-    "vite": "^8.1.5",
+    "updates": "^17.20.1",
+    "vite": "^8.2.0",
     "vitest": "^4.1.10",
     "vue": "^3.5.40",
     "vue-tsc": "^3.3.8"