@camera.ui/browser 0.0.146 → 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 {
 }
@@ -163,6 +163,8 @@ export declare interface CameraStream {
     readonly isPlaying: Ref<boolean>;
     readonly activeMode: Ref<'webrtc' | 'webrtc/tcp' | 'mse'>;
     readonly activeResolution: Ref<StreamingRole>;
+    readonly degradedFrom: Ref<StreamingRole | null>;
+    readonly unsupported: Ref<boolean>;
     readonly hasAudio: Ref<boolean>;
     readonly hasBackchannel: Ref<boolean>;
     readonly error: Ref<Error | undefined>;
@@ -286,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[];
@@ -392,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 */
@@ -466,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`,
         };
     }
 
@@ -504,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',
@@ -782,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;
@@ -837,6 +858,8 @@ export declare interface ReactiveStream {
     readonly requestedMode: Ref<VideoStreamingMode>;
     readonly activeResolution: Ref<StreamingRole>;
     readonly requestedResolution: Ref<StreamingRole>;
+    readonly degradedFrom: Ref<StreamingRole | null>;
+    readonly degradeReason: Ref<StreamDegradeReason | null>;
     readonly source: Ref<CameraSource | undefined>;
     readonly hasVideo: Ref<boolean>;
     readonly hasAudio: Ref<boolean>;
@@ -882,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;
 
@@ -904,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;
 }
@@ -959,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 */
@@ -991,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;
@@ -1023,6 +1065,8 @@ export declare const STREAM_CONFIG: {
     };
 };
 
+declare type StreamDegradeReason = 'codec';
+
 export declare interface StreamOptions {
     camera: MaybeRefOrGetter<ReactiveCameraDevice | undefined>;
     videoElement: MaybeRefOrGetter<HTMLVideoElement | undefined | null>;
@@ -1034,7 +1078,7 @@ export declare interface StreamOptions {
     webrtcConnectTimeout?: number;
 }
 
-export declare type StreamStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'closed';
+export declare type StreamStatus = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error' | 'unsupported' | 'closed';
 
 /* Excluded from this release type: SwitchControlProperties */
 
@@ -1071,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;
@@ -1206,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: {
@@ -2322,6 +2401,7 @@ var STREAM_CONFIG = {
 };
 //#endregion
 //#region src/streaming/utils.ts
+var H265_TEST_CODEC = "hvc1.1.6.L153.B0";
 function safariVersion() {
 	return navigator.userAgent.match(/version\/(\d+)/i);
 }
@@ -2354,14 +2434,27 @@ function isWebRTCCompatibleVideo(codec) {
 	if (codec === "H265") return isH265Supported();
 	return false;
 }
-function isH265Supported() {
-	try {
-		const videoCodecs = RTCRtpSender?.getCapabilities("video")?.codecs;
-		if (!videoCodecs) return false;
-		return videoCodecs.some((c) => c.mimeType.toLowerCase().includes("h265") || c.mimeType.toLowerCase().includes("hevc"));
+var mseH265;
+var webrtcH265;
+function canPlayH265(transport) {
+	if (transport === "auto") return canPlayH265("webrtc") || canPlayH265("mse");
+	if (transport === "mse") {
+		if (mseH265 === void 0) mseH265 = !!getMediaSourceConstructor()?.isTypeSupported(`video/mp4; codecs="${H265_TEST_CODEC}"`);
+		return mseH265;
+	}
+	if (webrtcH265 === void 0) try {
+		webrtcH265 = !!(RTCRtpReceiver?.getCapabilities("video")?.codecs)?.some((c) => c.mimeType.toLowerCase().includes("h265") || c.mimeType.toLowerCase().includes("hevc"));
 	} catch {
-		return false;
+		webrtcH265 = false;
 	}
+	return webrtcH265;
+}
+function reportH265DecodeFailure(transport) {
+	if (transport === "mse") mseH265 = false;
+	else webrtcH265 = false;
+}
+function isH265Supported() {
+	return canPlayH265("webrtc");
 }
 function checkWebRTCCompatibility(probe) {
 	const audioStreams = probe.audio.filter((s) => s.direction === "sendonly");
@@ -2741,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
@@ -2755,6 +2846,8 @@ var StreamConnection = class {
 	requestedMode;
 	activeResolution;
 	requestedResolution;
+	degradedFrom;
+	degradeReason;
 	source;
 	hasVideo;
 	hasAudio;
@@ -2766,14 +2859,20 @@ var StreamConnection = class {
 	paused;
 	nativeWidth;
 	nativeHeight;
+	camera;
+	videoElement;
+	containerElement;
+	target;
+	isReady;
+	effectiveMode;
+	triedSourceIds = /* @__PURE__ */ new Set();
 	options;
+	wsTransport;
+	scope = effectScope(true);
 	connectionGeneration = 0;
 	abortController = new AbortController();
-	scope = effectScope(true);
-	offTabVisible;
-	offTabPaused;
+	probedSourceId;
 	wasPausedByVisibility = false;
-	wsTransport;
 	wsHandle;
 	webrtcHandler;
 	mseHandler;
@@ -2783,15 +2882,11 @@ var StreamConnection = class {
 	lastMediaStream = null;
 	stopWatchers = [];
 	mseMonitorInterval;
+	offTabVisible;
+	offTabPaused;
 	onVideoPauseBound;
 	onVideoPlayBound;
 	onVideoResizeBound;
-	camera;
-	videoElement;
-	containerElement;
-	target;
-	isReady;
-	effectiveMode;
 	startWsConnectTimeout;
 	stopWsConnectTimeout;
 	startConnectTimeout;
@@ -2810,6 +2905,8 @@ var StreamConnection = class {
 		this.status = ref("idle");
 		this.activeMode = ref("webrtc");
 		this.activeResolution = ref("low-resolution");
+		this.degradedFrom = ref(null);
+		this.degradeReason = ref(null);
 		this.source = shallowRef();
 		this.hasVideo = ref(false);
 		this.hasAudio = ref(false);
@@ -2846,11 +2943,18 @@ var StreamConnection = class {
 					this.activeMode.value = "mse";
 					if (this.mseHandler?.isReady) this.status.value = "connected";
 					else this.startMSE();
-				} else this.restart();
+				} else {
+					this.markSourceUndecodable();
+					this.restart();
+				}
+				else if (this.status.value === "connected" && !this.isPlaying.value && !this.abortController.signal.aborted && this.sourceLikelyH265()) this.handleNoFramesWhileConnected();
 			}, STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
 			const mseConnectTimeout = useTimeoutFn(() => {
 				if (this.abortController.signal.aborted || this.status.value === "connected" || this.status.value === "closed") return;
-				if (this.mseHandler && !this.mseHandler.isReady) this.restart();
+				if (this.mseHandler && !this.mseHandler.isReady) {
+					this.markSourceUndecodable();
+					this.restart();
+				}
 			}, STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
 			const reconnectTimeout = useTimeoutFn(() => {
 				if (!this.abortController.signal.aborted) this.restart();
@@ -2901,22 +3005,43 @@ var StreamConnection = class {
 		this.cleanup();
 		this.abortController = new AbortController();
 		const gen = ++this.connectionGeneration;
+		this.triedSourceIds.clear();
 		this.status.value = "connecting";
 		this.error.value = void 0;
 		this.isPlaying.value = false;
 		try {
-			if (!this.initializeSource()) {
+			const init = this.initializeSource();
+			if (init === "unsupported") {
+				log.debug("start() — no source with a playable codec");
+				this.setUnsupported();
+				return;
+			}
+			if (!init) {
 				log.debug("start() — no streaming source available");
 				this.error.value = /* @__PURE__ */ new Error("No streaming source available");
 				this.status.value = "error";
 				return;
 			}
-			await this.probeStream();
-			if (gen !== this.connectionGeneration) {
-				log.debug("start() — generation stale after probe, aborting");
-				return;
+			for (let attempt = 0; attempt < 3; attempt++) {
+				const probedSourceId = this.source.value?._id;
+				const probe = await this.probeStream();
+				if (gen !== this.connectionGeneration) {
+					log.debug("start() — generation stale after probe, aborting");
+					return;
+				}
+				if (probe && probedSourceId && this.probeSaysUnplayable(probe)) this.triedSourceIds.add(probedSourceId);
+				const reinit = this.initializeSource();
+				if (reinit === "unsupported") {
+					this.setUnsupported();
+					return;
+				}
+				if (!reinit) {
+					this.error.value = /* @__PURE__ */ new Error("No streaming source available");
+					this.status.value = "error";
+					return;
+				}
+				if (!probe || this.source.value?._id === probedSourceId) break;
 			}
-			this.initializeSource();
 			log.debug("start() — connecting WebSocket");
 			this.connectWebSocket();
 		} catch (err) {
@@ -2940,15 +3065,27 @@ var StreamConnection = class {
 		if (this.requestedMode.value === mode) return;
 		this.requestedMode.value = mode;
 		this.activeMode.value = mode === "auto" ? "webrtc" : mode;
+		if (this.status.value === "unsupported") {
+			this.stop();
+			await this.start();
+			return;
+		}
 		if (this.status.value === "connected") await this.restart();
 	}
 	async setResolution(resolution) {
 		if (this.requestedResolution.value === resolution) return;
 		this.requestedResolution.value = resolution;
+		if (this.status.value === "unsupported") {
+			this.stop();
+			await this.start();
+			return;
+		}
 		const result = this.getSourceForResolution(resolution);
-		if (result && result.source._id !== this.source.value?._id) {
+		if (result && result !== "unsupported" && result.source._id !== this.source.value?._id) {
 			this.source.value = result.source;
 			this.activeResolution.value = result.effectiveResolution;
+			this.degradedFrom.value = result.degradedFrom;
+			this.degradeReason.value = result.degradedFrom ? "codec" : null;
 			if (this.status.value === "connected") await this.restart();
 		}
 	}
@@ -3023,7 +3160,12 @@ var StreamConnection = class {
 			return;
 		}
 		try {
-			if (!this.initializeSource()) {
+			const init = this.initializeSource();
+			if (init === "unsupported") {
+				this.setUnsupported();
+				return;
+			}
+			if (!init) {
 				this.error.value = /* @__PURE__ */ new Error("No streaming source available");
 				this.status.value = "error";
 				return;
@@ -3057,6 +3199,12 @@ var StreamConnection = class {
 			this.restart();
 		});
 		this.stopWatchers.push(stopAuthWatch);
+		const stopSourcesWatch = watch(() => this.camera.value?.sources.value, () => {
+			if (this.status.value !== "unsupported") return;
+			this.stop();
+			this.start();
+		});
+		this.stopWatchers.push(stopSourcesWatch);
 		const stopModeWatch = watch(() => toValue(this.options.mode), (newMode) => {
 			if (newMode !== void 0 && newMode !== this.requestedMode.value) this.setMode(newMode);
 		});
@@ -3107,6 +3255,9 @@ var StreamConnection = class {
 			if (newCamera !== oldCamera) {
 				if (this.status.value === "connected") {
 					if (newCamera && newVideo && newClient) this.restart();
+				} else if (this.status.value === "unsupported" && newCamera && newVideo && newClient) {
+					this.stop();
+					this.start();
 				}
 			} else if (newVideo !== oldVideo && newVideo) {
 				if (newVideo.srcObject instanceof MediaStream) {
@@ -3144,6 +3295,14 @@ var StreamConnection = class {
 		});
 		this.stopWatchers.push(stopCameraWatch);
 	}
+	isSourcePlayable(source) {
+		if (this.triedSourceIds.has(source._id)) return false;
+		if (source.videoCodec !== "H265") return true;
+		const mode = this.requestedMode.value;
+		if (mode === "auto") return canPlayH265("auto");
+		if (mode === "mse") return canPlayH265("mse");
+		return canPlayH265("webrtc");
+	}
 	getSourceForResolution(resolution) {
 		const cam = this.camera.value;
 		if (!cam) return void 0;
@@ -3152,43 +3311,89 @@ var StreamConnection = class {
 			"mid-resolution",
 			"low-resolution"
 		];
-		const exactSource = cam.sources.value.find((s) => s.role === resolution);
-		if (exactSource) return {
-			source: exactSource,
-			effectiveResolution: resolution
-		};
-		const startIndex = resolutionOrder.indexOf(resolution);
+		const startIndex = Math.max(0, resolutionOrder.indexOf(resolution));
+		let skippedUnplayable = false;
 		for (let i = startIndex; i < resolutionOrder.length; i++) {
 			const src = cam.sources.value.find((s) => s.role === resolutionOrder[i]);
-			if (src) return {
+			if (!src) continue;
+			if (!this.isSourcePlayable(src)) {
+				skippedUnplayable = true;
+				continue;
+			}
+			return {
 				source: src,
-				effectiveResolution: resolutionOrder[i]
+				effectiveResolution: resolutionOrder[i],
+				degradedFrom: skippedUnplayable ? resolution : null
 			};
 		}
 		const fallback = cam.streamSource.value;
-		if (fallback) return {
+		if (fallback && this.isSourcePlayable(fallback)) return {
 			source: fallback,
-			effectiveResolution: fallback.role ?? "low-resolution"
+			effectiveResolution: fallback.role ?? "low-resolution",
+			degradedFrom: skippedUnplayable ? resolution : null
 		};
+		if (skippedUnplayable || fallback) return "unsupported";
 	}
 	initializeSource() {
 		const result = this.getSourceForResolution(this.requestedResolution.value);
 		if (!result) return false;
+		if (result === "unsupported") return "unsupported";
 		this.source.value = result.source;
 		this.activeResolution.value = result.effectiveResolution;
+		this.degradedFrom.value = result.degradedFrom;
+		this.degradeReason.value = result.degradedFrom ? "codec" : null;
+		if (this.probedSourceId && this.probedSourceId !== result.source._id) {
+			this.probeInfo.value = void 0;
+			this.probedSourceId = void 0;
+			this.hasVideo.value = false;
+			this.hasAudio.value = false;
+			this.hasBackchannel.value = false;
+		}
 		return true;
 	}
+	setUnsupported() {
+		const codec = this.camera.value?.sources.value.find((s) => s.videoCodec)?.videoCodec ?? "H265";
+		this.error.value = /* @__PURE__ */ new Error(`${codec} cannot be played on this device`);
+		this.status.value = "unsupported";
+	}
+	probeSaysUnplayable(probe) {
+		const video = probe.video.filter((v) => v.direction === "sendonly");
+		if (!video.length) return false;
+		if (!video.every((v) => v.codec === "H265")) return false;
+		const mode = this.requestedMode.value;
+		return !canPlayH265(mode === "auto" ? "auto" : mode === "mse" ? "mse" : "webrtc");
+	}
+	sourceLikelyH265() {
+		const src = this.source.value;
+		if (!src) return false;
+		if (src.videoCodec === "H265") return true;
+		if (src.videoCodec !== void 0) return false;
+		const video = this.probeInfo.value?.video.filter((v) => v.direction === "sendonly") ?? [];
+		return video.length > 0 && video.every((v) => v.codec === "H265");
+	}
+	markSourceUndecodable() {
+		const src = this.source.value;
+		if (!src || !this.sourceLikelyH265()) return;
+		this.triedSourceIds.add(src._id);
+	}
+	handleNoFramesWhileConnected() {
+		reportH265DecodeFailure(this.activeMode.value === "mse" ? "mse" : "webrtc");
+		this.markSourceUndecodable();
+		this.restart();
+	}
 	async probeStream() {
 		const cam = this.camera.value;
-		if (!cam || !this.source.value || this.abortController.signal.aborted) return void 0;
+		const source = this.source.value;
+		if (!cam || !source || this.abortController.signal.aborted) return void 0;
 		try {
-			const probe = await cam.probeStream(this.source.value._id, {
+			const probe = await cam.probeStream(source._id, {
 				video: true,
 				audio: ["pcma", "opus"],
 				microphone: true
 			});
 			if (probe && !this.abortController.signal.aborted) {
 				this.probeInfo.value = probe;
+				this.probedSourceId = source._id;
 				this.hasBackchannel.value = probe.audio.some((a) => a.direction === "recvonly");
 				this.hasAudio.value = probe.audio.filter((a) => a.direction === "sendonly").length > 0;
 				this.hasVideo.value = probe.video.filter((v) => v.direction === "sendonly").length > 0;
@@ -3262,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) {
@@ -3294,7 +3497,6 @@ var StreamConnection = class {
 		if (this.abortController.signal.aborted) return;
 		const video = this.videoElement.value;
 		if (!video) return;
-		this.stopConnectTimeout();
 		this.activeMode.value = this.requestedMode.value === "auto" ? "webrtc" : this.requestedMode.value;
 		this.lastMediaStream = stream;
 		video.srcObject = stream;
@@ -3393,7 +3595,10 @@ var StreamConnection = class {
 		this.startWebRTC("webrtc");
 	}
 	handleFirstFrame() {
-		if (!this.isPlaying.value && !this.abortController.signal.aborted) this.isPlaying.value = true;
+		if (!this.isPlaying.value && !this.abortController.signal.aborted) {
+			this.stopConnectTimeout();
+			this.isPlaying.value = true;
+		}
 	}
 	monitorMseBuffer() {
 		const video = this.videoElement.value;
@@ -3800,11 +4005,13 @@ function useCameraStream(options) {
 	const isPlaying = computed(() => currentStream.value?.isPlaying.value ?? false);
 	const activeMode = computed(() => currentStream.value?.activeMode.value ?? "webrtc");
 	const activeResolution = computed(() => currentStream.value?.activeResolution.value ?? "low-resolution");
+	const degradedFrom = computed(() => currentStream.value?.degradedFrom.value ?? null);
+	const unsupported = computed(() => status.value === "unsupported");
 	const hasAudio = computed(() => currentStream.value?.hasAudio.value ?? false);
 	const hasBackchannel = computed(() => currentStream.value?.hasBackchannel.value ?? false);
 	const error = computed(() => currentStream.value?.error.value);
 	const isReconnecting = computed(() => status.value === "reconnecting");
-	const isBusy = computed(() => cameraDeviceLoading.value || !isPlaying.value && status.value !== "error");
+	const isBusy = computed(() => cameraDeviceLoading.value || !isPlaying.value && status.value !== "error" && status.value !== "unsupported");
 	const hasSound = computed(() => hasAudio.value && status.value === "connected");
 	const hasIntercom = computed(() => Boolean(typeof navigator !== "undefined" && navigator.mediaDevices) && hasBackchannel.value);
 	const muted = computed(() => currentStream.value?.muted.value ?? true);
@@ -4196,6 +4403,8 @@ function useCameraStream(options) {
 		isPlaying,
 		activeMode,
 		activeResolution,
+		degradedFrom,
+		unsupported,
 		hasAudio,
 		hasBackchannel,
 		error,
@@ -4441,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.146",
+  "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.31",
+    "@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.31",
+    "@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.1",
-    "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"