@camera.ui/browser 0.0.111 → 0.0.113

package/dist/index.js

@@ -0,0 +1,4179 @@
+import { computed, inject, markRaw, onBeforeUnmount, reactive, readonly, ref, shallowRef, toValue, watch } from "vue";
+import { tryOnScopeDispose, useTimeoutFn, whenever } from "@vueuse/core";
+import { SensorType } from "@camera.ui/sdk";
+export * from "@camera.ui/sdk";
+export * from "@camera.ui/sdk/internal";
+//#region src/utils/createDebouncedCache.ts
+function createDebouncedCache(options = {}) {
+	const { releaseDelay = 1e3, onRelease } = options;
+	const cache = /* @__PURE__ */ new Map();
+	const releaseTimers = /* @__PURE__ */ new Map();
+	function cancelTimer(key) {
+		const timer = releaseTimers.get(key);
+		if (timer) {
+			clearTimeout(timer);
+			releaseTimers.delete(key);
+		}
+	}
+	function doRelease(key) {
+		const entry = cache.get(key);
+		if (entry) {
+			try {
+				onRelease?.(key, entry.value);
+			} catch {}
+			cache.delete(key);
+		}
+		releaseTimers.delete(key);
+	}
+	function acquire(key, create) {
+		cancelTimer(key);
+		const cached = cache.get(key);
+		if (cached) {
+			cached.refCount++;
+			return cached.value;
+		}
+		const value = create();
+		cache.set(key, {
+			value,
+			refCount: 1
+		});
+		return value;
+	}
+	function release(key) {
+		const cached = cache.get(key);
+		if (!cached) return;
+		cached.refCount--;
+		if (cached.refCount <= 0) {
+			const timer = setTimeout(() => {
+				const stillCached = cache.get(key);
+				if (stillCached && stillCached.refCount <= 0) doRelease(key);
+				else releaseTimers.delete(key);
+			}, releaseDelay);
+			releaseTimers.set(key, timer);
+		}
+	}
+	function get(key) {
+		return cache.get(key)?.value;
+	}
+	function has(key) {
+		return cache.has(key);
+	}
+	function forceRelease(key) {
+		cancelTimer(key);
+		doRelease(key);
+	}
+	function clear() {
+		for (const key of releaseTimers.keys()) cancelTimer(key);
+		for (const key of cache.keys()) doRelease(key);
+	}
+	function getRefCount(key) {
+		return cache.get(key)?.refCount ?? 0;
+	}
+	function forEachValue(cb) {
+		for (const [key, entry] of cache) cb(entry.value, key);
+	}
+	return {
+		acquire,
+		release,
+		get,
+		has,
+		forceRelease,
+		clear,
+		getRefCount,
+		forEachValue
+	};
+}
+//#endregion
+//#region src/composables/useCameraUi.ts
+function useCameraUi() {
+	const context = inject(CAMERA_UI_INJECTION_KEY);
+	if (!context) throw new Error("[camera.ui] useCameraUi() called without CameraUiPlugin installed. Make sure to call app.use(createCameraUiPlugin({ ... })) before using this composable.");
+	return context;
+}
+//#endregion
+//#region ../../externals/camera.ui/server/src/utils/camera.ts
+function createSourceName(cameraName, sourceName) {
+	return `cui_${cameraName.replace(/ /g, "_").toLowerCase()}_${sourceName.replace(/ /g, "_").toLowerCase()}`;
+}
+//#endregion
+//#region ../../externals/camera.ui/server/src/rpc/namespaces.ts
+var NamespaceManager = class {
+	static coreManagerNamespaces() {
+		return {
+			coreManagerSubject: "coreManager.subscriber",
+			coreManagerRpc: "coreManager.rpc"
+		};
+	}
+	static deviceManagerNamespaces() {
+		return {
+			deviceManagerSubject: "deviceManager.subscriber",
+			deviceManagerRpc: "deviceManager.rpc"
+		};
+	}
+	static discoveryManagerNamespaces() {
+		return {
+			discoveryManagerSubject: "discoveryManager.subscriber",
+			discoveryManagerRpc: "discoveryManager.rpc"
+		};
+	}
+	static pluginNamespaces(pluginId) {
+		return {
+			pluginDeviceManagerSubject: `plugin.${pluginId}.deviceManager.subscriber`,
+			pluginChildRpc: `plugin.${pluginId}.child.rpc`,
+			pluginChild: `plugin.${pluginId}.child`,
+			pluginStorageRpc: `plugin.${pluginId}.storage.rpc`
+		};
+	}
+	static cameraNamespaces(cameraId) {
+		return {
+			cameraSubject: `camera.${cameraId}.subscriber`,
+			cameraControllerRpc: `camera.${cameraId}.controller.rpc`
+		};
+	}
+	static frameWorkerNamespaces(cameraId) {
+		return {
+			frameWorkerChildRpc: `camera.${cameraId}.frameWorker.child.rpc`,
+			frameWorkerChild: `camera.${cameraId}.frameWorker.child`
+		};
+	}
+	static pluginCameraNamespaces(pluginId, cameraId) {
+		return {
+			cameraInterfacesRpc: `plugin.${pluginId}.camera.${cameraId}.cameraInterfaces.rpc`,
+			cameraStorageRpc: `plugin.${pluginId}.camera.${cameraId}.cameraStorage.rpc`,
+			cameraImplRpc: `plugin.${pluginId}.camera.${cameraId}.impl.rpc`
+		};
+	}
+	static pluginSensorNamespaces(pluginId, cameraId, sensorId) {
+		return { sensorStorageRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.storage.rpc` };
+	}
+	static sensorControllerNamespaces(cameraId) {
+		return {
+			sensorSubject: `camera.${cameraId}.sensors.subject`,
+			sensorRpc: `camera.${cameraId}.sensors.rpc`,
+			sensorWriteSubject: `camera.${cameraId}.sensors.writes`
+		};
+	}
+	static sensorEventNamespaces(cameraId, sensorId) {
+		return { sensorSubject: `camera.${cameraId}.sensor.${sensorId}.subject` };
+	}
+	static sensorProviderNamespaces(pluginId, cameraId, sensorId) {
+		return { sensorRpc: `plugin.${pluginId}.camera.${cameraId}.sensor.${sensorId}.rpc` };
+	}
+	static frameWorkerDetectionNamespaces(cameraId) {
+		return { detectionRpc: `camera.${cameraId}.frameWorker.detection.rpc` };
+	}
+	static detectionEventNamespaces(cameraId) {
+		return { detectionEventSubject: `camera.${cameraId}.events.subject` };
+	}
+	static sensorControllerRpc(cameraId) {
+		return `camera.${cameraId}.sensors.controller.rpc`;
+	}
+	static terminalManagerNamespaces() {
+		return {
+			terminalManagerSubject: "terminalManager.subscriber",
+			terminalManagerRpc: "terminalManager.rpc"
+		};
+	}
+	static downloadManagerNamespaces() {
+		return { downloadManagerRpc: "downloadManager.rpc" };
+	}
+	static notificationManagerNamespaces() {
+		return { notificationsPublishSubject: "notifications.publish" };
+	}
+	static workerAgentRpc(agentId) {
+		return `worker.${agentId}.rpc`;
+	}
+	static workerHeartbeat() {
+		return "workers.heartbeat";
+	}
+	static workerDisconnect() {
+		return "workers.disconnect";
+	}
+};
+//#endregion
+//#region src/composables/useRpc.ts
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+async function rpcCall(rpcRef, fn, options = {}) {
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const awaitConnect = options.awaitConnect ?? true;
+	const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+	const retryDelayMs = options.retryDelayMs ?? defaultRetryDelayMs;
+	const shouldRetry = options.shouldRetry ?? defaultShouldRetry;
+	const signal = options.signal;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		if (signal?.aborted) throw makeAbortError();
+		let rpc = rpcRef.value;
+		if (!rpc) {
+			if (!awaitConnect) throw new Error("rpc: not connected");
+			rpc = await waitForRpc(rpcRef, connectTimeoutMs, signal);
+		}
+		try {
+			return await fn(rpc);
+		} catch (err) {
+			lastError = err;
+			if (attempt >= maxRetries) throw err;
+			if (!shouldRetry(err, attempt)) throw err;
+			await sleep(retryDelayMs(attempt), signal);
+		}
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("rpc: max retries exceeded");
+}
+function useRpcCall(fn, options = {}) {
+	const ctx = useCameraUi();
+	const data = shallowRef();
+	const loading = ref(false);
+	const error = ref();
+	let abortCtrl;
+	async function execute() {
+		abortCtrl?.abort();
+		abortCtrl = new AbortController();
+		const localCtrl = abortCtrl;
+		loading.value = true;
+		error.value = void 0;
+		try {
+			const result = await rpcCall(ctx.rpc, fn, {
+				...options,
+				signal: localCtrl.signal
+			});
+			if (localCtrl.signal.aborted) return void 0;
+			data.value = result;
+			return result;
+		} catch (err) {
+			if (localCtrl.signal.aborted) return void 0;
+			error.value = err instanceof Error ? err : new Error(String(err));
+			return;
+		} finally {
+			if (!localCtrl.signal.aborted) loading.value = false;
+		}
+	}
+	if (options.immediate) execute();
+	if (options.watch?.length) watch(options.watch, () => {
+		execute();
+	});
+	if (options.refetchOnReconnect !== false) {
+		const handleReconnected = () => {
+			execute();
+		};
+		ctx.on("reconnected", handleReconnected);
+		tryOnScopeDispose(() => ctx.off("reconnected", handleReconnected));
+	}
+	tryOnScopeDispose(() => abortCtrl?.abort());
+	return {
+		data,
+		loading,
+		error,
+		execute,
+		refresh: execute
+	};
+}
+function useRpcSubscription(subscribeFn, options = {}) {
+	const ctx = useCameraUi();
+	const isActive = ref(false);
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const retryDelayMs = options.retryDelayMs ?? defaultRetryDelayMs;
+	let unsubscribe;
+	let pending = false;
+	let disposed = false;
+	async function bind(rpc) {
+		if (pending || disposed) return;
+		pending = true;
+		try {
+			if (unsubscribe) {
+				try {
+					unsubscribe();
+				} catch {}
+				unsubscribe = void 0;
+			}
+			for (let attempt = 0; attempt <= maxRetries; attempt++) {
+				if (disposed) return;
+				try {
+					unsubscribe = await subscribeFn(rpc);
+					isActive.value = true;
+					return;
+				} catch (err) {
+					if (attempt >= maxRetries) {
+						isActive.value = false;
+						options.onError?.(err);
+						return;
+					}
+					await sleep(retryDelayMs(attempt));
+				}
+			}
+		} finally {
+			pending = false;
+		}
+	}
+	function unbind() {
+		if (unsubscribe) {
+			try {
+				unsubscribe();
+			} catch {}
+			unsubscribe = void 0;
+		}
+		isActive.value = false;
+	}
+	async function resubscribe() {
+		const rpc = ctx.rpc.value;
+		if (rpc) await bind(rpc);
+	}
+	if (ctx.rpc.value) bind(ctx.rpc.value);
+	const stopWatch = watch(ctx.rpc, (rpc, prevRpc) => {
+		if (rpc && rpc !== prevRpc) bind(rpc);
+		else if (!rpc && prevRpc) unbind();
+	});
+	tryOnScopeDispose(() => {
+		disposed = true;
+		stopWatch();
+		unbind();
+	});
+	return {
+		isActive,
+		resubscribe
+	};
+}
+function defaultRetryDelayMs(attempt) {
+	return Math.min(100 * Math.pow(2, attempt), 1e3);
+}
+function defaultShouldRetry(err) {
+	if (!(err instanceof Error)) return false;
+	const msg = err.message.toLowerCase();
+	if (msg.includes("not connected")) return true;
+	if (msg.includes("connection closed")) return true;
+	if (msg.includes("no responders")) return true;
+	if (msg.includes("connection refused")) return true;
+	if (msg.includes("socket")) return true;
+	if (msg.includes("timeout")) return true;
+	return false;
+}
+async function waitForRpc(rpcRef, timeoutMs, signal) {
+	if (rpcRef.value) return rpcRef.value;
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			stopWatch();
+			signal?.removeEventListener("abort", onAbort);
+			reject(/* @__PURE__ */ new Error("rpc: connect timeout"));
+		}, timeoutMs);
+		const onAbort = () => {
+			clearTimeout(timer);
+			stopWatch();
+			reject(makeAbortError());
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const stopWatch = watch(rpcRef, (next) => {
+			if (next) {
+				clearTimeout(timer);
+				stopWatch();
+				signal?.removeEventListener("abort", onAbort);
+				resolve(next);
+			}
+		});
+	});
+}
+async function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(makeAbortError());
+			return;
+		}
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(makeAbortError());
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function makeAbortError() {
+	if (typeof DOMException !== "undefined") return new DOMException("Aborted", "AbortError");
+	const err = /* @__PURE__ */ new Error("Aborted");
+	err.name = "AbortError";
+	return err;
+}
+//#endregion
+//#region src/composables/useSnapshot.ts
+var REVOKE_DELAY_MS = 5e3;
+var snapshotCache = /* @__PURE__ */ new Map();
+var urlCache = /* @__PURE__ */ new Map();
+var subscribers = /* @__PURE__ */ new Map();
+function notify(cameraId) {
+	subscribers.get(cameraId)?.forEach((cb) => cb());
+}
+function deferRevoke(url) {
+	setTimeout(() => URL.revokeObjectURL(url), REVOKE_DELAY_MS);
+}
+function setSnapshot(cameraId, data) {
+	const oldUrl = urlCache.get(cameraId);
+	if (oldUrl) {
+		deferRevoke(oldUrl);
+		urlCache.delete(cameraId);
+	}
+	snapshotCache.set(cameraId, data);
+	notify(cameraId);
+}
+function getSnapshot(cameraId) {
+	return snapshotCache.get(cameraId);
+}
+function getSnapshotUrl(cameraId) {
+	const buffer = snapshotCache.get(cameraId);
+	if (!buffer) return void 0;
+	let url = urlCache.get(cameraId);
+	if (!url) {
+		url = URL.createObjectURL(new Blob([buffer], { type: "image/jpeg" }));
+		urlCache.set(cameraId, url);
+	}
+	return url;
+}
+function clearSnapshotCache() {
+	for (const url of urlCache.values()) URL.revokeObjectURL(url);
+	urlCache.clear();
+	snapshotCache.clear();
+}
+function useSnapshot(cameraIdOrName) {
+	const { isConnected } = useCameraUi();
+	const deviceManager = useDeviceManager();
+	const snapshot = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const snapshotSrc = computed(() => {
+		if (!snapshot.value) return void 0;
+		const idOrName = toValue(cameraIdOrName);
+		return getSnapshotUrl(typeof idOrName === "string" ? idOrName : idOrName._id);
+	});
+	function subscribe(cameraId) {
+		if (!subscribers.has(cameraId)) subscribers.set(cameraId, /* @__PURE__ */ new Set());
+		const updateFn = () => {
+			snapshot.value = snapshotCache.get(cameraId);
+		};
+		subscribers.get(cameraId).add(updateFn);
+		return () => {
+			subscribers.get(cameraId)?.delete(updateFn);
+		};
+	}
+	let unsubscribe;
+	async function loadSnapshot(id) {
+		if (!isConnected.value || !id) return;
+		const cached = snapshotCache.get(id);
+		if (cached) {
+			snapshot.value = cached;
+			initialLoadDone.value = true;
+			return;
+		}
+		_isLoading.value = true;
+		try {
+			const device = await deviceManager.getCamera(id);
+			if (device) {
+				const result = await device.fetchSnapshot();
+				if (result) {
+					setSnapshot(id, result);
+					snapshot.value = result;
+				}
+			}
+		} catch {} finally {
+			_isLoading.value = false;
+			initialLoadDone.value = true;
+		}
+	}
+	function isCameraDisabled(camOrId) {
+		return typeof camOrId === "object" && camOrId?.disabled === true;
+	}
+	async function refresh() {
+		const cameraIdName = toValue(cameraIdOrName);
+		const id = typeof cameraIdName === "string" ? cameraIdName : cameraIdName._id;
+		if (!id || !isConnected.value) return;
+		if (isCameraDisabled(cameraIdName)) return;
+		_isLoading.value = true;
+		try {
+			const device = await deviceManager.getCamera(id);
+			if (device) {
+				const result = await device.fetchSnapshot(void 0, true);
+				if (result) {
+					setSnapshot(id, result);
+					snapshot.value = result;
+				}
+			}
+		} catch {} finally {
+			_isLoading.value = false;
+			initialLoadDone.value = true;
+		}
+	}
+	watch([
+		isConnected,
+		() => toValue(cameraIdOrName),
+		() => isCameraDisabled(toValue(cameraIdOrName))
+	], async ([connected, cameraIdName, disabled]) => {
+		unsubscribe?.();
+		unsubscribe = void 0;
+		const id = typeof cameraIdName === "string" ? cameraIdName : cameraIdName._id;
+		if (connected && id && !disabled) {
+			unsubscribe = subscribe(id);
+			await loadSnapshot(id);
+		} else if (id) {
+			snapshot.value = snapshotCache.get(id);
+			initialLoadDone.value = true;
+		} else snapshot.value = void 0;
+	}, { immediate: true });
+	tryOnScopeDispose(() => {
+		unsubscribe?.();
+	});
+	return {
+		snapshot,
+		snapshotSrc,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		refresh
+	};
+}
+//#endregion
+//#region src/composables/useCamera.ts
+async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
+	const cameraNamespaces = NamespaceManager.cameraNamespaces(initialCamera._id);
+	const sensorNamespaces = NamespaceManager.sensorControllerNamespaces(initialCamera._id);
+	const ctx = "rpc" in rpcOrContext && "value" in rpcOrContext.rpc ? rpcOrContext : void 0;
+	const rpcRef = ctx ? ctx.rpc : shallowRef(rpcOrContext);
+	let closeSubscription;
+	let closeSensorSubscription;
+	const camera = shallowRef(initialCamera);
+	const connected = ref(false);
+	const frameWorkerConnected = ref(false);
+	const snapshot = computed(() => getSnapshot(initialCamera._id));
+	const snapshotLoading = ref(false);
+	const sensorStates = ref({});
+	const name = computed(() => camera.value.name);
+	const room = computed(() => camera.value.room);
+	const nativeId = computed(() => camera.value.nativeId);
+	const disabled = computed(() => camera.value.disabled);
+	const snooze = computed(() => camera.value.detectionSettings?.snooze ?? false);
+	const isCloud = computed(() => camera.value.isCloud);
+	const sources = computed(() => {
+		return JSON.parse(JSON.stringify(camera.value.sources)).map((source) => ({
+			...source,
+			snapshot: async (forceNew) => fetchSnapshot(source._id, forceNew),
+			probeStream: async (probeConfig, refresh = false) => probeStream(source._id, probeConfig, refresh)
+		}));
+	});
+	const highResolutionSource = computed(() => sources.value.find((s) => s.role === "high-resolution"));
+	const midResolutionSource = computed(() => sources.value.find((s) => s.role === "mid-resolution"));
+	const lowResolutionSource = computed(() => sources.value.find((s) => s.role === "low-resolution"));
+	const streamSource = computed(() => highResolutionSource.value ?? midResolutionSource.value ?? lowResolutionSource.value);
+	const snapshotSource = computed(() => sources.value.find((s) => s.role === "snapshot") ?? sources.value.find((s) => s.useForSnapshot));
+	const existingSensorTypes = computed(() => {
+		const types = /* @__PURE__ */ new Set();
+		for (const state of Object.values(sensorStates.value)) types.add(state.type);
+		return types;
+	});
+	const capabilities = computed(() => Array.from(existingSensorTypes.value));
+	const hasLight = computed(() => existingSensorTypes.value.has(SensorType.Light));
+	const hasSiren = computed(() => existingSensorTypes.value.has(SensorType.Siren));
+	const hasDoorbell = computed(() => existingSensorTypes.value.has(SensorType.Doorbell));
+	const hasBattery = computed(() => existingSensorTypes.value.has(SensorType.Battery));
+	const hasAudioSensor = computed(() => existingSensorTypes.value.has(SensorType.Audio));
+	const hasMotionSensor = computed(() => existingSensorTypes.value.has(SensorType.Motion));
+	const hasObjectSensor = computed(() => existingSensorTypes.value.has(SensorType.Object));
+	const hasPtz = computed(() => existingSensorTypes.value.has(SensorType.PTZ));
+	async function fetchSnapshot(sourceId, forceNew) {
+		snapshotLoading.value = true;
+		try {
+			const result = await rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).snapshot(sourceId, forceNew));
+			if (result && result.byteLength > 0) {
+				setSnapshot(initialCamera._id, result);
+				return result;
+			}
+		} finally {
+			snapshotLoading.value = false;
+		}
+	}
+	async function probeStream(sourceId, probeConfig, refresh = false) {
+		return rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).probeStream(sourceId, probeConfig, refresh));
+	}
+	async function streamUrl(sourceId) {
+		return rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).streamUrl(sourceId));
+	}
+	async function refreshStates() {
+		const response = await rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).refreshStates());
+		camera.value = response.camera;
+		connected.value = response.cameraState;
+		frameWorkerConnected.value = response.frameWorkerState;
+		sensorStates.value = response.sensorStates;
+	}
+	async function handleCameraEvent(event) {
+		switch (event.type) {
+			case "removed":
+				await close();
+				break;
+			case "updated":
+				camera.value = event.data;
+				break;
+			case "cameraState":
+				connected.value = event.data;
+				break;
+			case "frameWorkerState":
+				frameWorkerConnected.value = event.data;
+				break;
+			case "snapshot:updated":
+				setSnapshot(initialCamera._id, event.data.snapshot);
+				break;
+		}
+	}
+	function handleSensorEvent(event) {
+		if (event.type === "sensor:added") {
+			const addedEvent = event.data;
+			sensorStates.value = {
+				...sensorStates.value,
+				[addedEvent.sensor.id]: addedEvent.state
+			};
+		} else if (event.type === "sensor:removed") {
+			const removedEvent = event.data;
+			const newStates = { ...sensorStates.value };
+			delete newStates[removedEvent.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));
+		await refreshStates();
+	}
+	async function close() {
+		closeSubscription?.();
+		closeSubscription = void 0;
+		closeSensorSubscription?.();
+		closeSensorSubscription = void 0;
+	}
+	async function fetchSnapshotFn(sourceId, forceNew) {
+		const useForSnapshotSource = sources.value.find((s) => s.useForSnapshot);
+		const dedicatedSnapshotSource = sources.value.find((s) => s.role === "snapshot");
+		const id = sourceId ?? dedicatedSnapshotSource?._id ?? useForSnapshotSource?._id ?? lowResolutionSource.value?._id ?? midResolutionSource.value?._id ?? highResolutionSource.value?._id ?? streamSource.value?._id;
+		if (!id) return Promise.resolve(void 0);
+		return fetchSnapshot(id, forceNew);
+	}
+	async function probeStreamFn(sourceId, probeConfig, refresh = false) {
+		const id = sourceId ?? streamSource.value?._id;
+		if (!id) return Promise.resolve(void 0);
+		return probeStream(id, probeConfig, refresh);
+	}
+	await init();
+	return {
+		id: initialCamera._id,
+		name,
+		room,
+		nativeId,
+		disabled,
+		snooze,
+		isCloud,
+		connected,
+		frameWorkerConnected,
+		sources,
+		streamSource,
+		snapshotSource,
+		highResolutionSource,
+		midResolutionSource,
+		lowResolutionSource,
+		capabilities,
+		hasLight,
+		hasSiren,
+		hasDoorbell,
+		hasBattery,
+		hasAudioSensor,
+		hasMotionSensor,
+		hasObjectSensor,
+		hasPtz,
+		camera,
+		snapshot,
+		snapshotLoading,
+		fetchSnapshot: fetchSnapshotFn,
+		probeStream: probeStreamFn,
+		streamUrl,
+		refreshStates,
+		reconnect: init,
+		close
+	};
+}
+//#endregion
+//#region src/composables/useDeviceManager.ts
+function useDeviceManager() {
+	const ctx = useCameraUi();
+	const namespaces = NamespaceManager.deviceManagerNamespaces();
+	async function getCamera(cameraIdOrName) {
+		const camera = await rpcCall(ctx.rpc, (rpc) => rpc.createProxy(namespaces.deviceManagerRpc).getCamera(cameraIdOrName, "@camera.ui/browser"));
+		if (camera) return createReactiveCameraDevice(ctx, camera);
+	}
+	return { getCamera };
+}
+//#endregion
+//#region src/composables/useCameraById.ts
+var cameraCache = createDebouncedCache({
+	releaseDelay: 1e3,
+	onRelease: (_key, device) => device.close()
+});
+var pendingLoads$1 = /* @__PURE__ */ new Map();
+function clearCameraCache() {
+	cameraCache.clear();
+	pendingLoads$1.clear();
+}
+function reconnectAllCameraDevices() {
+	cameraCache.forEachValue((device) => {
+		device.reconnect().catch(() => {});
+	});
+}
+function useCameraById(cameraIdOrName) {
+	const { isConnected } = useCameraUi();
+	const deviceManager = useDeviceManager();
+	const camera = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	let currentCameraId;
+	async function loadCamera(id) {
+		if (!isConnected.value || !id) return;
+		if (currentCameraId && currentCameraId !== id) {
+			cameraCache.release(currentCameraId);
+			camera.value = void 0;
+			currentCameraId = void 0;
+		}
+		if (cameraCache.has(id)) {
+			const cached = cameraCache.acquire(id, () => {
+				throw new Error("Should not create - already cached");
+			});
+			currentCameraId = id;
+			camera.value = cached;
+			initialLoadDone.value = true;
+			return;
+		}
+		const pending = pendingLoads$1.get(id);
+		if (pending) {
+			_isLoading.value = true;
+			try {
+				const device = await pending;
+				if (device && cameraCache.has(id)) {
+					const cached = cameraCache.acquire(id, () => device);
+					currentCameraId = id;
+					camera.value = cached;
+				}
+			} catch (err) {
+				error.value = err instanceof Error ? err : new Error(String(err));
+			} finally {
+				_isLoading.value = false;
+				initialLoadDone.value = true;
+			}
+			return;
+		}
+		_isLoading.value = true;
+		error.value = void 0;
+		const loadPromise = deviceManager.getCamera(id);
+		pendingLoads$1.set(id, loadPromise);
+		try {
+			const device = await loadPromise;
+			if (device) {
+				cameraCache.acquire(id, () => device);
+				currentCameraId = id;
+				camera.value = device;
+			}
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+		} finally {
+			pendingLoads$1.delete(id);
+			_isLoading.value = false;
+			initialLoadDone.value = true;
+		}
+	}
+	async function refresh() {
+		const id = toValue(cameraIdOrName);
+		if (!id) return;
+		if (currentCameraId) {
+			if (cameraCache.getRefCount(currentCameraId) <= 1) cameraCache.forceRelease(currentCameraId);
+			else cameraCache.release(currentCameraId);
+			camera.value = void 0;
+			currentCameraId = void 0;
+		}
+		await loadCamera(id);
+	}
+	watch([isConnected, () => toValue(cameraIdOrName)], async ([connected, id]) => {
+		if (connected && id) await loadCamera(id);
+		else if (!connected && currentCameraId) {
+			cameraCache.release(currentCameraId);
+			camera.value = void 0;
+			currentCameraId = void 0;
+		}
+	}, { immediate: true });
+	tryOnScopeDispose(() => {
+		if (currentCameraId) {
+			cameraCache.release(currentCameraId);
+			camera.value = void 0;
+			currentCameraId = void 0;
+		}
+	});
+	return {
+		camera,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error,
+		refresh
+	};
+}
+//#endregion
+//#region src/composables/usePlugin.ts
+var pluginCache = createDebouncedCache({ releaseDelay: 1e3 });
+var pendingLoads = /* @__PURE__ */ new Map();
+var instances = /* @__PURE__ */ new Set();
+function clearPluginCache() {
+	pluginCache.clear();
+	pendingLoads.clear();
+	for (const reset of instances) try {
+		reset();
+	} catch {}
+}
+function usePlugin(pluginName) {
+	const { rpc, isConnected } = useCameraUi();
+	const plugin = shallowRef();
+	const contract = ref();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	let currentPluginName;
+	function acquirePlugin(name) {
+		if (pluginCache.has(name)) return pluginCache.acquire(name, () => {
+			throw new Error("Should not create - already cached");
+		});
+	}
+	function releasePlugin(name) {
+		pluginCache.release(name);
+	}
+	async function loadPlugin(name) {
+		if (!isConnected.value || !name) return;
+		if (currentPluginName && currentPluginName !== name) {
+			releasePlugin(currentPluginName);
+			plugin.value = void 0;
+			contract.value = void 0;
+			currentPluginName = void 0;
+		}
+		const cached = acquirePlugin(name);
+		if (cached) {
+			currentPluginName = name;
+			plugin.value = cached.proxy;
+			contract.value = cached.contract;
+			initialLoadDone.value = true;
+			return;
+		}
+		const pending = pendingLoads.get(name);
+		if (pending) {
+			_isLoading.value = true;
+			try {
+				if (await pending) {
+					const cachedAfterPending = acquirePlugin(name);
+					if (cachedAfterPending) {
+						currentPluginName = name;
+						plugin.value = cachedAfterPending.proxy;
+						contract.value = cachedAfterPending.contract;
+					}
+				}
+			} catch (err) {
+				error.value = err instanceof Error ? err : new Error(String(err));
+			} finally {
+				_isLoading.value = false;
+				initialLoadDone.value = true;
+			}
+			return;
+		}
+		_isLoading.value = true;
+		error.value = void 0;
+		const loadPromise = rpcCall(rpc, async (client) => {
+			const coreNamespaces = NamespaceManager.coreManagerNamespaces();
+			const pluginInfo = await client.createProxy(coreNamespaces.coreManagerRpc).getPlugin(name);
+			if (!pluginInfo) throw new Error(`Plugin "${name}" not found`);
+			const pluginNamespaces = NamespaceManager.pluginNamespaces(pluginInfo.id);
+			return {
+				proxy: client.createProxy(pluginNamespaces.pluginChildRpc),
+				contract: pluginInfo.contract
+			};
+		});
+		pendingLoads.set(name, loadPromise);
+		try {
+			const result = await loadPromise;
+			if (result) {
+				pluginCache.acquire(name, () => result);
+				currentPluginName = name;
+				plugin.value = result.proxy;
+				contract.value = result.contract;
+			}
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			plugin.value = void 0;
+			contract.value = void 0;
+		} finally {
+			pendingLoads.delete(name);
+			_isLoading.value = false;
+			initialLoadDone.value = true;
+		}
+	}
+	async function refresh() {
+		const name = toValue(pluginName);
+		if (!name) return;
+		if (currentPluginName) {
+			if (pluginCache.getRefCount(currentPluginName) <= 1) pluginCache.forceRelease(currentPluginName);
+			else pluginCache.release(currentPluginName);
+			plugin.value = void 0;
+			contract.value = void 0;
+			currentPluginName = void 0;
+		}
+		await loadPlugin(name);
+	}
+	const resetInstance = () => {
+		if (!currentPluginName) return;
+		plugin.value = void 0;
+		contract.value = void 0;
+		currentPluginName = void 0;
+	};
+	instances.add(resetInstance);
+	watch([
+		isConnected,
+		() => toValue(pluginName),
+		rpc
+	], async ([connected, name, currentClient], oldValues) => {
+		const prevClient = oldValues?.[2];
+		if (currentPluginName && prevClient && prevClient !== currentClient) {
+			releasePlugin(currentPluginName);
+			plugin.value = void 0;
+			contract.value = void 0;
+			currentPluginName = void 0;
+		}
+		if (connected && name && currentClient) await loadPlugin(name);
+		else if ((!connected || !currentClient) && currentPluginName) {
+			releasePlugin(currentPluginName);
+			plugin.value = void 0;
+			contract.value = void 0;
+			currentPluginName = void 0;
+		}
+	}, { immediate: true });
+	tryOnScopeDispose(() => {
+		instances.delete(resetInstance);
+		if (currentPluginName) {
+			releasePlugin(currentPluginName);
+			plugin.value = void 0;
+			contract.value = void 0;
+			currentPluginName = void 0;
+		}
+	});
+	return {
+		plugin,
+		contract,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error,
+		refresh
+	};
+}
+//#endregion
+//#region src/composables/utils.ts
+function extractCameraId(camera) {
+	if (!camera) return void 0;
+	if (typeof camera === "string") return camera;
+	return camera.id;
+}
+//#endregion
+//#region src/composables/useSensor.ts
+function createSensorTypeGuard(sensorType) {
+	return (sensor) => sensor.type === sensorType;
+}
+var isReactiveLightControl = createSensorTypeGuard(SensorType.Light);
+var isReactiveSirenControl = createSensorTypeGuard(SensorType.Siren);
+var isReactiveBatteryInfo = createSensorTypeGuard(SensorType.Battery);
+var isReactiveDoorbellTrigger = createSensorTypeGuard(SensorType.Doorbell);
+var isReactiveContactSensor = createSensorTypeGuard(SensorType.Contact);
+var isReactiveMotionSensor = createSensorTypeGuard(SensorType.Motion);
+var isReactiveObjectSensor = createSensorTypeGuard(SensorType.Object);
+var isReactiveAudioSensor = createSensorTypeGuard(SensorType.Audio);
+var isReactiveFaceSensor = createSensorTypeGuard(SensorType.Face);
+var isReactiveLicensePlateSensor = createSensorTypeGuard(SensorType.LicensePlate);
+var isReactiveClassifierSensor = createSensorTypeGuard(SensorType.Classifier);
+var isReactivePTZControl = createSensorTypeGuard(SensorType.PTZ);
+var isReactiveSwitchControl = createSensorTypeGuard(SensorType.Switch);
+var isReactiveLockControl = createSensorTypeGuard(SensorType.Lock);
+var isReactiveSecuritySystem = createSensorTypeGuard(SensorType.SecuritySystem);
+var isReactiveTemperatureInfo = createSensorTypeGuard(SensorType.Temperature);
+var isReactiveHumidityInfo = createSensorTypeGuard(SensorType.Humidity);
+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) {
+	const displayName = ref(state.displayName ?? data.displayName ?? data.name);
+	const capabilities = ref(state.capabilities ?? data.capabilities ?? []);
+	const properties = reactive({ ...state.properties });
+	const capabilityCallbacks = [];
+	return {
+		id: data.id,
+		type: data.type,
+		name: data.name,
+		displayName,
+		pluginId: data.pluginId,
+		capabilities,
+		properties,
+		getProperty(property) {
+			return properties[property];
+		},
+		async setProperty(property, value) {
+			const sensorNamespace = `plugin.${data.pluginId}.camera.${cameraId}.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));
+		},
+		hasCapability(capability) {
+			return capabilities.value.includes(capability);
+		},
+		onCapabilitiesChanged(callback) {
+			capabilityCallbacks.push(callback);
+			return () => {
+				const index = capabilityCallbacks.indexOf(callback);
+				if (index !== -1) capabilityCallbacks.splice(index, 1);
+			};
+		},
+		_notifyCapabilitiesChanged() {
+			for (const callback of capabilityCallbacks) callback(capabilities.value);
+		}
+	};
+}
+function createSensorManager(rpcOrContext, cameraId, sensorSubjectNamespace, sensorRpcNamespace) {
+	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());
+	let globalUnsubscribe;
+	const sensorSubscriptions = /* @__PURE__ */ new Map();
+	const initialized = ref(false);
+	let initPromise;
+	function handlePerSensorEvent(sensorId, message) {
+		const sensor = sensorMap.value.get(sensorId);
+		if (!sensor) return;
+		if (message.type === "property:changed") {
+			const event = message.data;
+			sensor.properties[event.property] = event.value;
+		} else if (message.type === "sensor:displayName:changed") {
+			const event = message.data;
+			sensor.displayName.value = event.displayName;
+		} else if (message.type === "sensor:capabilities:changed") {
+			const event = message.data;
+			sensor.capabilities.value = event.capabilities;
+			sensor._notifyCapabilitiesChanged();
+		}
+	}
+	async function subscribeToSensorEvents(sensorId) {
+		if (sensorSubscriptions.has(sensorId)) return;
+		const namespace = NamespaceManager.sensorEventNamespaces(cameraId, sensorId);
+		const unsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(namespace.sensorSubject, (msg) => handlePerSensorEvent(sensorId, msg)));
+		sensorSubscriptions.set(sensorId, unsubscribe);
+	}
+	function unsubscribeFromSensorEvents(sensorId) {
+		const unsubscribe = sensorSubscriptions.get(sensorId);
+		if (unsubscribe) {
+			unsubscribe();
+			sensorSubscriptions.delete(sensorId);
+		}
+	}
+	function handleGlobalSensorEvent(message) {
+		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 newMap = new Map(sensorMap.value);
+			newMap.set(event.sensor.id, reactiveSensor);
+			sensorMap.value = newMap;
+			subscribeToSensorEvents(event.sensor.id);
+		} else if (message.type === "sensor:removed") {
+			const event = message.data;
+			unsubscribeFromSensorEvents(event.sensorId);
+			const newMap = new Map(sensorMap.value);
+			newMap.delete(event.sensorId);
+			sensorMap.value = newMap;
+		}
+	}
+	async function doInit() {
+		globalUnsubscribe?.();
+		globalUnsubscribe = void 0;
+		for (const unsubscribe of sensorSubscriptions.values()) unsubscribe();
+		sensorSubscriptions.clear();
+		sensorMap.value = /* @__PURE__ */ new Map();
+		let pendingEvents = [];
+		globalUnsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(sensorSubjectNamespace, (msg) => {
+			if (pendingEvents) pendingEvents.push(msg);
+			else handleGlobalSensorEvent(msg);
+		}));
+		const [sensors, states] = await rpcCall(rpcRef, async (c) => {
+			const proxy = c.createProxy(sensorRpcNamespace);
+			return Promise.all([proxy.getSensors(), proxy.getSensorStates()]);
+		});
+		const newMap = /* @__PURE__ */ new Map();
+		for (const sensor of sensors) {
+			const reactiveSensor = createReactiveSensor(sensor, states[sensor.id] ?? {
+				properties: {},
+				capabilities: [],
+				type: sensor.type
+			}, rpcRef, cameraId);
+			newMap.set(sensor.id, reactiveSensor);
+		}
+		sensorMap.value = newMap;
+		for (const sensorId of newMap.keys()) await subscribeToSensorEvents(sensorId);
+		const queued = pendingEvents;
+		pendingEvents = void 0;
+		for (const msg of queued) handleGlobalSensorEvent(msg);
+		initialized.value = true;
+	}
+	async function ensureInitialized() {
+		if (initialized.value) return;
+		if (!initPromise) initPromise = doInit().finally(() => {
+			initPromise = void 0;
+		});
+		return initPromise;
+	}
+	async function reconnect() {
+		initialized.value = false;
+		if (!initPromise) initPromise = doInit().finally(() => {
+			initPromise = void 0;
+		});
+		return initPromise;
+	}
+	function close() {
+		globalUnsubscribe?.();
+		globalUnsubscribe = void 0;
+		for (const unsubscribe of sensorSubscriptions.values()) unsubscribe();
+		sensorSubscriptions.clear();
+		sensorMap.value.clear();
+		initialized.value = false;
+		initPromise = void 0;
+	}
+	const sensors = computed(() => Array.from(sensorMap.value.values()));
+	return {
+		sensors,
+		isInitialized: computed(() => initialized.value),
+		getSensor(sensorId) {
+			return sensorMap.value.get(sensorId);
+		},
+		getSensorsByType(type) {
+			return sensors.value.filter((s) => s.type === type);
+		},
+		hasSensorType(type) {
+			return sensors.value.some((s) => s.type === type);
+		},
+		async setDisplayName(sensorId, displayName) {
+			await rpcCall(rpcRef, (c) => c.createProxy(sensorRpcNamespace).setDisplayName(sensorId, displayName));
+		},
+		ensureInitialized,
+		reconnect,
+		close
+	};
+}
+var sensorManagerCache = createDebouncedCache({
+	releaseDelay: 1e3,
+	onRelease: (_key, cached) => cached.manager.close()
+});
+function clearSensorCache() {
+	sensorManagerCache.clear();
+}
+function reconnectAllSensorManagers() {
+	sensorManagerCache.forEachValue((cached) => {
+		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) };
+	});
+}
+function releaseSensorManager(cameraId) {
+	sensorManagerCache.release(cameraId);
+}
+function createSensorComposableState() {
+	return {
+		currentCameraId: void 0,
+		cachedManager: void 0
+	};
+}
+async function ensureSensorManager(state, cameraUi, isConnected, cameraId, 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;
+		state.cachedManager = cached.manager;
+		if (!cached.initPromise) cached.initPromise = cached.manager.ensureInitialized();
+		await cached.initPromise;
+		return cached.manager;
+	} catch (err) {
+		error.value = err instanceof Error ? err : new Error(String(err));
+		return;
+	} finally {
+		isLoading.value = false;
+	}
+}
+function cleanupSensorComposable(state) {
+	if (state.currentCameraId) {
+		releaseSensorManager(state.currentCameraId);
+		state.currentCameraId = void 0;
+		state.cachedManager = void 0;
+	}
+}
+function useSensorById(camera, sensorId) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensor = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([
+		isConnected,
+		() => extractCameraId(toValue(camera)),
+		() => toValue(sensorId)
+	], async ([connected, camId, senId]) => {
+		if (connected && camId && senId) {
+			sensor.value = (await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error))?.getSensor(senId);
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensor.value = void 0;
+		}
+	}, { immediate: true });
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensor.value = void 0;
+	});
+	return {
+		sensor,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+function useSensorByType(camera, sensorType) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensor = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([
+		isConnected,
+		() => extractCameraId(toValue(camera)),
+		() => toValue(sensorType)
+	], async ([connected, camId, type]) => {
+		if (connected && camId) {
+			sensor.value = (await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error))?.getSensorsByType(type)[0];
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensor.value = void 0;
+		}
+	}, { immediate: true });
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensor.value = void 0;
+	});
+	return {
+		sensor,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+function useSensorsByType(camera, sensorType) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensorsRef = shallowRef([]);
+	const cachedManager = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([
+		isConnected,
+		() => extractCameraId(toValue(camera)),
+		() => toValue(sensorType)
+	], async ([connected, camId, type]) => {
+		if (connected && camId) {
+			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			cachedManager.value = manager;
+			sensorsRef.value = manager?.getSensorsByType(type) ?? [];
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensorsRef.value = [];
+			cachedManager.value = void 0;
+		}
+	}, { immediate: true });
+	const sensors = computed(() => {
+		if (!cachedManager.value) return [];
+		const type = toValue(sensorType);
+		return cachedManager.value.sensors.value.filter((s) => s.type === type);
+	});
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensorsRef.value = [];
+	});
+	return {
+		sensors,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+function useSensors(camera) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensorsRef = shallowRef([]);
+	const cachedManager = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
+		if (connected && camId) {
+			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			cachedManager.value = manager;
+			sensorsRef.value = manager?.sensors.value ?? [];
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensorsRef.value = [];
+			cachedManager.value = void 0;
+		}
+	}, { immediate: true });
+	const sensors = computed(() => cachedManager.value?.sensors.value ?? []);
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensorsRef.value = [];
+	});
+	return {
+		sensors,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+function useTypedSensor(camera, sensorType) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensor = shallowRef();
+	const cachedManager = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
+		if (connected && camId) {
+			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			cachedManager.value = manager;
+			sensor.value = manager?.getSensorsByType(sensorType)[0];
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensor.value = void 0;
+		}
+	}, { immediate: true });
+	watch(() => {
+		if (!cachedManager.value) return void 0;
+		return cachedManager.value.getSensorsByType(sensorType)[0]?.id;
+	}, () => {
+		if (cachedManager.value) sensor.value = cachedManager.value.getSensorsByType(sensorType)[0];
+	});
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensor.value = void 0;
+	});
+	return {
+		sensor,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+function useMotionSensor(camera) {
+	return useTypedSensor(camera, SensorType.Motion);
+}
+function useObjectSensor(camera) {
+	return useTypedSensor(camera, SensorType.Object);
+}
+function useFaceSensor(camera) {
+	return useTypedSensor(camera, SensorType.Face);
+}
+function useLicensePlateSensor(camera) {
+	return useTypedSensor(camera, SensorType.LicensePlate);
+}
+function useAudioSensor(camera) {
+	return useTypedSensor(camera, SensorType.Audio);
+}
+function usePTZControl(camera) {
+	return useTypedSensor(camera, SensorType.PTZ);
+}
+function useClassifierSensors(camera) {
+	const cameraUi = useCameraUi();
+	const { isConnected } = cameraUi;
+	const sensorsRef = shallowRef([]);
+	const cachedManager = shallowRef();
+	const _isLoading = ref(false);
+	const initialLoadDone = ref(false);
+	const error = ref();
+	const state = createSensorComposableState();
+	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
+		if (connected && camId) {
+			const manager = await ensureSensorManager(state, cameraUi, connected, camId, _isLoading, error);
+			cachedManager.value = manager;
+			sensorsRef.value = manager?.getSensorsByType(SensorType.Classifier) ?? [];
+			initialLoadDone.value = true;
+		} else {
+			cleanupSensorComposable(state);
+			sensorsRef.value = [];
+			cachedManager.value = void 0;
+		}
+	}, { immediate: true });
+	const sensors = computed(() => cachedManager.value?.getSensorsByType(SensorType.Classifier) ?? []);
+	tryOnScopeDispose(() => {
+		cleanupSensorComposable(state);
+		sensorsRef.value = [];
+	});
+	return {
+		sensors,
+		isLoading: computed(() => _isLoading.value || !initialLoadDone.value),
+		error
+	};
+}
+//#endregion
+//#region src/composables/resolvePluginId.ts
+var pluginIdCache = /* @__PURE__ */ new Map();
+function clearPluginIdCache() {
+	pluginIdCache.clear();
+}
+async function resolvePluginId(rpcRef, pluginName) {
+	const cached = pluginIdCache.get(pluginName);
+	if (cached) return cached;
+	const namespaces = NamespaceManager.coreManagerNamespaces();
+	const pluginInfo = await rpcCall(rpcRef, (rpc) => rpc.createProxy(namespaces.coreManagerRpc).getPlugin(pluginName));
+	if (pluginInfo) {
+		pluginIdCache.set(pluginName, pluginInfo.id);
+		return pluginInfo.id;
+	}
+}
+//#endregion
+//#region src/composables/useStorage.ts
+function createReactiveStorage(proxy) {
+	const config = shallowRef();
+	const isLoading = ref(false);
+	const error = ref();
+	async function getConfig() {
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			config.value = await proxy.getConfig();
+			return config.value;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			return;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function setValue(key, value) {
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			await proxy.setValue(key, value);
+			await getConfig();
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function setConfig(newConfig) {
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			await proxy.setConfig(newConfig);
+			await getConfig();
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function submitValue(key, value) {
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			const response = await proxy.submitValue(key, value);
+			if (!response?.toast || response.toast.type !== "error") await getConfig();
+			return response;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	return {
+		proxy,
+		config,
+		isLoading,
+		error,
+		getConfig,
+		setValue,
+		setConfig,
+		submitValue
+	};
+}
+var storageCache = createDebouncedCache({ releaseDelay: 1e3 });
+function getPluginStorageKey(pluginId) {
+	return `plugin:${pluginId}`;
+}
+function getCameraStorageKey(pluginId, cameraId) {
+	return `plugin:${pluginId}:camera:${cameraId}`;
+}
+function getSensorStorageKey(pluginId, cameraId, sensorId) {
+	return `plugin:${pluginId}:camera:${cameraId}:sensor:${sensorId}`;
+}
+function acquireStorage(key, createProxy) {
+	return storageCache.acquire(key, () => {
+		return createReactiveStorage(createProxy());
+	});
+}
+function releaseStorage(key) {
+	storageCache.release(key);
+}
+function clearStorageCache() {
+	storageCache.clear();
+	clearPluginIdCache();
+}
+function createStorageState() {
+	return {
+		currentStorageKey: void 0,
+		cachedStorage: void 0
+	};
+}
+function cleanupStorage(state, isConnected, config) {
+	if (state.currentStorageKey) {
+		releaseStorage(state.currentStorageKey);
+		state.currentStorageKey = void 0;
+	}
+	isConnected.value = false;
+	state.cachedStorage = void 0;
+	config.value = void 0;
+}
+function createStorageOperations(state, config, isLoading, error) {
+	async function getConfig() {
+		const cached = state.cachedStorage;
+		if (!cached) return void 0;
+		const result = await cached.getConfig();
+		if (state.cachedStorage !== cached) return result;
+		config.value = cached.config.value;
+		isLoading.value = cached.isLoading.value;
+		error.value = cached.error.value;
+		return result;
+	}
+	async function setValue(key, value) {
+		const cached = state.cachedStorage;
+		if (!cached) throw new Error("Storage not connected");
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			await cached.setValue(key, value);
+			if (state.cachedStorage === cached) config.value = cached.config.value;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function setConfig(newConfig) {
+		const cached = state.cachedStorage;
+		if (!cached) throw new Error("Storage not connected");
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			await cached.setConfig(newConfig);
+			if (state.cachedStorage === cached) config.value = cached.config.value;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	async function submitValue(key, value) {
+		const cached = state.cachedStorage;
+		if (!cached) throw new Error("Storage not connected");
+		isLoading.value = true;
+		error.value = void 0;
+		try {
+			const result = await cached.submitValue(key, value);
+			if (state.cachedStorage === cached) config.value = cached.config.value;
+			return result;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			throw err;
+		} finally {
+			isLoading.value = false;
+		}
+	}
+	return {
+		getConfig,
+		setValue,
+		setConfig,
+		submitValue
+	};
+}
+function usePluginStorage(pluginName) {
+	const { rpc, isConnected: clientConnected } = useCameraUi();
+	const config = shallowRef();
+	const _isLoading = ref(false);
+	const initialSetupDone = ref(false);
+	const error = ref();
+	const isConnected = ref(false);
+	const state = createStorageState();
+	const operations = createStorageOperations(state, config, _isLoading, error);
+	async function connect(name) {
+		if (!rpc.value || !clientConnected.value) return false;
+		try {
+			const pluginId = await resolvePluginId(rpc, name);
+			if (!pluginId) throw new Error(`Plugin "${name}" not found`);
+			const storageKey = getPluginStorageKey(pluginId);
+			if (state.currentStorageKey && state.currentStorageKey !== storageKey) releaseStorage(state.currentStorageKey);
+			state.currentStorageKey = storageKey;
+			state.cachedStorage = acquireStorage(storageKey, () => {
+				const namespaces = NamespaceManager.pluginNamespaces(pluginId);
+				return rpc.value.createProxy(namespaces.pluginStorageRpc);
+			});
+			isConnected.value = true;
+			return true;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			isConnected.value = false;
+			return false;
+		}
+	}
+	async function getConfig() {
+		if (!state.cachedStorage) {
+			const name = toValue(pluginName);
+			if (!name) return void 0;
+			if (!await connect(name)) return void 0;
+		}
+		return operations.getConfig();
+	}
+	watch([clientConnected, () => toValue(pluginName)], async ([connected, name]) => {
+		if (connected && name) {
+			await connect(name);
+			operations.getConfig();
+		} else cleanupStorage(state, isConnected, config);
+		initialSetupDone.value = true;
+	}, { immediate: true });
+	tryOnScopeDispose(() => cleanupStorage(state, isConnected, config));
+	return {
+		config,
+		isLoading: computed(() => _isLoading.value || !initialSetupDone.value),
+		error,
+		isConnected,
+		getConfig,
+		setValue: operations.setValue,
+		setConfig: operations.setConfig,
+		submitValue: operations.submitValue
+	};
+}
+function useCameraStorage(camera, pluginName) {
+	const { rpc, isConnected: clientConnected } = useCameraUi();
+	const config = shallowRef();
+	const _isLoading = ref(false);
+	const initialSetupDone = ref(false);
+	const error = ref();
+	const isConnected = ref(false);
+	const state = createStorageState();
+	const operations = createStorageOperations(state, config, _isLoading, error);
+	async function connect(cameraId, name) {
+		if (!rpc.value || !clientConnected.value) return false;
+		try {
+			const pluginId = await resolvePluginId(rpc, name);
+			if (!pluginId) throw new Error(`Plugin "${name}" not found`);
+			const storageKey = getCameraStorageKey(pluginId, cameraId);
+			if (state.currentStorageKey && state.currentStorageKey !== storageKey) releaseStorage(state.currentStorageKey);
+			state.currentStorageKey = storageKey;
+			state.cachedStorage = acquireStorage(storageKey, () => {
+				const namespaces = NamespaceManager.pluginCameraNamespaces(pluginId, cameraId);
+				return rpc.value.createProxy(namespaces.cameraStorageRpc);
+			});
+			isConnected.value = true;
+			return true;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			isConnected.value = false;
+			return false;
+		}
+	}
+	async function getConfig() {
+		const cameraId = extractCameraId(toValue(camera));
+		const name = toValue(pluginName);
+		if (!cameraId || !name) return void 0;
+		if (!state.cachedStorage) {
+			if (!await connect(cameraId, name)) return void 0;
+		}
+		return operations.getConfig();
+	}
+	watch([
+		clientConnected,
+		() => extractCameraId(toValue(camera)),
+		() => toValue(pluginName)
+	], async ([connected, cameraId, name]) => {
+		if (connected && cameraId && name) {
+			await connect(cameraId, name);
+			operations.getConfig();
+		} else cleanupStorage(state, isConnected, config);
+		initialSetupDone.value = true;
+	}, { immediate: true });
+	tryOnScopeDispose(() => cleanupStorage(state, isConnected, config));
+	return {
+		config,
+		isLoading: computed(() => _isLoading.value || !initialSetupDone.value),
+		error,
+		isConnected,
+		getConfig,
+		setValue: operations.setValue,
+		setConfig: operations.setConfig,
+		submitValue: operations.submitValue
+	};
+}
+function useSensorStorage(camera, sensorId, pluginId) {
+	const { rpc, isConnected: clientConnected } = useCameraUi();
+	const config = shallowRef();
+	const _isLoading = ref(false);
+	const initialSetupDone = ref(false);
+	const error = ref();
+	const isConnected = ref(false);
+	const state = createStorageState();
+	const operations = createStorageOperations(state, config, _isLoading, error);
+	function connect(cameraId, senId, plugId) {
+		if (!rpc.value || !clientConnected.value) return false;
+		try {
+			const storageKey = getSensorStorageKey(plugId, cameraId, senId);
+			if (state.currentStorageKey && state.currentStorageKey !== storageKey) releaseStorage(state.currentStorageKey);
+			state.currentStorageKey = storageKey;
+			state.cachedStorage = acquireStorage(storageKey, () => {
+				const namespaces = NamespaceManager.pluginSensorNamespaces(plugId, cameraId, senId);
+				return rpc.value.createProxy(namespaces.sensorStorageRpc);
+			});
+			isConnected.value = true;
+			return true;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			isConnected.value = false;
+			return false;
+		}
+	}
+	async function getConfig() {
+		const cameraId = extractCameraId(toValue(camera));
+		const senId = toValue(sensorId);
+		const plugId = toValue(pluginId);
+		if (!cameraId || !senId || !plugId) return void 0;
+		if (!state.cachedStorage) {
+			if (!connect(cameraId, 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);
+			operations.getConfig();
+		} else cleanupStorage(state, isConnected, config);
+		initialSetupDone.value = true;
+	}, { immediate: true });
+	tryOnScopeDispose(() => cleanupStorage(state, isConnected, config));
+	return {
+		config,
+		isLoading: computed(() => _isLoading.value || !initialSetupDone.value),
+		error,
+		isConnected,
+		getConfig,
+		setValue: operations.setValue,
+		setConfig: operations.setConfig,
+		submitValue: operations.submitValue
+	};
+}
+//#endregion
+//#region src/composables/resetClientState.ts
+function resetClientState() {
+	clearPluginCache();
+	clearCameraCache();
+	clearStorageCache();
+	clearSensorCache();
+	clearSnapshotCache();
+}
+function refreshClientSubscriptions() {
+	clearPluginCache();
+	reconnectAllCameraDevices();
+	reconnectAllSensorManagers();
+}
+//#endregion
+//#region src/plugin.ts
+var CAMERA_UI_INJECTION_KEY = Symbol("camera-ui");
+function isContext(input) {
+	return "rpc" in input && "isConnected" in input;
+}
+function makeContextFromTransport(input) {
+	const { natsTransport, target, wsTransport } = input;
+	let hasBeenConnected = false;
+	const rpc = shallowRef(natsTransport.getClient() ?? void 0);
+	const isConnected = ref(natsTransport.getClient()?.isConnected ?? false);
+	const error = ref(void 0);
+	const endpoint = computed(() => target.value?.endpoint.url);
+	const token = computed(() => target.value?.tokens.access);
+	const extraProxyQuery = computed(() => {
+		const t = target.value;
+		if (!t?.tokens.proxySession) return void 0;
+		return { session: t.tokens.proxySession };
+	});
+	const listeners = /* @__PURE__ */ new Map();
+	function on(event, cb) {
+		let set = listeners.get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			listeners.set(event, set);
+		}
+		set.add(cb);
+	}
+	function off(event, cb) {
+		listeners.get(event)?.delete(cb);
+	}
+	function emit(event) {
+		const set = listeners.get(event);
+		if (!set) return;
+		for (const cb of set) try {
+			cb();
+		} catch (err) {
+			console.warn("[camera.ui] context listener threw:", err);
+		}
+	}
+	natsTransport.subscribeClient((next) => {
+		const wasConnected = isConnected.value;
+		if (next) {
+			rpc.value = next;
+			isConnected.value = true;
+			error.value = void 0;
+			if (!wasConnected) {
+				refreshClientSubscriptions();
+				if (hasBeenConnected) emit("reconnected");
+				hasBeenConnected = true;
+			}
+		} else {
+			rpc.value = void 0;
+			isConnected.value = false;
+			if (wasConnected) emit("disconnected");
+		}
+	});
+	natsTransport.on("auth-error", (payload) => {
+		error.value = new Error(payload.message ?? "auth-error");
+	});
+	natsTransport.on("down", (payload) => {
+		if (!error.value) error.value = new Error(payload.reason);
+	});
+	natsTransport.on("up", () => {
+		error.value = void 0;
+	});
+	return markRaw({
+		rpc,
+		target: readonly(target),
+		isConnected: readonly(isConnected),
+		endpoint,
+		token,
+		extraProxyQuery,
+		error: readonly(error),
+		wsTransport,
+		on,
+		off
+	});
+}
+function createCameraUiPlugin(input) {
+	return { install(app) {
+		const ctx = isContext(input) ? input : makeContextFromTransport(input);
+		app.provide(CAMERA_UI_INJECTION_KEY, ctx);
+	} };
+}
+//#endregion
+//#region src/streaming/activityMode.ts
+var DEFAULT_CONFIG = {
+	standbyTimeout: 5e3,
+	activityTimeout: 5e3
+};
+function createActivityMode(options) {
+	const { initialMode = "always-on", config = {}, onStreamStart, onStreamStop, isStreamPlaying } = options;
+	const resolvedConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	const mode = ref(initialMode);
+	const inStandby = ref(false);
+	const hasActivity = ref(false);
+	let activityTimeout;
+	let idleTimeout;
+	function clearActivityTimeout() {
+		if (activityTimeout) {
+			clearTimeout(activityTimeout);
+			activityTimeout = void 0;
+		}
+	}
+	function clearIdleTimeout() {
+		if (idleTimeout) {
+			clearTimeout(idleTimeout);
+			idleTimeout = void 0;
+		}
+	}
+	function clearAllTimers() {
+		clearActivityTimeout();
+		clearIdleTimeout();
+	}
+	function goToStandby() {
+		if (!inStandby.value) {
+			inStandby.value = true;
+			onStreamStop();
+		}
+	}
+	function exitStandby() {
+		if (inStandby.value) {
+			inStandby.value = false;
+			onStreamStart();
+		}
+	}
+	function manageStreamState() {
+		clearAllTimers();
+		switch (mode.value) {
+			case "always-on":
+				inStandby.value = false;
+				if (!isStreamPlaying()) onStreamStart();
+				break;
+			case "standby":
+				if (!inStandby.value) {
+					if (!isStreamPlaying()) onStreamStart();
+					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;
+		}
+	}
+	function startIdleTimer() {
+		clearIdleTimeout();
+		idleTimeout = setTimeout(() => {
+			if (mode.value === "standby") goToStandby();
+		}, resolvedConfig.standbyTimeout);
+	}
+	function setMode(newMode) {
+		if (mode.value !== newMode) {
+			mode.value = newMode;
+			manageStreamState();
+		}
+	}
+	function reportActivity(detected) {
+		if (mode.value !== "activity") return;
+		if (detected) {
+			hasActivity.value = true;
+			clearActivityTimeout();
+			if (inStandby.value || !isStreamPlaying()) exitStandby();
+		} else {
+			hasActivity.value = false;
+			clearActivityTimeout();
+			activityTimeout = setTimeout(() => {
+				if (!hasActivity.value) goToStandby();
+			}, resolvedConfig.activityTimeout);
+		}
+	}
+	function resumeFromStandby() {
+		if (!inStandby.value) return;
+		exitStandby();
+		switch (mode.value) {
+			case "standby":
+				startIdleTimer();
+				break;
+			case "activity":
+				clearActivityTimeout();
+				if (!hasActivity.value) activityTimeout = setTimeout(() => {
+					goToStandby();
+				}, resolvedConfig.activityTimeout);
+				break;
+		}
+	}
+	function resetIdleTimer() {
+		if (mode.value === "standby" && !inStandby.value) startIdleTimer();
+	}
+	function dispose() {
+		clearAllTimers();
+	}
+	return {
+		mode,
+		inStandby,
+		hasActivity,
+		setMode,
+		reportActivity,
+		resumeFromStandby,
+		resetIdleTimer,
+		dispose
+	};
+}
+//#endregion
+//#region src/composables/useTabVisibility.ts
+var DEFAULT_TAB_PAUSE_MS = 3e4;
+function log$1(...args) {
+	const d = /* @__PURE__ */ new Date();
+	const hh = String(d.getHours()).padStart(2, "0");
+	const mm = String(d.getMinutes()).padStart(2, "0");
+	const ss = String(d.getSeconds()).padStart(2, "0");
+	const ms = String(d.getMilliseconds()).padStart(3, "0");
+	console.log(`[TabVisibility ${hh}:${mm}:${ss}.${ms}]`, ...args);
+}
+var _isVisible = ref(typeof document === "undefined" ? true : document.visibilityState === "visible");
+var _hiddenAt = null;
+var _hiddenListeners = /* @__PURE__ */ new Set();
+var _pausedListeners = /* @__PURE__ */ new Set();
+var _visibleListeners = /* @__PURE__ */ new Set();
+var _initialized = false;
+function _firePausedEntry(entry) {
+	log$1(`paused listener fired (delay ${entry.delayMs}ms reached)`);
+	try {
+		entry.cb();
+	} catch (err) {
+		console.error("[TabVisibility] onTabPaused listener threw:", err);
+	}
+}
+function _schedulePausedEntry(entry) {
+	log$1(`paused listener scheduled in ${entry.delayMs}ms`);
+	entry.timer = setTimeout(() => {
+		entry.timer = null;
+		if (_isVisible.value) {
+			log$1("paused listener skipped — tab visible before delay");
+			return;
+		}
+		_firePausedEntry(entry);
+	}, entry.delayMs);
+}
+function _cancelPausedEntries() {
+	for (const entry of _pausedListeners) if (entry.timer !== null) {
+		clearTimeout(entry.timer);
+		entry.timer = null;
+	}
+}
+function _init() {
+	if (_initialized || typeof document === "undefined") return;
+	_initialized = true;
+	document.addEventListener("visibilitychange", () => {
+		const visible = document.visibilityState === "visible";
+		if (!visible && _isVisible.value) {
+			_isVisible.value = false;
+			_hiddenAt = Date.now();
+			log$1(`tab → hidden (hidden=${_hiddenListeners.size} paused=${_pausedListeners.size})`);
+			for (const entry of _hiddenListeners) try {
+				entry.cb();
+			} catch (err) {
+				console.error("[TabVisibility] onTabHidden listener threw:", err);
+			}
+			for (const entry of _pausedListeners) _schedulePausedEntry(entry);
+		} else if (visible && !_isVisible.value) {
+			_cancelPausedEntries();
+			const hiddenMs = _hiddenAt != null ? Date.now() - _hiddenAt : 0;
+			_hiddenAt = null;
+			_isVisible.value = true;
+			log$1(`tab → visible (hiddenMs=${hiddenMs}, visible-listeners=${_visibleListeners.size})`);
+			for (const { cb } of _visibleListeners) try {
+				cb({ hiddenMs });
+			} catch (err) {
+				console.error("[TabVisibility] onTabVisible listener threw:", err);
+			}
+		}
+	});
+}
+function useTabVisibility() {
+	_init();
+	const isVisible = computed(() => _isVisible.value);
+	function onTabHidden(cb) {
+		const entry = { cb };
+		_hiddenListeners.add(entry);
+		const off = () => {
+			_hiddenListeners.delete(entry);
+		};
+		tryOnScopeDispose(off);
+		return off;
+	}
+	function onTabPaused(cb, options = {}) {
+		const entry = {
+			cb,
+			delayMs: options.delayMs ?? DEFAULT_TAB_PAUSE_MS,
+			timer: null
+		};
+		_pausedListeners.add(entry);
+		const off = () => {
+			if (entry.timer !== null) {
+				clearTimeout(entry.timer);
+				entry.timer = null;
+			}
+			_pausedListeners.delete(entry);
+		};
+		tryOnScopeDispose(off);
+		return off;
+	}
+	function onTabVisible(cb) {
+		const entry = { cb };
+		_visibleListeners.add(entry);
+		const off = () => {
+			_visibleListeners.delete(entry);
+		};
+		tryOnScopeDispose(off);
+		return off;
+	}
+	return {
+		isVisible,
+		onTabHidden,
+		onTabPaused,
+		onTabVisible
+	};
+}
+//#endregion
+//#region src/streaming/config.ts
+var STREAM_CONFIG = {
+	WEBRTC: {
+		RECONNECT_DELAY: 1e3,
+		CONNECT_TIMEOUT: 1e4,
+		WS_CONNECT_TIMEOUT: 5e3,
+		ICE_SERVERS: [{ urls: "stun:stun.l.google.com:19302" }]
+	},
+	MSE: {
+		BUFFER_SIZE: 2 * 1024 * 1024,
+		BUFFER_WINDOW: 5
+	},
+	CODECS: {
+		DEFAULT: [
+			"avc1.640029",
+			"avc1.64002A",
+			"avc1.640033",
+			"hvc1.1.6.L153.B0",
+			"mp4a.40.2",
+			"mp4a.40.5",
+			"flac",
+			"opus"
+		],
+		WEBRTC_VIDEO: [
+			"H264",
+			"VP8",
+			"VP9"
+		],
+		WEBRTC_AUDIO: [
+			"opus",
+			"G722",
+			"PCMU",
+			"PCMA"
+		]
+	}
+};
+//#endregion
+//#region src/streaming/utils.ts
+function safariVersion() {
+	return navigator.userAgent.match(/version\/(\d+)/i);
+}
+function getSupportedCodecs() {
+	const codecs = [...STREAM_CONFIG.CODECS.DEFAULT];
+	const version = safariVersion();
+	if (version?.[1]) {
+		const majorVersion = parseInt(version[1], 10);
+		if (majorVersion < 13) {
+			const index = codecs.indexOf("mp4a.40.2");
+			if (index > -1) codecs.splice(index);
+		} else if (majorVersion < 14) {
+			const index = codecs.indexOf("flac");
+			if (index > -1) codecs.splice(index);
+		} else {
+			const index = codecs.indexOf("opus");
+			if (index > -1) codecs.splice(index);
+		}
+	}
+	return codecs;
+}
+function filterSupportedCodecs(codecs, isTypeSupported) {
+	return codecs.filter((codec) => isTypeSupported(`video/mp4; codecs="${codec}"`)).join(",");
+}
+function isWebRTCCompatibleAudio(codec) {
+	return STREAM_CONFIG.CODECS.WEBRTC_AUDIO.includes(codec);
+}
+function isWebRTCCompatibleVideo(codec) {
+	if (STREAM_CONFIG.CODECS.WEBRTC_VIDEO.includes(codec)) return true;
+	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"));
+	} catch {
+		return false;
+	}
+}
+function checkWebRTCCompatibility(probe) {
+	const audioStreams = probe.audio.filter((s) => s.direction === "sendonly");
+	const videoStreams = probe.video.filter((s) => s.direction === "sendonly");
+	const audioCompatible = audioStreams.length === 0 || audioStreams.some((s) => isWebRTCCompatibleAudio(s.codec));
+	const videoCompatible = videoStreams.length === 0 || videoStreams.some((s) => isWebRTCCompatibleVideo(s.codec));
+	const incompatibleCodecs = [];
+	if (!audioCompatible) incompatibleCodecs.push(...audioStreams.map((s) => s.codec));
+	if (!videoCompatible) incompatibleCodecs.push(...videoStreams.map((s) => s.codec));
+	return {
+		compatible: audioCompatible && videoCompatible,
+		audioCompatible,
+		videoCompatible,
+		incompatibleCodecs
+	};
+}
+function hasManagedMediaSource() {
+	return "ManagedMediaSource" in window;
+}
+function getMediaSourceConstructor() {
+	if (hasManagedMediaSource()) return window.ManagedMediaSource;
+	if ("MediaSource" in window) return window.MediaSource;
+}
+function abortableSleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal.aborted) {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const timer = setTimeout(resolve, ms);
+		signal.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(new DOMException("Aborted", "AbortError"));
+		}, { once: true });
+	});
+}
+//#endregion
+//#region src/streaming/mse.ts
+function createMSEHandler(options) {
+	const { videoElement, onReady, onFirstData, onError, signal } = options;
+	let mediaSource = null;
+	let sourceBuffer = null;
+	let isReady = false;
+	let hasFirstData = false;
+	let pendingBuffer = new Uint8Array(STREAM_CONFIG.MSE.BUFFER_SIZE);
+	let pendingLength = 0;
+	const earlyDataBuffer = [];
+	const supportedCodecs = getSupportedCodecs();
+	function setup() {
+		if (signal.aborted) return void 0;
+		const MediaSourceConstructor = getMediaSourceConstructor();
+		if (!MediaSourceConstructor) {
+			onError(/* @__PURE__ */ new Error("MediaSource not supported"));
+			return;
+		}
+		mediaSource = new MediaSourceConstructor();
+		const isMMS = hasManagedMediaSource();
+		const oldSrc = videoElement.src;
+		mediaSource.addEventListener("sourceopen", () => {
+			if (signal.aborted) return;
+			if (!isMMS && oldSrc && oldSrc.startsWith("blob:") && oldSrc !== videoElement.src) URL.revokeObjectURL(oldSrc);
+		}, { once: true });
+		if (isMMS) {
+			videoElement.disableRemotePlayback = true;
+			videoElement.srcObject = mediaSource;
+		} else {
+			videoElement.src = URL.createObjectURL(mediaSource);
+			videoElement.srcObject = null;
+		}
+		return filterSupportedCodecs(supportedCodecs, MediaSourceConstructor.isTypeSupported.bind(MediaSourceConstructor));
+	}
+	function initializeBuffer(mimeType) {
+		if (signal.aborted || !mediaSource) return;
+		if (mediaSource.readyState !== "open") {
+			mediaSource.addEventListener("sourceopen", () => {
+				if (!signal.aborted) initializeBuffer(mimeType);
+			}, { once: true });
+			return;
+		}
+		pendingLength = 0;
+		pendingBuffer = new Uint8Array(STREAM_CONFIG.MSE.BUFFER_SIZE);
+		const MediaSourceConstructor = getMediaSourceConstructor();
+		if (MediaSourceConstructor && !MediaSourceConstructor.isTypeSupported(mimeType)) {
+			onError(/* @__PURE__ */ new Error(`MIME type not supported: ${mimeType}`));
+			return;
+		}
+		try {
+			sourceBuffer = mediaSource.addSourceBuffer(mimeType);
+			sourceBuffer.mode = "segments";
+			sourceBuffer.addEventListener("updateend", handleUpdateEnd);
+			isReady = true;
+			if (earlyDataBuffer.length > 0) {
+				for (const earlyData of earlyDataBuffer) appendBuffer(earlyData);
+				earlyDataBuffer.length = 0;
+			}
+			onReady();
+		} catch (err) {
+			onError(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	function handleUpdateEnd() {
+		if (signal.aborted || !sourceBuffer || !mediaSource) return;
+		if (!sourceBuffer.updating && pendingLength > 0) try {
+			const data = pendingBuffer.slice(0, pendingLength);
+			sourceBuffer.appendBuffer(data);
+			pendingLength = 0;
+		} catch {}
+		if (!sourceBuffer.updating && sourceBuffer.buffered?.length) {
+			const end = sourceBuffer.buffered.end(sourceBuffer.buffered.length - 1);
+			const start = end - STREAM_CONFIG.MSE.BUFFER_WINDOW;
+			const start0 = sourceBuffer.buffered.start(0);
+			if (!hasFirstData) {
+				hasFirstData = true;
+				onFirstData();
+			}
+			if (start > start0) try {
+				sourceBuffer.remove(start0, start);
+				mediaSource.setLiveSeekableRange(start, end);
+			} catch {}
+			if (videoElement.currentTime < start) videoElement.currentTime = start;
+			const gap = end - videoElement.currentTime;
+			if (gap > 1) videoElement.playbackRate = 1.1;
+			else if (gap < .1) videoElement.playbackRate = .9;
+			else videoElement.playbackRate = 1;
+		}
+	}
+	function appendBuffer(data) {
+		if (signal.aborted) return;
+		if (!sourceBuffer) {
+			earlyDataBuffer.push(data);
+			return;
+		}
+		if (mediaSource?.readyState === "closed") {
+			onError(/* @__PURE__ */ new Error("MediaSource closed"));
+			return;
+		}
+		if (sourceBuffer.updating || pendingLength > 0) {
+			const bytes = new Uint8Array(data);
+			pendingBuffer.set(bytes, pendingLength);
+			pendingLength += bytes.byteLength;
+		} else try {
+			sourceBuffer.appendBuffer(data);
+		} catch {}
+	}
+	function close() {
+		if (sourceBuffer) {
+			sourceBuffer.removeEventListener("updateend", handleUpdateEnd);
+			if (mediaSource?.readyState === "open") try {
+				mediaSource.removeSourceBuffer(sourceBuffer);
+			} catch {}
+			sourceBuffer = null;
+		}
+		if (mediaSource?.readyState === "open") try {
+			mediaSource.endOfStream();
+		} catch {}
+		mediaSource = null;
+		isReady = false;
+		hasFirstData = false;
+		pendingLength = 0;
+		earlyDataBuffer.length = 0;
+	}
+	signal.addEventListener("abort", close, { once: true });
+	return {
+		get mediaSource() {
+			return mediaSource;
+		},
+		get sourceBuffer() {
+			return sourceBuffer;
+		},
+		get isReady() {
+			return isReady;
+		},
+		setup,
+		initializeBuffer,
+		appendBuffer,
+		close
+	};
+}
+async function playVideo(videoElement) {
+	try {
+		await videoElement.play();
+	} catch {
+		if (!videoElement.muted) {
+			videoElement.muted = true;
+			await playVideo(videoElement);
+		}
+	}
+}
+//#endregion
+//#region src/streaming/webrtc.ts
+function createBasePeerConnection(signal, onCandidate, filterUdp) {
+	const peerConnection = new RTCPeerConnection({
+		bundlePolicy: "max-bundle",
+		iceServers: [...STREAM_CONFIG.WEBRTC.ICE_SERVERS]
+	});
+	peerConnection.onicecandidate = (ev) => {
+		if (signal.aborted) return;
+		if (filterUdp && ev.candidate?.protocol === "udp") return;
+		const candidate = ev.candidate?.toJSON().candidate ?? "";
+		if (candidate) onCandidate(candidate);
+	};
+	return peerConnection;
+}
+async function handleSdpAnswer(pc, signal, sdp) {
+	if (signal.aborted || !pc) return;
+	await pc.setRemoteDescription({
+		type: "answer",
+		sdp
+	});
+}
+async function handleIceCandidate(pc, signal, candidate, filterUdp) {
+	if (signal.aborted || !pc) return;
+	if (filterUdp && candidate.includes(" udp ")) return;
+	await pc.addIceCandidate({
+		candidate,
+		sdpMid: "0"
+	});
+}
+async function setMicTrack(micTransceiver, signal, track) {
+	if (signal.aborted || !micTransceiver) return;
+	try {
+		await micTransceiver.sender.replaceTrack(track);
+	} catch {}
+}
+function closePeerConnection(state) {
+	if (state.micTransceiver) {
+		state.micTransceiver.sender.replaceTrack(null).catch(() => {});
+		state.micTransceiver = null;
+	}
+	if (state.pc) {
+		state.pc.getTransceivers().forEach((t) => t.sender?.track?.stop());
+		state.pc.close();
+		state.pc = null;
+	}
+	state.isConnected = false;
+}
+function createWebRTCHandler(options) {
+	const { mode, onConnected, onDisconnected, onFailed, onCandidate, signal } = options;
+	const state = {
+		pc: null,
+		micTransceiver: null,
+		isConnected: false
+	};
+	const filterUdp = mode === "webrtc/tcp";
+	function createPeerConnection() {
+		const peerConnection = createBasePeerConnection(signal, onCandidate, filterUdp);
+		peerConnection.onconnectionstatechange = () => {
+			if (signal.aborted) return;
+			const connectionState = peerConnection.connectionState;
+			if (connectionState === "connected") {
+				state.isConnected = true;
+				onConnected(new MediaStream(peerConnection.getTransceivers().filter((tr) => tr.currentDirection === "recvonly").map((tr) => tr.receiver.track)));
+			} else if (connectionState === "failed") {
+				state.isConnected = false;
+				onFailed();
+			} else if (connectionState === "disconnected") {
+				state.isConnected = false;
+				onDisconnected();
+			}
+		};
+		peerConnection.addTransceiver("video", { direction: "recvonly" });
+		peerConnection.addTransceiver("audio", { direction: "recvonly" });
+		state.micTransceiver = peerConnection.addTransceiver("audio", { direction: "sendonly" });
+		return peerConnection;
+	}
+	async function createOffer() {
+		if (signal.aborted) return void 0;
+		state.pc = createPeerConnection();
+		const offer = await state.pc.createOffer();
+		await state.pc.setLocalDescription(offer);
+		return offer.sdp;
+	}
+	function close() {
+		closePeerConnection(state);
+	}
+	signal.addEventListener("abort", close, { once: true });
+	return {
+		get pc() {
+			return state.pc;
+		},
+		get micTransceiver() {
+			return state.micTransceiver;
+		},
+		get isConnected() {
+			return state.isConnected;
+		},
+		createOffer,
+		handleAnswer: (sdp) => handleSdpAnswer(state.pc, signal, sdp),
+		handleCandidate: (candidate) => handleIceCandidate(state.pc, signal, candidate, filterUdp),
+		setMicrophoneTrack: (track) => setMicTrack(state.micTransceiver, signal, track),
+		close
+	};
+}
+function createBackchannelHandler(options) {
+	const { onConnected, onDisconnected, onCandidate, signal } = options;
+	const state = {
+		pc: null,
+		micTransceiver: null,
+		isConnected: false
+	};
+	function createPeerConnection() {
+		const peerConnection = createBasePeerConnection(signal, onCandidate, false);
+		peerConnection.onconnectionstatechange = () => {
+			if (signal.aborted) return;
+			const connectionState = peerConnection.connectionState;
+			if (connectionState === "connected") {
+				state.isConnected = true;
+				onConnected();
+			} else if (connectionState === "disconnected" || connectionState === "failed") {
+				state.isConnected = false;
+				onDisconnected();
+			}
+		};
+		state.micTransceiver = peerConnection.addTransceiver("audio", { direction: "sendonly" });
+		return peerConnection;
+	}
+	async function createOffer() {
+		if (signal.aborted) return void 0;
+		state.pc = createPeerConnection();
+		const offer = await state.pc.createOffer();
+		await state.pc.setLocalDescription(offer);
+		return offer.sdp;
+	}
+	function close() {
+		closePeerConnection(state);
+	}
+	signal.addEventListener("abort", close, { once: true });
+	return {
+		get isConnected() {
+			return state.isConnected;
+		},
+		createOffer,
+		handleAnswer: (sdp) => handleSdpAnswer(state.pc, signal, sdp),
+		handleCandidate: (candidate) => handleIceCandidate(state.pc, signal, candidate, false),
+		setMicrophoneTrack: (track) => setMicTrack(state.micTransceiver, signal, track),
+		close
+	};
+}
+async function processWebRTCMessage(handler, msg) {
+	switch (msg.type) {
+		case "webrtc/answer":
+			await handler.handleAnswer(msg.value);
+			break;
+		case "webrtc/candidate":
+			if (msg.value) await handler.handleCandidate(msg.value);
+			break;
+	}
+}
+//#endregion
+//#region src/streaming/streamConnection.ts
+function log(...args) {
+	const d = /* @__PURE__ */ new Date();
+	const hh = String(d.getHours()).padStart(2, "0");
+	const mm = String(d.getMinutes()).padStart(2, "0");
+	const ss = String(d.getSeconds()).padStart(2, "0");
+	const ms = String(d.getMilliseconds()).padStart(3, "0");
+	console.log(`[StreamConnection ${hh}:${mm}:${ss}.${ms}]`, ...args);
+}
+var StreamConnection = class {
+	status;
+	activeMode;
+	requestedMode;
+	activeResolution;
+	requestedResolution;
+	source;
+	hasVideo;
+	hasAudio;
+	hasBackchannel;
+	isPlaying;
+	error;
+	probeInfo;
+	muted;
+	paused;
+	nativeWidth;
+	nativeHeight;
+	options;
+	connectionGeneration = 0;
+	abortController = new AbortController();
+	offTabVisible;
+	offTabPaused;
+	wasPausedByVisibility = false;
+	wsTransport;
+	wsHandle;
+	webrtcHandler;
+	mseHandler;
+	firstFrameCallbackId;
+	backchannelHandler;
+	pendingMicTrack = null;
+	lastMediaStream = null;
+	stopWatchers = [];
+	mseMonitorInterval;
+	onVideoPauseBound;
+	onVideoPlayBound;
+	onVideoResizeBound;
+	camera;
+	videoElement;
+	containerElement;
+	target;
+	isReady;
+	effectiveMode;
+	startWsConnectTimeout;
+	stopWsConnectTimeout;
+	startConnectTimeout;
+	stopConnectTimeout;
+	startReconnectTimeout;
+	stopReconnectTimeout;
+	constructor(options) {
+		this.options = options;
+		const ctx = useCameraUi();
+		if (!ctx.wsTransport) throw new Error("[camera.ui] StreamConnection requires a wsTransport on CameraUiContext — pass `wsTransport` to createCameraUiPlugin.");
+		this.target = ctx.target;
+		this.wsTransport = ctx.wsTransport;
+		const { autoStart = true } = options;
+		this.status = ref("idle");
+		this.activeMode = ref("webrtc");
+		this.activeResolution = ref("low-resolution");
+		this.source = shallowRef();
+		this.hasVideo = ref(false);
+		this.hasAudio = ref(false);
+		this.hasBackchannel = ref(false);
+		this.isPlaying = ref(false);
+		this.error = ref();
+		this.probeInfo = shallowRef();
+		this.muted = ref(true);
+		this.paused = ref(false);
+		this.nativeWidth = ref(0);
+		this.nativeHeight = ref(0);
+		this.requestedMode = ref(toValue(options.mode) ?? "auto");
+		this.requestedResolution = ref(toValue(options.resolution) ?? "high-resolution");
+		this.camera = computed(() => toValue(options.camera));
+		this.videoElement = computed(() => toValue(options.videoElement));
+		this.containerElement = computed(() => toValue(options.containerElement));
+		this.isReady = computed(() => !!this.camera.value && !!this.videoElement.value && !!this.target.value);
+		this.effectiveMode = computed(() => {
+			if (this.requestedMode.value === "auto") return this.activeMode.value;
+			return this.requestedMode.value;
+		});
+		const { onTabPaused, onTabVisible } = useTabVisibility();
+		const { start: startWsConnectTimeout, stop: stopWsConnectTimeout } = useTimeoutFn(() => {
+			if (this.wsHandle?.readyState === WebSocket.CONNECTING) {
+				this.disconnectWebSocket();
+				if (!this.abortController.signal.aborted && this.status.value !== "closed") this.restart();
+			}
+		}, STREAM_CONFIG.WEBRTC.WS_CONNECT_TIMEOUT, { immediate: false });
+		this.startWsConnectTimeout = startWsConnectTimeout;
+		this.stopWsConnectTimeout = stopWsConnectTimeout;
+		const { start: startConnectTimeout, stop: stopConnectTimeout } = useTimeoutFn(() => {
+			if (this.webrtcHandler && !this.webrtcHandler.isConnected) if (this.requestedMode.value === "auto") if (this.mseHandler?.isReady) {
+				this.activeMode.value = "mse";
+				this.status.value = "connected";
+			} else {
+				this.activeMode.value = "mse";
+				this.startMSE();
+			}
+			else this.restart();
+		}, STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
+		this.startConnectTimeout = startConnectTimeout;
+		this.stopConnectTimeout = stopConnectTimeout;
+		const { start: startReconnectTimeout, stop: stopReconnectTimeout } = useTimeoutFn(() => {
+			if (!this.abortController.signal.aborted) this.restart();
+		}, STREAM_CONFIG.WEBRTC.RECONNECT_DELAY, { immediate: false });
+		this.startReconnectTimeout = startReconnectTimeout;
+		this.stopReconnectTimeout = stopReconnectTimeout;
+		this.setupWatchers();
+		this.offTabPaused = onTabPaused(() => {
+			log(`onTabPaused fired — status=${this.status.value}, isReady=${this.isReady.value}, target=${!!this.target.value}`);
+			if (this.status.value === "idle" || this.status.value === "closed") {
+				log(`onTabPaused — already in ${this.status.value}, skipping stop()`);
+				return;
+			}
+			this.wasPausedByVisibility = true;
+			this.stop();
+			log("onTabPaused — stop() done, wasPausedByVisibility=true");
+		});
+		this.offTabVisible = onTabVisible(() => {
+			log(`onTabVisible fired — wasPausedByVisibility=${this.wasPausedByVisibility}, status=${this.status.value}, isReady=${this.isReady.value}, target=${!!this.target.value}`);
+			if (!this.wasPausedByVisibility) {
+				log("onTabVisible — not paused by visibility, no-op");
+				return;
+			}
+			this.wasPausedByVisibility = false;
+			this.startWhenReady();
+		});
+		if (autoStart) whenever(this.isReady, () => {
+			if (this.status.value === "idle" || this.status.value === "closed") this.start();
+		}, { immediate: true });
+	}
+	async start() {
+		log(`start() called — status=${this.status.value}, isReady=${this.isReady.value}`);
+		if (this.status.value !== "idle" && this.status.value !== "closed") {
+			log(`start() — skipped, status is ${this.status.value}`);
+			return;
+		}
+		if (!this.isReady.value) {
+			log("start() — skipped, isReady=false");
+			return;
+		}
+		this.cleanup();
+		this.abortController = new AbortController();
+		const gen = ++this.connectionGeneration;
+		this.status.value = "connecting";
+		this.error.value = void 0;
+		this.isPlaying.value = false;
+		try {
+			if (!this.initializeSource()) {
+				log("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("start() — generation stale after probe, aborting");
+				return;
+			}
+			this.initializeSource();
+			log("start() — connecting WebSocket");
+			this.connectWebSocket();
+		} catch (err) {
+			if (gen !== this.connectionGeneration) return;
+			log("start() — error:", err);
+			this.error.value = err instanceof Error ? err : new Error(String(err));
+			this.status.value = "error";
+		}
+	}
+	stop() {
+		if (this.status.value === "closed") {
+			log("stop() — already closed, no-op");
+			return;
+		}
+		log(`stop() — was ${this.status.value}, transitioning to closed`);
+		++this.connectionGeneration;
+		this.status.value = "closed";
+		this.cleanup();
+	}
+	async setMode(mode) {
+		if (this.requestedMode.value === mode) return;
+		this.requestedMode.value = mode;
+		this.activeMode.value = mode === "auto" ? "webrtc" : mode;
+		if (this.status.value === "connected") await this.restart();
+	}
+	async setResolution(resolution) {
+		if (this.requestedResolution.value === resolution) return;
+		this.requestedResolution.value = resolution;
+		const result = this.getSourceForResolution(resolution);
+		if (result && result.source._id !== this.source.value?._id) {
+			this.source.value = result.source;
+			this.activeResolution.value = result.effectiveResolution;
+			if (this.status.value === "connected") await this.restart();
+		}
+	}
+	async setMicrophone(track) {
+		if (this.webrtcHandler) {
+			await this.webrtcHandler.setMicrophoneTrack(track);
+			return;
+		}
+		if (this.activeMode.value === "mse" && this.hasBackchannel.value) {
+			this.pendingMicTrack = track;
+			if (track && !this.backchannelHandler) await this.startBackchannel();
+			else if (!track && this.backchannelHandler) this.closeBackchannel();
+			else if (this.backchannelHandler?.isConnected) await this.backchannelHandler.setMicrophoneTrack(track);
+		}
+	}
+	setMuted(muted) {
+		this.muted.value = muted;
+		const video = this.videoElement.value;
+		if (video) video.muted = muted;
+	}
+	async play() {
+		this.paused.value = false;
+		const video = this.videoElement.value;
+		if (!video) return;
+		try {
+			await video.play();
+		} catch {
+			if (!video.muted) {
+				video.muted = true;
+				this.muted.value = true;
+				try {
+					await video.play();
+				} catch {}
+			}
+		}
+	}
+	pause() {
+		this.paused.value = true;
+		const video = this.videoElement.value;
+		if (video) video.pause();
+	}
+	destroy() {
+		for (const stopWatcher of this.stopWatchers) stopWatcher();
+		this.stopWatchers = [];
+		this.offTabVisible?.();
+		this.offTabVisible = void 0;
+		this.offTabPaused?.();
+		this.offTabPaused = void 0;
+		this.stop();
+	}
+	async restart() {
+		this.status.value = "reconnecting";
+		this.isPlaying.value = false;
+		this.cleanup();
+		this.abortController = new AbortController();
+		const gen = ++this.connectionGeneration;
+		try {
+			await abortableSleep(1e3, this.abortController.signal);
+		} catch {
+			return;
+		}
+		if (gen !== this.connectionGeneration) return;
+		if (!this.isReady.value) {
+			this.status.value = "idle";
+			return;
+		}
+		try {
+			if (!this.initializeSource()) {
+				this.error.value = /* @__PURE__ */ new Error("No streaming source available");
+				this.status.value = "error";
+				return;
+			}
+			this.connectWebSocket();
+		} catch (err) {
+			if (gen !== this.connectionGeneration) return;
+			this.error.value = err instanceof Error ? err : new Error(String(err));
+			this.status.value = "error";
+		}
+	}
+	startWhenReady() {
+		if (this.isReady.value) {
+			log("startWhenReady — already ready, calling start() now");
+			this.start();
+			return;
+		}
+		log(`startWhenReady — not ready (camera=${!!this.camera.value}, video=${!!this.videoElement.value}, target=${!!this.target.value}), watching isReady`);
+		const stop = watch(this.isReady, (ready) => {
+			if (!ready) return;
+			log("startWhenReady — isReady → true, calling start()");
+			stop();
+			this.start();
+		});
+		this.stopWatchers.push(stop);
+	}
+	setupWatchers() {
+		const stopAuthWatch = watch(() => this.target.value?.endpoint.url ?? null, (next, prev) => {
+			if (!next || !prev || next === prev) return;
+			if (this.status.value === "idle" || this.status.value === "closed") return;
+			this.restart();
+		});
+		this.stopWatchers.push(stopAuthWatch);
+		const stopModeWatch = watch(() => toValue(this.options.mode), (newMode) => {
+			if (newMode !== void 0 && newMode !== this.requestedMode.value) this.setMode(newMode);
+		});
+		this.stopWatchers.push(stopModeWatch);
+		const stopResolutionWatch = watch(() => toValue(this.options.resolution), (newResolution) => {
+			if (newResolution !== void 0 && newResolution !== this.requestedResolution.value) this.setResolution(newResolution);
+		});
+		this.stopWatchers.push(stopResolutionWatch);
+		const stopVideoElWatch = watch(this.videoElement, (video, oldVideo) => {
+			if (oldVideo) {
+				if (this.onVideoPauseBound) oldVideo.removeEventListener("pause", this.onVideoPauseBound);
+				if (this.onVideoPlayBound) oldVideo.removeEventListener("play", this.onVideoPlayBound);
+				if (this.onVideoResizeBound) oldVideo.removeEventListener("resize", this.onVideoResizeBound);
+			}
+			if (video) {
+				this.onVideoPauseBound = () => {
+					if (!this.paused.value) video.play().catch(() => {});
+				};
+				this.onVideoPlayBound = () => {
+					this.paused.value = false;
+				};
+				this.onVideoResizeBound = () => {
+					if (video.videoWidth > 0 && video.videoHeight > 0) {
+						this.nativeWidth.value = video.videoWidth;
+						this.nativeHeight.value = video.videoHeight;
+					}
+				};
+				video.addEventListener("pause", this.onVideoPauseBound);
+				video.addEventListener("play", this.onVideoPlayBound);
+				video.addEventListener("resize", this.onVideoResizeBound);
+				if (video.videoWidth > 0 && video.videoHeight > 0) {
+					this.nativeWidth.value = video.videoWidth;
+					this.nativeHeight.value = video.videoHeight;
+				}
+			}
+		}, { immediate: true });
+		this.stopWatchers.push(stopVideoElWatch);
+		const stopMseWatch = watch(this.activeMode, (mode) => {
+			this.stopMseMonitor();
+			if (mode === "mse") this.mseMonitorInterval = setInterval(() => this.monitorMseBuffer(), 1e3);
+		}, { immediate: true });
+		this.stopWatchers.push(stopMseWatch);
+		const stopCameraWatch = watch([
+			this.camera,
+			this.videoElement,
+			() => this.target.value
+		], ([newCamera, newVideo, newClient], [oldCamera, oldVideo]) => {
+			if (newCamera !== oldCamera) {
+				if (this.status.value === "connected") {
+					if (newCamera && newVideo && newClient) this.restart();
+				}
+			} else if (newVideo !== oldVideo && newVideo) {
+				if (newVideo.srcObject instanceof MediaStream) {
+					const existingStream = newVideo.srcObject;
+					if (existingStream.active && existingStream.getTracks().some((t) => t.readyState === "live")) {
+						playVideo(newVideo);
+						this.lastMediaStream = existingStream;
+						return;
+					}
+				}
+				if (this.status.value === "connected" && this.activeMode.value !== "mse") {
+					const mediaStream = this.lastMediaStream;
+					if (mediaStream?.active && mediaStream.getTracks().some((t) => t.readyState === "live")) {
+						newVideo.srcObject = mediaStream;
+						playVideo(newVideo);
+					} else this.restart();
+				} else if (this.status.value === "connected" && this.activeMode.value === "mse") this.restart();
+				else if (this.status.value === "connecting" || this.status.value === "reconnecting") {
+					const stopConnectionWatch = watch(() => this.isPlaying.value, (playing) => {
+						const currentVideo = this.videoElement.value;
+						if (playing && currentVideo?.srcObject instanceof MediaStream) {
+							playVideo(currentVideo);
+							stopConnectionWatch();
+						} else if (playing && currentVideo && !currentVideo.srcObject) {
+							if (this.lastMediaStream?.active) {
+								currentVideo.srcObject = this.lastMediaStream;
+								playVideo(currentVideo);
+								stopConnectionWatch();
+							}
+						}
+					}, { immediate: true });
+					this.stopWatchers.push(stopConnectionWatch);
+				}
+			}
+		});
+		this.stopWatchers.push(stopCameraWatch);
+	}
+	getSourceForResolution(resolution) {
+		const cam = this.camera.value;
+		if (!cam) return void 0;
+		const resolutionOrder = [
+			"high-resolution",
+			"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);
+		for (let i = startIndex; i < resolutionOrder.length; i++) {
+			const src = cam.sources.value.find((s) => s.role === resolutionOrder[i]);
+			if (src) return {
+				source: src,
+				effectiveResolution: resolutionOrder[i]
+			};
+		}
+		const fallback = cam.streamSource.value;
+		if (fallback) return {
+			source: fallback,
+			effectiveResolution: fallback.role ?? "low-resolution"
+		};
+	}
+	initializeSource() {
+		const result = this.getSourceForResolution(this.requestedResolution.value);
+		if (!result) return false;
+		this.source.value = result.source;
+		this.activeResolution.value = result.effectiveResolution;
+		return true;
+	}
+	async probeStream() {
+		const cam = this.camera.value;
+		if (!cam || !this.source.value || this.abortController.signal.aborted) return void 0;
+		try {
+			const probe = await cam.probeStream(this.source.value._id, {
+				video: true,
+				audio: ["pcma", "opus"],
+				microphone: true
+			});
+			if (probe && !this.abortController.signal.aborted) {
+				this.probeInfo.value = probe;
+				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;
+			}
+			return probe;
+		} catch {
+			return;
+		}
+	}
+	connectWebSocket() {
+		this.disconnectWebSocket();
+		const cam = this.camera.value;
+		if (this.abortController.signal.aborted || !cam || !this.source.value || !this.target.value) return;
+		const sourceNamePart = this.source.value.name ?? this.source.value.role ?? this.source.value._id;
+		const sourceName = createSourceName(cam.name.value, sourceNamePart);
+		this.startWsConnectTimeout();
+		this.wsHandle = this.wsTransport.open({
+			path: "/api/go2rtc",
+			query: { src: sourceName },
+			binaryType: "arraybuffer"
+		});
+		this.wsHandle.on("open", () => this.handleWsOpen());
+		this.wsHandle.on("close", () => this.handleWsClose());
+		this.wsHandle.on("message", (ev) => this.handleWsMessage(ev));
+		this.wsHandle.on("error", () => {});
+	}
+	disconnectWebSocket() {
+		this.stopWsConnectTimeout();
+		if (this.wsHandle) {
+			this.wsHandle.dispose();
+			this.wsHandle = void 0;
+		}
+	}
+	sendWsMessage(msg) {
+		if (this.wsHandle?.readyState === WebSocket.OPEN) this.wsHandle.send(JSON.stringify(msg));
+	}
+	handleWsOpen() {
+		if (this.abortController.signal.aborted) return;
+		this.stopWsConnectTimeout();
+		this.status.value = "connecting";
+		const mode = this.effectiveMode.value;
+		if (mode === "webrtc" || mode === "webrtc/tcp") this.startWebRTC(mode);
+		else if (mode === "mse") this.startMSE();
+		else if (this.requestedMode.value === "auto") this.startAutoMode();
+	}
+	handleWsClose() {
+		if (this.status.value !== "closed" && !this.abortController.signal.aborted) this.startReconnectTimeout();
+	}
+	handleWsMessage(ev) {
+		if (this.abortController.signal.aborted) return;
+		if (typeof ev.data === "string") {
+			const msg = JSON.parse(ev.data);
+			this.handleMessage(msg);
+		} else if (this.mseHandler) {
+			this.mseHandler.appendBuffer(ev.data);
+			this.handleFirstFrame();
+		}
+	}
+	handleMessage(msg) {
+		switch (msg.type) {
+			case "webrtc/answer":
+			case "webrtc/candidate":
+				if (this.webrtcHandler) processWebRTCMessage(this.webrtcHandler, msg);
+				else if (this.backchannelHandler) processWebRTCMessage(this.backchannelHandler, msg);
+				break;
+			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;
+		}
+	}
+	async startWebRTC(mode) {
+		if (this.abortController.signal.aborted) return;
+		this.startConnectTimeout();
+		this.webrtcHandler = createWebRTCHandler({
+			mode,
+			signal: this.abortController.signal,
+			onConnected: (stream) => this.handleWebRTCConnected(stream),
+			onDisconnected: () => this.handleWebRTCDisconnected(),
+			onFailed: () => this.handleWebRTCFailed(),
+			onCandidate: (candidate) => this.sendWsMessage({
+				type: "webrtc/candidate",
+				value: candidate
+			})
+		});
+		const offer = await this.webrtcHandler.createOffer();
+		if (offer && !this.abortController.signal.aborted) this.sendWsMessage({
+			type: "webrtc/offer",
+			value: offer
+		});
+	}
+	handleWebRTCConnected(stream) {
+		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;
+		video.muted = this.muted.value;
+		playVideo(video);
+		this.status.value = "connected";
+		this.handleFirstFrameWebRTC(stream);
+		if (this.requestedMode.value === "auto" && this.mseHandler) {
+			this.mseHandler.close();
+			this.mseHandler = void 0;
+		}
+	}
+	handleWebRTCDisconnected() {
+		if (this.status.value !== "closed" && !this.abortController.signal.aborted) {
+			this.status.value = "reconnecting";
+			if (this.requestedMode.value === "auto" && this.mseHandler?.isReady) {
+				this.activeMode.value = "mse";
+				this.status.value = "connected";
+			} else this.restart();
+		}
+	}
+	handleWebRTCFailed() {
+		if (this.abortController.signal.aborted) return;
+		this.stopConnectTimeout();
+		if (this.requestedMode.value === "auto") {
+			this.activeMode.value = "mse";
+			if (!this.mseHandler?.isReady) this.startMSE();
+			else this.status.value = "connected";
+		} else {
+			this.error.value = /* @__PURE__ */ new Error("WebRTC connection failed");
+			this.status.value = "error";
+		}
+	}
+	startMSE() {
+		const video = this.videoElement.value;
+		if (this.abortController.signal.aborted || !video) return;
+		this.mseHandler = createMSEHandler({
+			videoElement: video,
+			signal: this.abortController.signal,
+			onReady: () => this.handleMSEReady(),
+			onFirstData: () => this.handleMSEFirstData(),
+			onError: (err) => {
+				if (this.requestedMode.value !== "auto") {
+					this.error.value = err;
+					this.status.value = "error";
+				}
+			}
+		});
+		const codecs = this.mseHandler.setup();
+		if (codecs) this.sendWsMessage({
+			type: "mse",
+			value: codecs
+		});
+	}
+	handleMSEReady() {
+		if (this.abortController.signal.aborted) return;
+		if (this.requestedMode.value === "auto") {
+			if (!this.webrtcHandler?.isConnected) {
+				this.activeMode.value = "mse";
+				this.status.value = "connected";
+			}
+		} else {
+			this.activeMode.value = "mse";
+			this.status.value = "connected";
+		}
+	}
+	handleMSEFirstData() {
+		if (this.abortController.signal.aborted) return;
+		const video = this.videoElement.value;
+		if (video) playVideo(video);
+	}
+	async startAutoMode() {
+		if (this.abortController.signal.aborted) return;
+		const probe = this.probeInfo.value ?? await this.probeStream();
+		if (probe) {
+			if (!checkWebRTCCompatibility(probe).compatible) {
+				this.activeMode.value = "mse";
+				this.startMSE();
+				return;
+			}
+		}
+		this.startMSE();
+		this.startWebRTC("webrtc");
+	}
+	handleFirstFrame() {
+		if (!this.isPlaying.value && !this.abortController.signal.aborted) this.isPlaying.value = true;
+	}
+	monitorMseBuffer() {
+		const video = this.videoElement.value;
+		if (!video || this.activeMode.value !== "mse" || !this.isPlaying.value) return;
+		if (video.buffered.length > 0) {
+			const end = video.buffered.end(video.buffered.length - 1);
+			if (end - video.currentTime > 1) video.currentTime = end;
+		}
+	}
+	stopMseMonitor() {
+		if (this.mseMonitorInterval !== void 0) {
+			clearInterval(this.mseMonitorInterval);
+			this.mseMonitorInterval = void 0;
+		}
+	}
+	handleFirstFrameWebRTC(stream) {
+		const video = this.videoElement.value;
+		if (this.isPlaying.value || this.abortController.signal.aborted || !video) return;
+		if (!stream.getVideoTracks()[0]) {
+			this.handleFirstFrame();
+			return;
+		}
+		const videoWithCallback = video;
+		if (typeof videoWithCallback.requestVideoFrameCallback === "function") this.firstFrameCallbackId = videoWithCallback.requestVideoFrameCallback(() => {
+			if (!this.abortController.signal.aborted) this.handleFirstFrame();
+		});
+		else {
+			const checkFrame = () => {
+				if (this.abortController.signal.aborted) return;
+				if (video.readyState >= 2 && video.videoWidth > 0) this.handleFirstFrame();
+				else this.firstFrameCallbackId = requestAnimationFrame(checkFrame);
+			};
+			this.firstFrameCallbackId = requestAnimationFrame(checkFrame);
+		}
+	}
+	cleanup() {
+		this.abortController.abort();
+		this.stopConnectTimeout();
+		this.stopWsConnectTimeout();
+		this.stopReconnectTimeout();
+		this.stopMseMonitor();
+		const videoEl = this.videoElement.value;
+		if (videoEl) {
+			if (this.onVideoPauseBound) videoEl.removeEventListener("pause", this.onVideoPauseBound);
+			if (this.onVideoPlayBound) videoEl.removeEventListener("play", this.onVideoPlayBound);
+			if (this.onVideoResizeBound) videoEl.removeEventListener("resize", this.onVideoResizeBound);
+		}
+		this.lastMediaStream = null;
+		this.webrtcHandler?.close();
+		this.webrtcHandler = void 0;
+		this.mseHandler?.close();
+		this.mseHandler = void 0;
+		this.closeBackchannel();
+		this.disconnectWebSocket();
+		const video = this.videoElement.value;
+		if (this.firstFrameCallbackId !== void 0) {
+			if (video && "cancelVideoFrameCallback" in video) video.cancelVideoFrameCallback(this.firstFrameCallbackId);
+			else cancelAnimationFrame(this.firstFrameCallbackId);
+			this.firstFrameCallbackId = void 0;
+		}
+		if (video) {
+			video.style.display = "";
+			video.pause();
+			video.srcObject = null;
+			video.removeAttribute("src");
+			video.load();
+		}
+	}
+	async startBackchannel() {
+		if (this.abortController.signal.aborted || !this.wsHandle || this.wsHandle.readyState !== WebSocket.OPEN) return;
+		this.backchannelHandler = createBackchannelHandler({
+			signal: this.abortController.signal,
+			onCandidate: (candidate) => this.sendWsMessage({
+				type: "webrtc/candidate",
+				value: candidate
+			}),
+			onConnected: async () => {
+				if (this.pendingMicTrack && this.backchannelHandler) await this.backchannelHandler.setMicrophoneTrack(this.pendingMicTrack);
+			},
+			onDisconnected: () => {
+				this.backchannelHandler = void 0;
+			}
+		});
+		const offer = await this.backchannelHandler.createOffer();
+		if (offer && !this.abortController.signal.aborted) this.sendWsMessage({
+			type: "webrtc/offer",
+			value: offer
+		});
+	}
+	closeBackchannel() {
+		this.backchannelHandler?.close();
+		this.backchannelHandler = void 0;
+		this.pendingMicTrack = null;
+	}
+};
+function createStreamConnection(options) {
+	return new StreamConnection(options);
+}
+//#endregion
+//#region src/streaming/streamManager.ts
+var StreamManager = class {
+	streams = /* @__PURE__ */ new Map();
+	releaseTimers = /* @__PURE__ */ new Map();
+	releaseDelay;
+	DEFAULT_RELEASE_DELAY = 2e3;
+	constructor(config = {}) {
+		this.releaseDelay = config.releaseDelay ?? this.DEFAULT_RELEASE_DELAY;
+	}
+	has(cameraName) {
+		return this.streams.has(cameraName);
+	}
+	get(cameraName) {
+		return this.streams.get(cameraName);
+	}
+	acquire(cameraName, consumerContainerRef) {
+		this.cancelRelease(cameraName);
+		const entry = this.streams.get(cameraName);
+		if (entry) {
+			entry.refCount++;
+			if (consumerContainerRef) entry.consumerContainerRefs.add(consumerContainerRef);
+			return entry;
+		}
+	}
+	register(cameraName, stream, videoElementRef, cameraDeviceRef, containerElementRef, sharedVideoElement) {
+		this.cancelRelease(cameraName);
+		const entry = {
+			stream,
+			videoElementRef,
+			cameraDeviceRef,
+			containerElementRef,
+			consumerContainerRefs: new Set([containerElementRef]),
+			sharedVideoElement,
+			mediaStream: null,
+			refCount: 1
+		};
+		this.streams.set(cameraName, entry);
+		return entry;
+	}
+	updateContainerElement(cameraName, container) {
+		const entry = this.streams.get(cameraName);
+		if (entry) entry.containerElementRef.value = container;
+	}
+	updateSharedVideoElement(cameraName, videoElement) {
+		const entry = this.streams.get(cameraName);
+		if (entry) entry.sharedVideoElement = videoElement;
+	}
+	updateMediaStream(cameraName, mediaStream) {
+		const entry = this.streams.get(cameraName);
+		if (entry) entry.mediaStream = mediaStream;
+	}
+	release(cameraName, _videoElement, consumerContainerRef) {
+		const entry = this.streams.get(cameraName);
+		if (!entry) return;
+		entry.refCount--;
+		if (consumerContainerRef) {
+			entry.consumerContainerRefs.delete(consumerContainerRef);
+			if (entry.refCount > 0 && consumerContainerRef.value === entry.containerElementRef.value) for (const ref of entry.consumerContainerRefs) {
+				const candidate = ref.value;
+				if (candidate && candidate !== consumerContainerRef.value) {
+					entry.containerElementRef = ref;
+					if (entry.sharedVideoElement && entry.sharedVideoElement.parentElement !== candidate) {
+						candidate.appendChild(entry.sharedVideoElement);
+						entry.sharedVideoElement.play().catch(() => {});
+					}
+					break;
+				}
+			}
+		}
+		if (entry.refCount <= 0) {
+			const timer = setTimeout(() => {
+				this.doRelease(cameraName);
+			}, this.releaseDelay);
+			this.releaseTimers.set(cameraName, timer);
+		}
+	}
+	forceRelease(cameraName) {
+		this.cancelRelease(cameraName);
+		this.doRelease(cameraName);
+	}
+	clear() {
+		for (const timer of this.releaseTimers.values()) clearTimeout(timer);
+		this.releaseTimers.clear();
+		for (const [cameraName, entry] of this.streams) {
+			entry.stream.stop();
+			this.streams.delete(cameraName);
+		}
+	}
+	getDebugInfo() {
+		return Array.from(this.streams.entries()).map(([cameraName, entry]) => ({
+			cameraName,
+			refCount: entry.refCount,
+			mode: entry.stream.activeMode.value,
+			resolution: entry.stream.activeResolution.value
+		}));
+	}
+	cancelRelease(cameraName) {
+		const timer = this.releaseTimers.get(cameraName);
+		if (timer) {
+			clearTimeout(timer);
+			this.releaseTimers.delete(cameraName);
+		}
+	}
+	doRelease(cameraName) {
+		const entry = this.streams.get(cameraName);
+		if (!entry) return;
+		if (entry.refCount <= 0) {
+			entry.stream.stop();
+			this.streams.delete(cameraName);
+		}
+		this.releaseTimers.delete(cameraName);
+	}
+};
+var streamManager = new StreamManager();
+//#endregion
+//#region src/composables/useFullscreen.ts
+var fsRegistry = /* @__PURE__ */ new WeakMap();
+var fullscreenStack = [];
+var topmostFullscreenWrapper = shallowRef(null);
+function refreshTopmost() {
+	topmostFullscreenWrapper.value = fullscreenStack[fullscreenStack.length - 1] ?? null;
+}
+function useTopmostFullscreenElement() {
+	return computed(() => topmostFullscreenWrapper.value);
+}
+function useCuiFullscreen(target, options = {}) {
+	const mode = options.mode ?? "fit";
+	const isFullscreen = ref(false);
+	const currentEl = shallowRef(null);
+	watch(() => toValue(target), (el) => {
+		currentEl.value = el ?? null;
+	}, { immediate: true });
+	function onEscape(e) {
+		if (e.key === "Escape" && isFullscreen.value) exit();
+	}
+	async function enter() {
+		const el = currentEl.value;
+		if (!el || isFullscreen.value) return;
+		const wrapper = document.createElement("div");
+		wrapper.className = `cui-fullscreen cui-fullscreen-${mode}`;
+		applyWrapperStyles(wrapper, mode);
+		const state = {
+			wrapper,
+			parent: el.parentElement,
+			next: el.nextSibling,
+			bodyOverflow: document.body.style.overflow,
+			htmlOverflow: document.documentElement.style.overflow
+		};
+		fsRegistry.set(el, state);
+		el.setAttribute("data-cui-fullscreen", mode);
+		document.body.appendChild(wrapper);
+		wrapper.appendChild(el);
+		document.body.style.overflow = "hidden";
+		document.documentElement.style.overflow = "hidden";
+		document.addEventListener("keydown", onEscape);
+		fullscreenStack.push(wrapper);
+		refreshTopmost();
+		isFullscreen.value = true;
+	}
+	async function exit() {
+		const el = currentEl.value;
+		if (!el || !isFullscreen.value) return;
+		const state = fsRegistry.get(el);
+		if (!state) return;
+		fsRegistry.delete(el);
+		el.removeAttribute("data-cui-fullscreen");
+		if (state.parent) if (state.next && state.next.parentNode === state.parent) state.parent.insertBefore(el, state.next);
+		else state.parent.appendChild(el);
+		state.wrapper.remove();
+		document.body.style.overflow = state.bodyOverflow;
+		document.documentElement.style.overflow = state.htmlOverflow;
+		document.removeEventListener("keydown", onEscape);
+		const stackIndex = fullscreenStack.indexOf(state.wrapper);
+		if (stackIndex !== -1) fullscreenStack.splice(stackIndex, 1);
+		refreshTopmost();
+		isFullscreen.value = false;
+	}
+	async function toggle() {
+		if (isFullscreen.value) await exit();
+		else await enter();
+	}
+	tryOnScopeDispose(() => {
+		if (isFullscreen.value && currentEl.value) exit();
+		document.removeEventListener("keydown", onEscape);
+	});
+	return {
+		isFullscreen: computed(() => isFullscreen.value),
+		isSupported: computed(() => true),
+		enter,
+		exit,
+		toggle
+	};
+}
+function applyWrapperStyles(wrapper, mode) {
+	const common = {
+		position: "fixed",
+		top: "0",
+		right: "0",
+		bottom: "0",
+		left: "0",
+		zIndex: "2147483647",
+		margin: "0",
+		background: "black",
+		paddingTop: "env(safe-area-inset-top)",
+		paddingRight: "env(safe-area-inset-right)",
+		paddingBottom: "env(safe-area-inset-bottom)",
+		paddingLeft: "env(safe-area-inset-left)",
+		boxSizing: "border-box"
+	};
+	if (mode === "fit") Object.assign(wrapper.style, common, {
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center",
+		overflow: "hidden"
+	});
+	else Object.assign(wrapper.style, common, {
+		display: "block",
+		overflowY: "auto",
+		overflowX: "hidden",
+		WebkitOverflowScrolling: "touch",
+		overscrollBehavior: "contain"
+	});
+}
+//#endregion
+//#region src/composables/useCameraStream.ts
+var AUTO_STAGGER_STEP_MS = 75;
+var AUTO_STAGGER_RESET_MS = 500;
+var autoStaggerIndex = 0;
+var autoStaggerLastTouch = 0;
+function acquireAutoStaggerDelay() {
+	const now = performance.now();
+	if (now - autoStaggerLastTouch > AUTO_STAGGER_RESET_MS) autoStaggerIndex = 0;
+	const delay = autoStaggerIndex * AUTO_STAGGER_STEP_MS;
+	autoStaggerIndex++;
+	autoStaggerLastTouch = now;
+	return delay;
+}
+function useCameraStream(options) {
+	const { activityConfig, autoStart: autoStartOption = true, isolated = false } = options;
+	const shouldAutoStart = () => toValue(autoStartOption);
+	const startDelay = options.startDelay ?? acquireAutoStaggerDelay();
+	const autoStartReady = ref(startDelay <= 0);
+	let startDelayTimer;
+	if (startDelay > 0) startDelayTimer = setTimeout(() => {
+		autoStartReady.value = true;
+	}, startDelay);
+	const { isConnected } = useCameraUi();
+	const cameraGetter = computed(() => toValue(options.camera));
+	const isCameraString = computed(() => typeof cameraGetter.value === "string");
+	const cameraName = computed(() => {
+		const cam = cameraGetter.value;
+		return typeof cam === "string" ? cam : cam.name.value;
+	});
+	const { camera: cameraDeviceFromLookup, isLoading: cameraDeviceLoading } = useCameraById(cameraName);
+	const resolvedCameraDevice = computed(() => {
+		if (isCameraString.value) return cameraDeviceFromLookup.value;
+		return cameraGetter.value;
+	});
+	const containerElement = shallowRef();
+	const fullscreenElement = shallowRef();
+	const videoElement = shallowRef();
+	const streamVideoElementRef = shallowRef();
+	const currentStream = shallowRef();
+	const isUsingCachedStream = ref(false);
+	const initialized = ref(false);
+	const cleanedUp = ref(false);
+	const cameraDeviceRef = shallowRef();
+	watch(resolvedCameraDevice, (device) => {
+		cameraDeviceRef.value = device;
+	}, { immediate: true });
+	const isCameraDisabled = computed(() => cameraDeviceRef.value?.disabled.value === true);
+	const cleanupFns = [];
+	let ownedConnection;
+	function createOwnedStream() {
+		ownedConnection = createStreamConnection({
+			camera: cameraDeviceRef,
+			videoElement: streamVideoElementRef,
+			containerElement,
+			mode: computed(() => toValue(options.mode) ?? "auto"),
+			resolution: computed(() => toValue(options.resolution) ?? "high-resolution"),
+			autoStart: false
+		});
+		return ownedConnection;
+	}
+	const ownedStream = createOwnedStream();
+	function createVideoElement() {
+		const video = document.createElement("video");
+		video.autoplay = true;
+		video.playsInline = true;
+		video.muted = true;
+		video.disablePictureInPicture = false;
+		video.preload = "auto";
+		video.style.position = "absolute";
+		video.style.width = "100%";
+		video.style.height = "100%";
+		video.style.inset = "0";
+		video.style.objectFit = "fill";
+		return video;
+	}
+	function insertVideoIntoContainer(video, container) {
+		if (video.parentElement && video.parentElement !== container) video.parentElement.removeChild(video);
+		if (video.parentElement !== container) container.appendChild(video);
+	}
+	watch([containerElement, videoElement], ([container, video]) => {
+		if (container && video) insertVideoIntoContainer(video, container);
+	}, { immediate: true });
+	const status = computed(() => currentStream.value?.status.value ?? "idle");
+	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 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 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);
+	const paused = computed(() => currentStream.value?.paused.value ?? false);
+	const nativeWidth = ref(0);
+	const nativeHeight = ref(0);
+	const stopDimensionSync = watch([() => currentStream.value?.nativeWidth.value, () => currentStream.value?.nativeHeight.value], ([w, h]) => {
+		if (w && w > 0) nativeWidth.value = w;
+		if (h && h > 0) nativeHeight.value = h;
+	});
+	cleanupFns.push(stopDimensionSync);
+	if (options.canvasStyle !== void 0 || options.canvasClass !== void 0) {
+		let stopCanvasListener;
+		function applyCanvasStyles(canvas) {
+			const style = toValue(options.canvasStyle);
+			const cls = toValue(options.canvasClass);
+			if (style) if (typeof style === "string") canvas.style.cssText += ";" + style;
+			else if (Array.isArray(style)) {
+				for (const s of style) if (typeof s === "string") canvas.style.cssText += ";" + s;
+				else if (s) Object.assign(canvas.style, s);
+			} else Object.assign(canvas.style, style);
+			if (cls) if (typeof cls === "string") canvas.className = cls;
+			else if (Array.isArray(cls)) canvas.className = cls.filter(Boolean).join(" ");
+			else for (const [name, active] of Object.entries(cls)) canvas.classList.toggle(name, !!active);
+		}
+		const stopContainerWatch = watch(containerElement, (container) => {
+			stopCanvasListener?.();
+			stopCanvasListener = void 0;
+			if (!container) return;
+			Array.from(container.querySelectorAll("canvas")).forEach((node) => {
+				applyCanvasStyles(node);
+			});
+			const observer = new MutationObserver((records) => {
+				for (const r of records) Array.from(r.addedNodes).forEach((added) => {
+					if (added instanceof HTMLCanvasElement) applyCanvasStyles(added);
+					else if (added instanceof HTMLElement) Array.from(added.querySelectorAll("canvas")).forEach((c) => applyCanvasStyles(c));
+				});
+			});
+			observer.observe(container, {
+				childList: true,
+				subtree: true
+			});
+			stopCanvasListener = () => observer.disconnect();
+		}, { immediate: true });
+		cleanupFns.push(() => {
+			stopContainerWatch();
+			stopCanvasListener?.();
+		});
+	}
+	if (options.videoStyle !== void 0 || options.videoClass !== void 0) {
+		const stopVideoStyleWatch = watch([
+			videoElement,
+			() => toValue(options.videoStyle),
+			() => toValue(options.videoClass)
+		], ([video, style, cls]) => {
+			if (!video) return;
+			if (style) if (typeof style === "string") video.style.cssText += ";" + style;
+			else if (Array.isArray(style)) {
+				for (const s of style) if (typeof s === "string") video.style.cssText += ";" + s;
+				else if (s) Object.assign(video.style, s);
+			} else Object.assign(video.style, style);
+			if (cls) if (typeof cls === "string") video.className = cls;
+			else if (Array.isArray(cls)) video.className = cls.filter(Boolean).join(" ");
+			else for (const [name, active] of Object.entries(cls)) video.classList.toggle(name, active);
+		}, { immediate: true });
+		cleanupFns.push(stopVideoStyleWatch);
+	}
+	const isPip = ref(false);
+	const supportsPip = computed(() => typeof document !== "undefined" && document.pictureInPictureEnabled && !!videoElement.value);
+	function onEnterPip() {
+		isPip.value = true;
+	}
+	function onLeavePip() {
+		isPip.value = false;
+	}
+	const stopPipWatch = watch(videoElement, (video, oldVideo) => {
+		if (oldVideo) {
+			oldVideo.removeEventListener("enterpictureinpicture", onEnterPip);
+			oldVideo.removeEventListener("leavepictureinpicture", onLeavePip);
+		}
+		if (video) {
+			video.addEventListener("enterpictureinpicture", onEnterPip);
+			video.addEventListener("leavepictureinpicture", onLeavePip);
+		}
+	}, { immediate: true });
+	cleanupFns.push(stopPipWatch);
+	const { isFullscreen, toggle: toggleFullscreen } = useCuiFullscreen(computed(() => fullscreenElement.value ?? containerElement.value));
+	const activityModeManager = createActivityMode({
+		initialMode: toValue(options.activityMode) ?? "always-on",
+		config: activityConfig,
+		onStreamStart: () => {
+			if (!isCameraDisabled.value) currentStream.value?.start();
+		},
+		onStreamStop: () => currentStream.value?.stop(),
+		isStreamPlaying: () => isPlaying.value
+	});
+	watch(() => toValue(options.activityMode), (newMode) => {
+		if (newMode && newMode !== activityModeManager.mode.value) activityModeManager.setMode(newMode);
+	});
+	function initializeIsolated() {
+		if (initialized.value) return;
+		const container = containerElement.value;
+		const camDevice = resolvedCameraDevice.value;
+		if (!container || !camDevice || !isConnected.value) return;
+		initialized.value = true;
+		isUsingCachedStream.value = false;
+		currentStream.value = ownedStream;
+		const video = createVideoElement();
+		videoElement.value = video;
+		streamVideoElementRef.value = video;
+		if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value) ownedStream.start();
+	}
+	function initialize() {
+		if (initialized.value) return;
+		if (isolated) {
+			initializeIsolated();
+			return;
+		}
+		const container = containerElement.value;
+		const camName = cameraName.value;
+		const camDevice = resolvedCameraDevice.value;
+		if (!container || !camName || !isConnected.value) return;
+		const cached = streamManager.acquire(camName, containerElement);
+		if (cached) {
+			initialized.value = true;
+			isUsingCachedStream.value = true;
+			currentStream.value = cached.stream;
+			if (camDevice && cached.cameraDeviceRef) cached.cameraDeviceRef.value = camDevice;
+			let video = cached.sharedVideoElement;
+			if (!video) {
+				video = createVideoElement();
+				cached.sharedVideoElement = video;
+				streamManager.updateSharedVideoElement(camName, video);
+			}
+			if (cached.mediaStream?.active) video.srcObject = cached.mediaStream;
+			if (container) cached.containerElementRef = containerElement;
+			videoElement.value = video;
+			cached.videoElementRef.value = video;
+			setupCachedStreamWatchers(cached.stream, video, camName);
+			if (shouldAutoStart() && autoStartReady.value && !isCameraDisabled.value) if (cached.stream.activeMode.value !== "mse") attachCachedStream(cached, video, camName);
+			else video.play().catch(() => {});
+		} else if (camDevice) {
+			initialized.value = true;
+			isUsingCachedStream.value = false;
+			currentStream.value = ownedStream;
+			const video = createVideoElement();
+			videoElement.value = video;
+			streamVideoElementRef.value = video;
+			streamManager.register(camName, ownedStream, streamVideoElementRef, cameraDeviceRef, containerElement, video);
+			if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value) ownedStream.start();
+			const stopPlayingWatch = watch(() => ownedStream.isPlaying.value, (playing) => {
+				if (playing && video.srcObject instanceof MediaStream) streamManager.updateMediaStream(camName, video.srcObject);
+			}, { immediate: true });
+			cleanupFns.push(stopPlayingWatch);
+			const stopStatusWatch = watch(() => ownedStream.status.value, (status) => {
+				if (status === "connected") {
+					if (video.srcObject instanceof MediaStream) streamManager.updateMediaStream(camName, video.srcObject);
+				}
+			});
+			cleanupFns.push(stopStatusWatch);
+		}
+	}
+	function attachCachedStream(cached, video, camName) {
+		if (!cached) return;
+		const stream = cached.stream;
+		const streamMode = stream.activeMode.value;
+		const streamStatus = stream.status.value;
+		const mediaStreamValid = cached.mediaStream?.active && cached.mediaStream.getTracks().some((t) => t.readyState === "live");
+		if (streamMode === "mse") {
+			streamManager.updateMediaStream(camName, null);
+			stream.restart();
+		} else if (mediaStreamValid && cached.mediaStream) {
+			video.srcObject = cached.mediaStream;
+			video.play().catch(() => {});
+		} else if (streamStatus === "idle" || streamStatus === "closed") {
+			stream.start();
+			watchForMediaStream(stream, video, camName);
+		} else if (streamStatus === "connected") {
+			stream.restart();
+			watchForMediaStream(stream, video, camName);
+		} else watchForMediaStream(stream, video, camName);
+	}
+	function watchForMediaStream(stream, video, camName) {
+		const stopWatch = watch([() => stream.isPlaying.value, () => stream.status.value], ([playing, status]) => {
+			if (status === "connected" || playing) {
+				const mediaStream = streamManager.get(camName)?.mediaStream;
+				if (mediaStream?.active && mediaStream.getTracks().some((t) => t.readyState === "live")) {
+					video.srcObject = mediaStream;
+					video.play().catch(() => {});
+					stopWatch();
+				} else if (video.srcObject instanceof MediaStream) {
+					streamManager.updateMediaStream(camName, video.srcObject);
+					video.play().catch(() => {});
+					stopWatch();
+				}
+			}
+		}, { immediate: true });
+		cleanupFns.push(stopWatch);
+	}
+	function setupCachedStreamWatchers(stream, video, camName) {
+		let wasDisconnected = stream.status.value !== "connected";
+		const stopStatusWatch = watch(() => stream.status.value, (status) => {
+			if (status === "reconnecting" || status === "connecting") wasDisconnected = true;
+			else if (status === "connected" && wasDisconnected) {
+				wasDisconnected = false;
+				setTimeout(() => {
+					if (video.srcObject instanceof MediaStream) {
+						streamManager.updateMediaStream(camName, video.srcObject);
+						video.play().catch(() => {});
+					}
+				}, 100);
+			}
+		}, { immediate: true });
+		cleanupFns.push(stopStatusWatch);
+		const stopPlayingWatch = watch(() => stream.isPlaying.value, (playing) => {
+			if (playing && stream.activeMode.value !== "mse") {
+				if (video.srcObject instanceof MediaStream) {
+					streamManager.updateMediaStream(camName, video.srcObject);
+					video.play().catch(() => {});
+				}
+			}
+		}, { immediate: true });
+		cleanupFns.push(stopPlayingWatch);
+	}
+	async function start() {
+		if (isCameraDisabled.value) return;
+		if (activityModeManager.inStandby.value) activityModeManager.resumeFromStandby();
+		else await currentStream.value?.start();
+	}
+	function stop() {
+		currentStream.value?.stop();
+	}
+	async function restart() {
+		await currentStream.value?.restart();
+	}
+	function resumeFromStandby() {
+		if (isCameraDisabled.value) return;
+		activityModeManager.resumeFromStandby();
+	}
+	async function setMode(mode) {
+		const camName = cameraName.value;
+		if (camName) streamManager.updateMediaStream(camName, null);
+		await currentStream.value?.setMode(mode);
+	}
+	async function setResolution(resolution) {
+		await currentStream.value?.setResolution(resolution);
+	}
+	async function setMicrophone(track) {
+		await currentStream.value?.setMicrophone(track);
+	}
+	function setActivityMode(mode) {
+		activityModeManager.setMode(mode);
+	}
+	function reportActivity(detected) {
+		activityModeManager.reportActivity(detected);
+	}
+	function setMuted(newMuted) {
+		currentStream.value?.setMuted(newMuted);
+		const video = videoElement.value;
+		if (video) video.muted = newMuted;
+	}
+	async function playStream() {
+		await currentStream.value?.play();
+	}
+	function pauseStream() {
+		currentStream.value?.pause();
+	}
+	function togglePip() {
+		if (document.pictureInPictureElement) document.exitPictureInPicture();
+		else if (document.pictureInPictureEnabled && videoElement.value) videoElement.value.requestPictureInPicture();
+	}
+	const renderElement = computed(() => videoElement.value);
+	function captureScreenshot() {
+		const video = videoElement.value;
+		if (!video || video.videoWidth === 0) return null;
+		const tmp = document.createElement("canvas");
+		tmp.width = video.videoWidth;
+		tmp.height = video.videoHeight;
+		tmp.getContext("2d")?.drawImage(video, 0, 0);
+		return tmp.toDataURL("image/png");
+	}
+	watch([
+		containerElement,
+		resolvedCameraDevice,
+		isConnected,
+		autoStartReady
+	], () => {
+		if (!initialized.value) initialize();
+		else if (autoStartReady.value && shouldAutoStart() && !isPlaying.value && status.value === "idle" && !isCameraDisabled.value) currentStream.value?.start();
+	}, { immediate: true });
+	watch(isCameraDisabled, (disabled, wasDisabled) => {
+		if (!initialized.value) return;
+		if (!wasDisabled && disabled) currentStream.value?.stop();
+		else if (wasDisabled && !disabled && shouldAutoStart()) currentStream.value?.restart();
+	});
+	function cleanup() {
+		if (cleanedUp.value) return;
+		cleanedUp.value = true;
+		if (startDelayTimer) {
+			clearTimeout(startDelayTimer);
+			startDelayTimer = void 0;
+		}
+		currentStream.value?.setMuted(true);
+		const video = videoElement.value;
+		if (video) video.muted = true;
+		for (const stopFn of cleanupFns) stopFn();
+		cleanupFns.length = 0;
+		if (isolated) ownedConnection?.stop();
+		else {
+			const camName = cameraName.value;
+			const video = videoElement.value;
+			if (camName && initialized.value) streamManager.release(camName, video, containerElement);
+		}
+		activityModeManager.dispose();
+	}
+	onBeforeUnmount(cleanup);
+	tryOnScopeDispose(cleanup);
+	return {
+		status,
+		isPlaying,
+		activeMode,
+		activeResolution,
+		hasAudio,
+		hasBackchannel,
+		error,
+		isReconnecting,
+		activityMode: activityModeManager.mode,
+		inStandby: activityModeManager.inStandby,
+		hasActivity: activityModeManager.hasActivity,
+		isBusy,
+		hasSound,
+		hasIntercom,
+		videoElement,
+		containerElement,
+		fullscreenElement,
+		renderElement,
+		stream: currentStream,
+		muted,
+		paused,
+		nativeWidth,
+		nativeHeight,
+		isPip,
+		supportsPip,
+		isFullscreen,
+		start,
+		stop,
+		restart,
+		resumeFromStandby,
+		setMode,
+		setResolution,
+		setMicrophone,
+		setActivityMode,
+		reportActivity,
+		setMuted,
+		play: playStream,
+		pause: pauseStream,
+		togglePip,
+		isCameraDisabled,
+		toggleFullscreen,
+		captureScreenshot
+	};
+}
+//#endregion
+//#region src/composables/useCoreManager.ts
+function useCoreManager() {
+	const ctx = useCameraUi();
+	const namespaces = NamespaceManager.coreManagerNamespaces();
+	const proxy = (rpc) => rpc.createProxy(namespaces.coreManagerRpc);
+	return {
+		getFFmpegPath: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getFFmpegPath()),
+		getServerAddresses: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getServerAddresses()),
+		getPluginsByInterface: (interfaceName) => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getPluginsByInterface(interfaceName))
+	};
+}
+//#endregion
+//#region src/composables/useOAuth.ts
+var POLL_ACTIVE_MS = 1500;
+var POLL_IDLE_MS = 3e4;
+var oauthStates = /* @__PURE__ */ new Map();
+function clearOAuthCache() {
+	oauthStates.clear();
+}
+function createOAuthState(pluginName) {
+	const ctx = useCameraUi();
+	const state = ref({ status: "disconnected" });
+	const metadata = ref(null);
+	let timer = null;
+	const call = (fn) => rpcCall(ctx.rpc, async (rpc) => {
+		const id = await resolvePluginId(ctx.rpc, pluginName);
+		if (!id) throw new Error(`Plugin "${pluginName}" not found`);
+		return fn(rpc.createProxy(NamespaceManager.pluginNamespaces(id).pluginChildRpc));
+	});
+	async function refresh() {
+		state.value = await call((proxy) => proxy.getOAuthState());
+		if (!metadata.value) metadata.value = await call((proxy) => proxy.getOAuthMetadata());
+	}
+	function startPolling(intervalMs) {
+		if (timer) clearInterval(timer);
+		timer = setInterval(() => {
+			refresh().catch(() => void 0);
+		}, intervalMs);
+	}
+	watch(() => state.value.status, (status) => {
+		startPolling(status === "awaiting_user" || status === "polling" ? POLL_ACTIVE_MS : POLL_IDLE_MS);
+	}, { immediate: true });
+	refresh().catch(() => void 0);
+	return {
+		state,
+		metadata,
+		call,
+		refresh
+	};
+}
+function useOAuth(pluginName) {
+	if (!oauthStates.has(pluginName)) oauthStates.set(pluginName, createOAuthState(pluginName));
+	const { state, metadata, call, refresh } = oauthStates.get(pluginName);
+	async function startDeviceFlow(scope) {
+		state.value = await call((proxy) => proxy.startDeviceFlow(scope));
+	}
+	async function startAuthCodeFlow(scope) {
+		state.value = await call((proxy) => proxy.startAuthCodeFlow(scope));
+	}
+	async function cancel() {
+		if (state.value.status === "awaiting_user" || state.value.status === "polling") await call((proxy) => proxy.cancelDeviceFlow?.() ?? proxy.cancelAuthCodeFlow?.() ?? Promise.resolve());
+		await refresh();
+	}
+	async function disconnect() {
+		await call((proxy) => proxy.disconnect());
+		await refresh();
+	}
+	return {
+		state,
+		metadata,
+		startDeviceFlow,
+		startAuthCodeFlow,
+		cancel,
+		disconnect,
+		refresh
+	};
+}
+//#endregion
+//#region src/composables/useTerminal.ts
+function useTerminal() {
+	const cameraUi = useCameraUi();
+	const { rpc, isConnected: isClientConnected } = cameraUi;
+	const namespaces = NamespaceManager.terminalManagerNamespaces();
+	const sessionId = shallowRef();
+	const isConnected = ref(false);
+	const isConnecting = ref(false);
+	const error = ref();
+	const dimensions = ref({
+		cols: 80,
+		rows: 24
+	});
+	let streamAbortController;
+	let currentOptions;
+	let streamGen = 0;
+	const proxy = (r) => r.createProxy(namespaces.terminalManagerRpc);
+	async function connect(options) {
+		if (isConnecting.value || isConnected.value) return;
+		isConnecting.value = true;
+		error.value = void 0;
+		currentOptions = options;
+		try {
+			const session = await rpcCall(rpc, (r) => proxy(r).createSession({
+				cols: options?.cols ?? 80,
+				rows: options?.rows ?? 24,
+				cwd: options?.cwd,
+				shell: options?.shell,
+				env: options?.env
+			}));
+			sessionId.value = session.sessionId;
+			dimensions.value = session.dimensions;
+			isConnected.value = true;
+			streamAbortController = new AbortController();
+			const gen = ++streamGen;
+			consumeOutputStream(session.sessionId, options, gen);
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			options?.onError?.(error.value);
+		} finally {
+			isConnecting.value = false;
+		}
+	}
+	async function consumeOutputStream(sid, options, gen) {
+		try {
+			const current = rpc.value;
+			if (!current) return;
+			for await (const chunk of proxy(current).generateOutput(sid)) {
+				if (gen !== streamGen || streamAbortController?.signal.aborted) break;
+				options?.onData?.(chunk);
+			}
+		} catch (err) {
+			if (gen === streamGen && !streamAbortController?.signal.aborted) {
+				error.value = err instanceof Error ? err : new Error(String(err));
+				options?.onError?.(error.value);
+			}
+		} finally {
+			if (gen === streamGen && !streamAbortController?.signal.aborted) {
+				isConnected.value = false;
+				options?.onClose?.();
+			}
+		}
+	}
+	async function write(data) {
+		if (!sessionId.value || !isConnected.value) return;
+		try {
+			await rpcCall(rpc, (r) => proxy(r).writeInput(sessionId.value, data));
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			currentOptions?.onError?.(error.value);
+		}
+	}
+	async function resize(dims) {
+		if (!sessionId.value || !isConnected.value) return;
+		try {
+			await rpcCall(rpc, (r) => proxy(r).resize(sessionId.value, dims));
+			dimensions.value = dims;
+		} catch (err) {
+			error.value = err instanceof Error ? err : new Error(String(err));
+			currentOptions?.onError?.(error.value);
+		}
+	}
+	async function close() {
+		streamAbortController?.abort();
+		streamGen++;
+		if (sessionId.value) try {
+			await rpcCall(rpc, (r) => proxy(r).closeSession(sessionId.value), {
+				awaitConnect: false,
+				maxRetries: 0
+			});
+		} catch {}
+		sessionId.value = void 0;
+		isConnected.value = false;
+		currentOptions = void 0;
+	}
+	function handleReconnected() {
+		if (!sessionId.value && !isConnected.value) return;
+		const savedOptions = currentOptions;
+		streamAbortController?.abort();
+		streamGen++;
+		sessionId.value = void 0;
+		isConnected.value = false;
+		currentOptions = void 0;
+		savedOptions?.onClose?.();
+		if (savedOptions) connect(savedOptions);
+	}
+	cameraUi.on("reconnected", handleReconnected);
+	tryOnScopeDispose(() => {
+		cameraUi.off("reconnected", handleReconnected);
+		close();
+	});
+	return {
+		sessionId: readonly(sessionId),
+		isConnected: readonly(isConnected),
+		isConnecting: readonly(isConnecting),
+		isClientConnected: readonly(isClientConnected),
+		error: readonly(error),
+		dimensions: readonly(dimensions),
+		connect,
+		write,
+		resize,
+		close
+	};
+}
+//#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 };