@camera.ui/browser 0.0.203 → 0.1.0

package/dist/index.js

@@ -1,7 +1,12 @@
 import { Logger } from "@camera.ui/logger";
-import { computed, effectScope, inject, markRaw, onBeforeUnmount, reactive, readonly, ref, shallowRef, toValue, watch } from "vue";
+import { computed, effectScope, inject, markRaw, onBeforeUnmount, readonly, ref, shallowReactive, shallowRef, toValue, watch } from "vue";
 import { tryOnScopeDispose, useTimeoutFn, whenever } from "@vueuse/core";
 import { SensorType } from "@camera.ui/sdk";
+import { isNoRespondersError } from "@camera.ui/rpc";
+import { classifyClose } from "@camera.ui/transport";
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+//#endregion
 //#region src/utils/createDebouncedCache.ts
 function createDebouncedCache(options = {}) {
 	const { releaseDelay = 1e3, onRelease } = options;
@@ -38,11 +43,12 @@ function createDebouncedCache(options = {}) {
 		});
 		return value;
 	}
-	function release(key) {
+	function release(key, value) {
 		const cached = cache.get(key);
-		if (!cached) return;
+		if (!cached || cached.refCount <= 0) return;
+		if (value !== void 0 && cached.value !== value) return;
 		cached.refCount--;
-		if (cached.refCount <= 0) {
+		if (cached.refCount === 0) {
 			const timer = setTimeout(() => {
 				const stillCached = cache.get(key);
 				if (stillCached && stillCached.refCount <= 0) doRelease(key);
@@ -83,6 +89,34 @@ function createDebouncedCache(options = {}) {
 	};
 }
 //#endregion
+//#region src/utils/createRetryTimer.ts
+var RETRY_MIN_MS = 1e3;
+var RETRY_MAX_MS$1 = 3e4;
+function createRetryTimer() {
+	let timer;
+	let delay = RETRY_MIN_MS;
+	function schedule(fn) {
+		if (timer) return;
+		timer = setTimeout(() => {
+			timer = void 0;
+			fn();
+		}, delay);
+		delay = Math.min(delay * 2, RETRY_MAX_MS$1);
+	}
+	function cancel() {
+		clearTimeout(timer);
+		timer = void 0;
+	}
+	function reset() {
+		delay = RETRY_MIN_MS;
+	}
+	return {
+		schedule,
+		cancel,
+		reset
+	};
+}
+//#endregion
 //#region src/composables/useCameraUi.ts
 function useCameraUi() {
 	const context = inject(CAMERA_UI_INJECTION_KEY);
@@ -91,6 +125,9 @@ function useCameraUi() {
 }
 //#endregion
 //#region ../../externals/camera.ui/server/src/utils/camera.ts
+var import___vite_browser_external = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+})))();
 function normalizeCameraName(name) {
 	return name.replace(/ /g, "_").toLowerCase();
 }
@@ -136,6 +173,7 @@ var NamespaceManager = class {
 	static cameraNamespaces(cameraId) {
 		return {
 			cameraSubject: `camera.${cameraId}.subscriber`,
+			cameraStateSubject: `camera.${cameraId}.state`,
 			cameraControllerRpc: `camera.${cameraId}.controller.rpc`
 		};
 	}
@@ -165,7 +203,10 @@ var NamespaceManager = class {
 		return { sensorWriteSubject: `camera.${cameraId}.sensors.writes` };
 	}
 	static sensorEventNamespaces(sensorId) {
-		return { sensorSubject: `sensor.${sensorId}.subject` };
+		return {
+			sensorSubject: `sensor.${sensorId}.subject`,
+			sensorStateSubject: `sensor.${sensorId}.state`
+		};
 	}
 	static sensorProviderNamespaces(pluginId, sensorId) {
 		return { sensorRpc: `plugin.${pluginId}.sensor.${sensorId}.rpc` };
@@ -191,46 +232,81 @@ var NamespaceManager = class {
 	static workerAgentRpc(agentId) {
 		return `worker.${agentId}.rpc`;
 	}
-	static workerManagerRpc() {
+	static workerManagerRpc(agentId) {
+		return `workers.${agentId}.manager.rpc`;
+	}
+	static sharedWorkerManagerRpc() {
 		return "workers.manager.rpc";
 	}
 	static workerSync(agentId) {
 		return `worker.${agentId}.sync`;
 	}
-	static workerDisconnect() {
+	static workerLinkSubject(agentId) {
+		return `worker.${agentId}.link`;
+	}
+	static workerDisconnect(agentId) {
+		return `workers.${agentId}.disconnect`;
+	}
+	static sharedWorkerDisconnect() {
 		return "workers.disconnect";
 	}
-	static workerLogs() {
+	static workerLogs(agentId) {
+		return `workers.${agentId}.logs`;
+	}
+	static sharedWorkerLogs() {
 		return "workers.logs";
 	}
+	static workerConnId(agentId, secret) {
+		return (0, import___vite_browser_external.createHmac)("sha256", secret).update(agentId).digest("hex").slice(0, 32);
+	}
 };
 //#endregion
 //#region src/composables/useRpc.ts
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
+var LINK_SETTLE_MS = 3e4;
+var LOCAL_NOT_CONNECTED = /* @__PURE__ */ new Set(["Not connected", "rpc: not connected"]);
+var linkRestoredAt = /* @__PURE__ */ new WeakMap();
+function markLinkRestored(rpcRef) {
+	linkRestoredAt.set(rpcRef, Date.now());
+}
+function isLinkSettling(rpcRef) {
+	return Date.now() - (linkRestoredAt.get(rpcRef) ?? -Infinity) < LINK_SETTLE_MS;
+}
+function isLocalNoResponders(err) {
+	return err instanceof Error && err.code === void 0 && err.name === "NoResponders";
+}
 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 shouldRetry = options.shouldRetry;
+	const retryOnTimeout = options.retryOnTimeout ?? false;
 	const signal = options.signal;
+	let linkChanges = 0;
+	const stopLinkWatch = watchDetached(rpcRef, () => linkChanges++, { flush: "sync" });
 	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$1(retryDelayMs(attempt), signal);
+	try {
+		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);
+			}
+			const changesAtStart = linkChanges;
+			try {
+				return await fn(rpc);
+			} catch (err) {
+				lastError = err;
+				if (attempt >= maxRetries) throw err;
+				if (!(shouldRetry ? shouldRetry(err, attempt) : isLinkFailure(err, rpc, rpcRef, linkChanges !== changesAtStart, retryOnTimeout))) throw err;
+				await sleep(retryDelayMs(attempt), signal);
+			}
 		}
+	} finally {
+		stopLinkWatch();
 	}
 	throw lastError ?? /* @__PURE__ */ new Error("rpc: max retries exceeded");
 }
@@ -288,11 +364,13 @@ function useRpcSubscription(subscribeFn, options = {}) {
 	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
 	const retryDelayMs = options.retryDelayMs ?? defaultRetryDelayMs;
 	let unsubscribe;
+	let boundClient;
 	let pending = false;
 	let disposed = false;
 	async function bind(rpc) {
 		if (pending || disposed) return;
 		pending = true;
+		boundClient = rpc;
 		try {
 			if (unsubscribe) {
 				try {
@@ -301,9 +379,14 @@ function useRpcSubscription(subscribeFn, options = {}) {
 				unsubscribe = void 0;
 			}
 			for (let attempt = 0; attempt <= maxRetries; attempt++) {
-				if (disposed) return;
+				if (disposed || boundClient !== rpc) return;
 				try {
-					unsubscribe = await subscribeFn(rpc);
+					const off = await subscribeFn(rpc);
+					if (disposed || boundClient !== rpc) {
+						off();
+						return;
+					}
+					unsubscribe = off;
 					isActive.value = true;
 					return;
 				} catch (err) {
@@ -312,16 +395,17 @@ function useRpcSubscription(subscribeFn, options = {}) {
 						options.onError?.(err);
 						return;
 					}
-					await sleep$1(retryDelayMs(attempt));
+					await sleep(retryDelayMs(attempt));
 				}
 			}
 		} finally {
 			pending = false;
 			const current = ctx.rpc.value;
-			if (!disposed && current && current !== rpc) bind(current);
+			if (!disposed && ctx.isConnected.value && current && current !== boundClient) bind(current);
 		}
 	}
 	function unbind() {
+		boundClient = void 0;
 		if (unsubscribe) {
 			try {
 				unsubscribe();
@@ -335,9 +419,9 @@ function useRpcSubscription(subscribeFn, options = {}) {
 		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();
+	const stopWatch = watch([ctx.rpc, ctx.isConnected], ([rpc, connected]) => {
+		if (!connected) unbind();
+		else if (rpc && (rpc !== boundClient || !isActive.value)) bind(rpc);
 	});
 	tryOnScopeDispose(() => {
 		disposed = true;
@@ -352,18 +436,19 @@ function useRpcSubscription(subscribeFn, options = {}) {
 function defaultRetryDelayMs(attempt) {
 	return Math.min(100 * Math.pow(2, attempt), 1e3);
 }
-function defaultShouldRetry(err) {
+function isLinkFailure(err, rpc, rpcRef, linkChanged, retryOnTimeout) {
+	if (rpcRef.value !== rpc) return true;
+	if (rpc.isConnected === false && rpc.isClosed === false) return true;
 	if (!(err instanceof Error)) return false;
 	const code = err.code;
-	if (code === "TIMEOUT" || code === "CONNECTION_CLOSED") return true;
-	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("timed out") || msg.includes("timeout")) return true;
-	return false;
+	if (code === void 0 && LOCAL_NOT_CONNECTED.has(err.message)) return true;
+	if (isLocalNoResponders(err) && isLinkSettling(rpcRef)) return true;
+	return code === "TIMEOUT" && (retryOnTimeout || linkChanged);
+}
+function watchDetached(source, cb, options) {
+	const scope = effectScope(true);
+	scope.run(() => watch(source, cb, options));
+	return () => scope.stop();
 }
 async function waitForRpc(rpcRef, timeoutMs, signal) {
 	if (rpcRef.value) return rpcRef.value;
@@ -379,7 +464,7 @@ async function waitForRpc(rpcRef, timeoutMs, signal) {
 			reject(makeAbortError());
 		};
 		signal?.addEventListener("abort", onAbort, { once: true });
-		const stopWatch = watch(rpcRef, (next) => {
+		const stopWatch = watchDetached(rpcRef, (next) => {
 			if (next) {
 				clearTimeout(timer);
 				stopWatch();
@@ -389,7 +474,7 @@ async function waitForRpc(rpcRef, timeoutMs, signal) {
 		});
 	});
 }
-async function sleep$1(ms, signal) {
+async function sleep(ms, signal) {
 	return new Promise((resolve, reject) => {
 		if (signal?.aborted) {
 			reject(makeAbortError());
@@ -413,10 +498,69 @@ function makeAbortError() {
 	return err;
 }
 //#endregion
+//#region src/composables/bulkLane.ts
+var PROBE_TIMEOUT_MS = 2e3;
+var RECHECK_AFTER_MS = 6e4;
+var deadMarks = /* @__PURE__ */ new WeakMap();
+var runningProbes = /* @__PURE__ */ new WeakMap();
+function liveBulkClient(lane) {
+	const client = lane?.value;
+	if (!lane || !client) return void 0;
+	const mark = deadMarks.get(lane);
+	if (!mark || mark.client !== client) return client;
+	if (performance.now() - mark.since >= RECHECK_AFTER_MS && !runningProbes.has(client)) recheck(lane, mark);
+}
+function markBulkDead(lane, client) {
+	if (lane.value !== client || deadMarks.has(lane)) return;
+	const stop = watchDetached(lane, () => clearMark(lane), { flush: "sync" });
+	deadMarks.set(lane, {
+		client,
+		since: performance.now(),
+		stop
+	});
+}
+function noticeBulkTimeout(lane, client) {
+	if (lane.value !== client || deadMarks.has(lane)) return;
+	probeBulkClient(client).then((alive) => {
+		if (!alive) markBulkDead(lane, client);
+	});
+}
+function probeBulkClient(client) {
+	let alive = runningProbes.get(client);
+	if (!alive) {
+		alive = answersPing(client);
+		runningProbes.set(client, alive);
+		alive.then(() => runningProbes.delete(client));
+	}
+	return alive;
+}
+async function answersPing(client) {
+	try {
+		await client.flush(PROBE_TIMEOUT_MS);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function recheck(lane, mark) {
+	probeBulkClient(mark.client).then((alive) => {
+		if (deadMarks.get(lane) !== mark) return;
+		if (alive) clearMark(lane);
+		else mark.since = performance.now();
+	});
+}
+function clearMark(lane) {
+	deadMarks.get(lane)?.stop();
+	deadMarks.delete(lane);
+}
+//#endregion
 //#region src/composables/useSnapshot.ts
 var REVOKE_DELAY_MS = 5e3;
+var SERVER_CLOCK_STEP_MS = 6e4;
 var snapshotCache = /* @__PURE__ */ new Map();
 var timestampCache = /* @__PURE__ */ new Map();
+var takenAtCache = /* @__PURE__ */ new Map();
+var stampCache = /* @__PURE__ */ new Map();
 var urlCache = /* @__PURE__ */ new Map();
 var subscribers = /* @__PURE__ */ new Map();
 var pendingLoads$2 = /* @__PURE__ */ new Map();
@@ -432,16 +576,16 @@ function fetchSnapshotShared(deviceManager, id, forceFresh = false) {
 			if (!device) return void 0;
 			return await device.fetchSnapshot(void 0, forceFresh ? true : void 0) ?? void 0;
 		} finally {
-			if (device) releaseCameraDevice(id);
+			if (device) releaseCameraDevice(device);
 		}
 	})().finally(() => pendingLoads$2.delete(id));
 	pendingLoads$2.set(id, promise);
 	return promise;
 }
-var reconnectHooked = false;
+var hookedContexts = /* @__PURE__ */ new WeakSet();
 function hookReconnectRefresh(cameraUi, deviceManager) {
-	if (reconnectHooked) return;
-	reconnectHooked = true;
+	if (hookedContexts.has(cameraUi)) return;
+	hookedContexts.add(cameraUi);
 	cameraUi.on("reconnected", () => {
 		setTimeout(() => {
 			let delay = 0;
@@ -460,7 +604,19 @@ function hookReconnectRefresh(cameraUi, deviceManager) {
 function deferRevoke(url) {
 	setTimeout(() => URL.revokeObjectURL(url), REVOKE_DELAY_MS);
 }
-function setSnapshot(cameraId, data, fetchedAt) {
+function isOlderThanHeld(cameraId, takenAt, stamp) {
+	const held = stampCache.get(cameraId);
+	if (stamp && held) {
+		const behind = held.fetchedAt - stamp.fetchedAt;
+		return behind > 0 && behind <= SERVER_CLOCK_STEP_MS;
+	}
+	return takenAt !== void 0 && takenAt < (takenAtCache.get(cameraId) ?? -Infinity);
+}
+function setSnapshot(cameraId, data, fetchedAt, takenAt, stamp) {
+	if (isOlderThanHeld(cameraId, takenAt, stamp)) return;
+	takenAtCache.set(cameraId, takenAt ?? Date.now());
+	if (stamp) stampCache.set(cameraId, stamp);
+	else stampCache.delete(cameraId);
 	if (snapshotCache.get(cameraId) !== data) {
 		const oldUrl = urlCache.get(cameraId);
 		if (oldUrl) {
@@ -475,6 +631,10 @@ function setSnapshot(cameraId, data, fetchedAt) {
 function getSnapshot(cameraId) {
 	return snapshotCache.get(cameraId);
 }
+function getSnapshotStamp(cameraId, sourceId) {
+	const stamp = stampCache.get(cameraId);
+	return stamp?.sourceId === sourceId ? stamp.fetchedAt : void 0;
+}
 function subscribeSnapshot(cameraId, cb) {
 	if (!subscribers.has(cameraId)) subscribers.set(cameraId, /* @__PURE__ */ new Set());
 	subscribers.get(cameraId).add(cb);
@@ -497,6 +657,8 @@ function clearSnapshotCache() {
 	urlCache.clear();
 	snapshotCache.clear();
 	timestampCache.clear();
+	takenAtCache.clear();
+	stampCache.clear();
 }
 function useSnapshot(cameraIdOrName) {
 	const cameraUi = useCameraUi();
@@ -529,27 +691,52 @@ function useSnapshot(cameraIdOrName) {
 	}
 	let unsubscribe;
 	let heldDeviceId;
+	let heldDevice;
 	let pendingHoldId;
+	const holdRetry = createRetryTimer();
+	let disposed = false;
+	function currentId() {
+		const idOrName = toValue(cameraIdOrName);
+		return typeof idOrName === "string" ? idOrName : idOrName._id;
+	}
 	async function holdDevice(id) {
 		if (heldDeviceId === id || pendingHoldId === id) return;
 		pendingHoldId = id;
 		try {
-			if (!await acquireCameraDevice(deviceManager, id)) return;
-			const idOrName = toValue(cameraIdOrName);
-			if ((typeof idOrName === "string" ? idOrName : idOrName._id) !== id || heldDeviceId === id) {
-				releaseCameraDevice(id);
+			const device = await acquireCameraDevice(deviceManager, id);
+			if (!device) return;
+			if (disposed || currentId() !== id || heldDeviceId === id) {
+				releaseCameraDevice(device);
 				return;
 			}
 			releaseHeldDevice();
 			heldDeviceId = id;
-		} catch {} finally {
+			heldDevice = device;
+			cancelHoldRetry();
+		} catch {
+			if (currentId() === id) scheduleHoldRetry(id);
+		} finally {
 			pendingHoldId = void 0;
 		}
 	}
+	function scheduleHoldRetry(id) {
+		if (disposed) return;
+		holdRetry.schedule(() => {
+			if (!isConnected.value || currentId() !== id || isCameraDisabled(toValue(cameraIdOrName))) return;
+			holdDevice(id).then(() => {
+				if (heldDeviceId === id) return loadSnapshot(id);
+			});
+		});
+	}
+	function cancelHoldRetry() {
+		holdRetry.cancel();
+		holdRetry.reset();
+	}
 	function releaseHeldDevice() {
 		if (heldDeviceId) {
-			releaseCameraDevice(heldDeviceId);
+			if (heldDevice) releaseCameraDevice(heldDevice);
 			heldDeviceId = void 0;
+			heldDevice = void 0;
 		}
 	}
 	function showCached(id) {
@@ -565,7 +752,7 @@ function useSnapshot(cameraIdOrName) {
 		_isLoading.value = true;
 		try {
 			const result = await fetchSnapshotShared(deviceManager, id);
-			if (result) snapshot.value = result;
+			if (result) snapshot.value = snapshotCache.get(id) ?? result;
 		} catch {} finally {
 			_isLoading.value = false;
 			initialLoadDone.value = true;
@@ -582,7 +769,7 @@ function useSnapshot(cameraIdOrName) {
 		_isLoading.value = true;
 		try {
 			const result = await fetchSnapshotShared(deviceManager, id, true);
-			if (result) snapshot.value = result;
+			if (result) snapshot.value = snapshotCache.get(id) ?? result;
 		} catch {} finally {
 			_isLoading.value = false;
 			initialLoadDone.value = true;
@@ -593,10 +780,12 @@ function useSnapshot(cameraIdOrName) {
 		() => toValue(cameraIdOrName),
 		() => isCameraDisabled(toValue(cameraIdOrName))
 	], async ([connected, cameraIdName, disabled]) => {
+		cancelHoldRetry();
 		unsubscribe?.();
 		unsubscribe = void 0;
 		const id = typeof cameraIdName === "string" ? cameraIdName : cameraIdName._id;
 		if (connected && id && !disabled) {
+			if (typeof cameraIdName === "object") rememberCameraName(cameraIdName.name, id);
 			unsubscribe = subscribe(id);
 			showCached(id);
 			await holdDevice(id);
@@ -611,6 +800,8 @@ function useSnapshot(cameraIdOrName) {
 		}
 	}, { immediate: true });
 	tryOnScopeDispose(() => {
+		disposed = true;
+		cancelHoldRetry();
 		unsubscribe?.();
 		releaseHeldDevice();
 	});
@@ -624,13 +815,25 @@ function useSnapshot(cameraIdOrName) {
 }
 //#endregion
 //#region src/composables/useCamera.ts
+var NOT_MODIFIED = "not-modified";
+var snapshotWithMetaSupport = /* @__PURE__ */ new WeakMap();
+var sensorEventFanouts = /* @__PURE__ */ new WeakMap();
 async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 	const cameraNamespaces = NamespaceManager.cameraNamespaces(initialCamera._id);
-	const sensorNamespaces = NamespaceManager.sensorRegistryNamespaces();
 	const ctx = "rpc" in rpcOrContext && "value" in rpcOrContext.rpc ? rpcOrContext : void 0;
 	const rpcRef = ctx ? ctx.rpc : shallowRef(rpcOrContext);
+	const bulkRpc = ctx?.bulkRpc;
 	let closeSubscription;
 	let closeSensorSubscription;
+	let closed = false;
+	let reconnecting;
+	let reconnectAgain = false;
+	const reconnectRetry = createRetryTimer();
+	let statesSeq = 0;
+	let appliedStatesSeq = 0;
+	let statesRun;
+	let statesNext;
+	let sensorRefreshQueued = false;
 	const camera = shallowRef(initialCamera);
 	const connected = ref(false);
 	const frameWorkerConnected = ref(false);
@@ -674,38 +877,130 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 	const hasPtz = computed(() => existingSensorTypes.value.has(SensorType.PTZ));
 	async function fetchSnapshot(sourceId, forceNew) {
 		snapshotLoading.value = true;
+		const requestedAt = Date.now();
 		try {
-			try {
-				const result = await rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).snapshotWithMeta(sourceId, forceNew));
-				if (result && result.data.byteLength > 0) {
-					setSnapshot(initialCamera._id, result.data, Date.now() - result.ageMs);
-					return result.data;
-				}
-				return;
-			} catch {
-				const result = await rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).snapshot(sourceId, forceNew));
-				if (result && result.byteLength > 0) {
-					setSnapshot(initialCamera._id, result, forceNew ? Date.now() : void 0);
-					return result;
-				}
+			const result = await requestSnapshot(sourceId, forceNew);
+			if (result === NOT_MODIFIED) return getSnapshot(initialCamera._id);
+			if (result && result.data.byteLength > 0) {
+				const stamp = result.stamp === void 0 ? void 0 : {
+					sourceId,
+					fetchedAt: result.stamp
+				};
+				setSnapshot(initialCamera._id, result.data, result.fetchedAt, result.fetchedAt ?? requestedAt, stamp);
+				return result.data;
 			}
+			return;
 		} finally {
 			snapshotLoading.value = false;
 		}
 	}
+	async function requestSnapshot(sourceId, forceNew) {
+		let lastClient;
+		let bulkDead = false;
+		try {
+			return await rpcCall(rpcRef, async (client) => {
+				lastClient = snapshotClient(client, bulkDead);
+				try {
+					return await snapshotFrom(lastClient, sourceId, forceNew);
+				} catch (err) {
+					if (!bulkRpc || lastClient === client || err.code !== "TIMEOUT" || await probeBulkClient(lastClient)) throw err;
+					bulkDead = true;
+					markBulkDead(bulkRpc, lastClient);
+					lastClient = client;
+					return snapshotFrom(client, sourceId, forceNew);
+				}
+			}, { retryOnTimeout: !forceNew });
+		} catch (err) {
+			if (err.code !== "TIMEOUT" || !lastClient || snapshotWithMetaSupport.has(lastClient)) throw err;
+			return rpcCall(rpcRef, (client) => legacySnapshotFrom(snapshotClient(client, bulkDead), sourceId, forceNew));
+		}
+	}
+	function snapshotClient(client, mainOnly = false) {
+		return mainOnly ? client : liveBulkClient(bulkRpc) ?? client;
+	}
+	async function snapshotFrom(client, sourceId, forceNew) {
+		const supported = snapshotWithMetaSupport.get(client);
+		if (supported === false) return legacySnapshotFrom(client, sourceId, forceNew);
+		try {
+			const controller = client.createProxy(cameraNamespaces.cameraControllerRpc);
+			const known = forceNew ? void 0 : getSnapshotStamp(initialCamera._id, sourceId);
+			const result = known === void 0 ? await controller.snapshotWithMeta(sourceId, forceNew) : await controller.snapshotWithMeta(sourceId, forceNew, known);
+			snapshotWithMetaSupport.set(client, true);
+			if (result?.notModified) return NOT_MODIFIED;
+			return result?.data ? {
+				data: result.data,
+				fetchedAt: Date.now() - (result.ageMs ?? 0),
+				stamp: result.fetchedAt
+			} : void 0;
+		} catch (err) {
+			if (err.code === "METHOD_NOT_FOUND") {
+				snapshotWithMetaSupport.set(client, false);
+				return legacySnapshotFrom(client, sourceId, forceNew);
+			}
+			if (supported || !isLocalNoResponders(err)) throw err;
+		}
+		const result = await legacySnapshotFrom(client, sourceId, forceNew);
+		if (!isLinkSettling(rpcRef)) snapshotWithMetaSupport.set(client, false);
+		return result;
+	}
+	async function legacySnapshotFrom(client, sourceId, forceNew) {
+		const data = await client.createProxy(cameraNamespaces.cameraControllerRpc).snapshot(sourceId, forceNew);
+		return data ? {
+			data,
+			fetchedAt: forceNew ? Date.now() : void 0
+		} : void 0;
+	}
 	async function probeStream(sourceId, probeConfig, refresh = false) {
-		return rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).probeStream(sourceId, probeConfig, refresh));
+		return rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).probeStream(sourceId, probeConfig, refresh), { retryOnTimeout: !refresh });
 	}
 	async function streamUrl(sourceId) {
 		return rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).streamUrl(sourceId));
 	}
-	async function refreshStates() {
+	function refreshStates() {
+		statesNext = void 0;
+		return startStatesRun();
+	}
+	function refreshStatesCoalesced() {
+		if (statesNext) return statesNext;
+		if (!statesRun) return startStatesRun();
+		const queuedAt = statesSeq;
+		statesNext = statesRun.catch(() => {}).then(() => {
+			if (statesSeq !== queuedAt) return statesRun;
+			statesNext = void 0;
+			return startStatesRun();
+		});
+		return statesNext;
+	}
+	function startStatesRun() {
+		const run = fetchStates(++statesSeq).finally(() => {
+			if (statesRun === run) statesRun = void 0;
+		});
+		statesRun = run;
+		return run;
+	}
+	async function fetchStates(seq) {
 		const response = await rpcCall(rpcRef, (client) => client.createProxy(cameraNamespaces.cameraControllerRpc).refreshStates());
+		if (seq < appliedStatesSeq) return;
+		appliedStatesSeq = seq;
 		camera.value = response.camera;
 		connected.value = response.cameraState;
 		frameWorkerConnected.value = response.frameWorkerState;
 		sensorStates.value = response.sensorStates;
 	}
+	function refreshForSensors() {
+		if (sensorRefreshQueued || closed) return;
+		sensorRefreshQueued = true;
+		queueMicrotask(() => {
+			sensorRefreshQueued = false;
+			if (!closed) refreshStatesCoalesced().catch(() => {});
+		});
+	}
+	function dropSensorState(sensorId) {
+		if (sensorStates.value[sensorId] === void 0) return;
+		const newStates = { ...sensorStates.value };
+		delete newStates[sensorId];
+		sensorStates.value = newStates;
+	}
 	async function handleCameraEvent(event) {
 		switch (event.type) {
 			case "removed":
@@ -720,7 +1015,14 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 			case "frameWorkerState":
 				frameWorkerConnected.value = event.data;
 				break;
-			case "snapshot:updated": setSnapshot(initialCamera._id, event.data.snapshot, event.data.fetchedAt);
+			case "snapshot:updated": {
+				const { sourceId, snapshot: data, fetchedAt } = event.data;
+				setSnapshot(initialCamera._id, data, fetchedAt, void 0, sourceId && fetchedAt !== void 0 ? {
+					sourceId,
+					fetchedAt
+				} : void 0);
+				break;
+			}
 		}
 	}
 	function handleSensorEvent(event) {
@@ -732,38 +1034,72 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 				...sensorStates.value,
 				[addedEvent.sensor.id]: addedEvent.state
 			};
-		} else if (event.type === "sensor:deleted") {
-			const deletedEvent = event.data;
-			const newStates = { ...sensorStates.value };
-			delete newStates[deletedEvent.sensorId];
-			sensorStates.value = newStates;
-		} else if (event.type === "sensor:connected:changed") {
+		} else if (event.type === "sensor:deleted") dropSensorState(event.data.sensorId);
+		else if (event.type === "sensor:connected:changed") {
 			const connectedEvent = event.data;
-			if (connectedEvent.connected) refreshStates().catch(() => {});
-			else {
-				const newStates = { ...sensorStates.value };
-				delete newStates[connectedEvent.sensorId];
-				sensorStates.value = newStates;
-			}
+			if (connectedEvent.connected) {
+				if (connectedEvent.assignedCameraIds && !connectedEvent.assignedCameraIds.includes(initialCamera._id)) return;
+				refreshForSensors();
+			} else dropSensorState(connectedEvent.sensorId);
 		} else if (event.type === "sensor:assignment:changed") {
 			const assignmentEvent = event.data;
 			if (assignmentEvent.cameraId !== initialCamera._id) return;
-			if (assignmentEvent.assigned) refreshStates().catch(() => {});
-			else {
-				const newStates = { ...sensorStates.value };
-				delete newStates[assignmentEvent.sensorId];
-				sensorStates.value = newStates;
-			}
+			if (assignmentEvent.assigned) refreshForSensors();
+			else dropSensorState(assignmentEvent.sensorId);
 		}
 	}
 	async function init() {
 		closeSubscription?.();
+		closeSubscription = void 0;
 		closeSensorSubscription?.();
-		closeSubscription = await rpcCall(rpcRef, (client) => client.subscribe(cameraNamespaces.cameraSubject, handleCameraEvent));
-		closeSensorSubscription = await rpcCall(rpcRef, (client) => client.subscribe(sensorNamespaces.sensorsSubject, handleSensorEvent));
+		closeSensorSubscription = void 0;
+		const cameraSubscription = await rpcCall(rpcRef, (client) => client.subscribe(cameraNamespaces.cameraSubject, handleCameraEvent));
+		if (closed) {
+			cameraSubscription();
+			return;
+		}
+		closeSubscription = cameraSubscription;
+		const sensorSubscription = await rpcCall(rpcRef, (client) => joinSensorEvents(client, handleSensorEvent));
+		if (closed) {
+			sensorSubscription();
+			return;
+		}
+		closeSensorSubscription = sensorSubscription;
 		await refreshStates();
 	}
+	function reconnect() {
+		if (closed) return Promise.resolve();
+		reconnectRetry.cancel();
+		if (reconnecting) {
+			reconnectAgain = true;
+			return reconnecting;
+		}
+		reconnecting = runReconnect();
+		return reconnecting;
+	}
+	async function runReconnect() {
+		try {
+			do {
+				reconnectAgain = false;
+				await init();
+			} while (reconnectAgain && !closed);
+			reconnectRetry.reset();
+		} catch (err) {
+			scheduleReconnect();
+			throw err;
+		} finally {
+			reconnecting = void 0;
+		}
+	}
+	function scheduleReconnect() {
+		if (closed) return;
+		reconnectRetry.schedule(() => {
+			reconnect().catch(() => {});
+		});
+	}
 	async function close() {
+		closed = true;
+		reconnectRetry.cancel();
 		closeSubscription?.();
 		closeSubscription = void 0;
 		closeSensorSubscription?.();
@@ -782,7 +1118,12 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 		if (!id) return Promise.resolve(void 0);
 		return probeStream(id, probeConfig, refresh);
 	}
-	await init();
+	try {
+		await init();
+	} catch (err) {
+		await close();
+		throw err;
+	}
 	return {
 		id: initialCamera._id,
 		name,
@@ -815,10 +1156,41 @@ async function createReactiveCameraDevice(rpcOrContext, initialCamera) {
 		probeStream: probeStreamFn,
 		streamUrl,
 		refreshStates,
-		reconnect: init,
+		reconnect,
 		close
 	};
 }
+async function joinSensorEvents(client, handler) {
+	let fanout = sensorEventFanouts.get(client);
+	if (!fanout) {
+		const handlers = /* @__PURE__ */ new Set();
+		const subject = NamespaceManager.sensorRegistryNamespaces().sensorsSubject;
+		fanout = {
+			handlers,
+			subscribed: client.subscribe(subject, (event) => {
+				for (const each of handlers) try {
+					each(event);
+				} catch {}
+			})
+		};
+		sensorEventFanouts.set(client, fanout);
+	}
+	const joined = fanout;
+	joined.handlers.add(handler);
+	try {
+		await joined.subscribed;
+	} catch (err) {
+		joined.handlers.delete(handler);
+		if (sensorEventFanouts.get(client) === joined) sensorEventFanouts.delete(client);
+		throw err;
+	}
+	return () => leaveSensorEvents(client, joined, handler);
+}
+function leaveSensorEvents(client, fanout, handler) {
+	if (!fanout.handlers.delete(handler) || fanout.handlers.size > 0) return;
+	if (sensorEventFanouts.get(client) === fanout) sensorEventFanouts.delete(client);
+	fanout.subscribed.then((off) => off()).catch(() => {});
+}
 //#endregion
 //#region src/composables/useDeviceManager.ts
 function useDeviceManager() {
@@ -837,36 +1209,74 @@ var cameraCache = createDebouncedCache({
 	onRelease: (_key, device) => device.close()
 });
 var pendingLoads$1 = /* @__PURE__ */ new Map();
+var knownNames = /* @__PURE__ */ new Map();
 function clearCameraCache() {
 	cameraCache.clear();
 	pendingLoads$1.clear();
+	knownNames.clear();
 }
-async function acquireCameraDevice(deviceManager, id) {
-	if (cameraCache.has(id)) return cameraCache.acquire(id, () => {
+function rememberCameraName(name, id) {
+	if (name && id && name !== id) knownNames.set(name, id);
+}
+function cachedIdFor(key) {
+	if (cameraCache.has(key)) return key;
+	let found;
+	cameraCache.forEachValue((device, id) => {
+		if (found === void 0 && device.name.value === key) found = id;
+	});
+	return found;
+}
+function pendingLoadFor(key) {
+	const own = pendingLoads$1.get(key);
+	if (own) return own;
+	for (const [name, id] of knownNames) {
+		const other = id === key ? pendingLoads$1.get(name) : name === key ? pendingLoads$1.get(id) : void 0;
+		if (other) return other;
+	}
+}
+function acquireCached(key) {
+	const id = cachedIdFor(key);
+	if (id === void 0) return void 0;
+	return cameraCache.acquire(id, () => {
 		throw new Error("Should not create - already cached");
 	});
-	const pending = pendingLoads$1.get(id);
+}
+async function acquireCameraDevice(deviceManager, key) {
+	const cached = acquireCached(key);
+	if (cached) return cached;
+	const pending = pendingLoadFor(key);
 	if (pending) {
 		const device = await pending;
-		return device ? cameraCache.acquire(id, () => device) : void 0;
+		const joined = acquireCached(key);
+		if (joined || !device) return joined;
 	}
-	const loadPromise = deviceManager.getCamera(id);
-	pendingLoads$1.set(id, loadPromise);
+	const loadPromise = deviceManager.getCamera(key);
+	pendingLoads$1.set(key, loadPromise);
 	try {
 		const device = await loadPromise;
-		return device ? cameraCache.acquire(id, () => device) : void 0;
+		return device ? cacheLoadedDevice(device) : void 0;
 	} finally {
-		pendingLoads$1.delete(id);
+		if (pendingLoads$1.get(key) === loadPromise) pendingLoads$1.delete(key);
 	}
 }
-function releaseCameraDevice(id) {
-	cameraCache.release(id);
+function cacheLoadedDevice(device) {
+	const held = cameraCache.acquire(device.id, () => device);
+	if (held !== device) device.close();
+	return held;
+}
+function releaseCameraDevice(device) {
+	cameraCache.release(device.id, device);
 }
 function reconnectAllCameraDevices() {
 	cameraCache.forEachValue((device) => {
 		device.reconnect().catch(() => {});
 	});
 }
+function refreshAllCameraDevices() {
+	cameraCache.forEachValue((device) => {
+		device.refreshStates().catch(() => device.reconnect().catch(() => {}));
+	});
+}
 function useCameraById(cameraIdOrName) {
 	const { isConnected } = useCameraUi();
 	const deviceManager = useDeviceManager();
@@ -874,89 +1284,90 @@ function useCameraById(cameraIdOrName) {
 	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;
+	let boundKey;
+	const loadRetry = createRetryTimer();
+	let disposed = false;
+	function bindCamera(key, device) {
+		boundKey = key;
+		camera.value = device;
+		error.value = void 0;
+		cancelRetry();
+	}
+	function unbindCamera() {
+		if (camera.value) releaseCameraDevice(camera.value);
+		camera.value = void 0;
+		boundKey = void 0;
+	}
+	function failLoad(key, err) {
+		error.value = err instanceof Error ? err : new Error(String(err));
+		scheduleRetry(key);
+	}
+	function scheduleRetry(key) {
+		if (disposed) return;
+		loadRetry.schedule(() => {
+			if (isConnected.value && toValue(cameraIdOrName) === key && boundKey !== key) loadCamera(key, true).catch(() => {});
+		});
+	}
+	function cancelRetry() {
+		loadRetry.cancel();
+		loadRetry.reset();
+	}
+	async function loadCamera(key, retry = false) {
+		if (disposed || !isConnected.value || !key) return;
+		if (boundKey !== void 0 && boundKey !== key) {
+			if (camera.value && (camera.value.id === key || camera.value.name.value === key)) {
+				boundKey = key;
+				return;
+			}
+			unbindCamera();
 		}
-		if (cameraCache.has(id)) {
-			const cached = cameraCache.acquire(id, () => {
-				throw new Error("Should not create - already cached");
-			});
-			currentCameraId = id;
-			camera.value = cached;
+		if (camera.value) return;
+		const cached = acquireCached(key);
+		if (cached) {
+			bindCamera(key, cached);
 			initialLoadDone.value = true;
 			return;
 		}
-		const pending = pendingLoads$1.get(id);
-		if (pending) {
+		if (!retry) {
 			_isLoading.value = true;
-			try {
-				const device = await pending;
-				if (device && cameraCache.has(id) && toValue(cameraIdOrName) === 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;
+			error.value = void 0;
 		}
-		_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);
-				if (toValue(cameraIdOrName) !== id) {
-					cameraCache.release(id);
-					return;
-				}
-				currentCameraId = id;
-				camera.value = device;
+			const device = await acquireCameraDevice(deviceManager, key);
+			if (!device) return;
+			if (disposed || toValue(cameraIdOrName) !== key || camera.value) {
+				releaseCameraDevice(device);
+				return;
 			}
+			bindCamera(key, device);
 		} catch (err) {
-			error.value = err instanceof Error ? err : new Error(String(err));
+			failLoad(key, 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);
+		const key = toValue(cameraIdOrName);
+		if (!key) return;
+		const device = camera.value;
+		if (device) {
+			if (cameraCache.get(device.id) === device && cameraCache.getRefCount(device.id) <= 1) cameraCache.forceRelease(device.id);
+			else releaseCameraDevice(device);
 			camera.value = void 0;
-			currentCameraId = void 0;
+			boundKey = void 0;
 		}
-		await loadCamera(id);
+		await loadCamera(key);
 	}
-	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;
-		}
+	watch([isConnected, () => toValue(cameraIdOrName)], async ([connected, key]) => {
+		cancelRetry();
+		if (connected && key) await loadCamera(key);
+		else if (!connected && boundKey !== void 0) unbindCamera();
 	}, { immediate: true });
 	tryOnScopeDispose(() => {
-		if (currentCameraId) {
-			cameraCache.release(currentCameraId);
-			camera.value = void 0;
-			currentCameraId = void 0;
-		}
+		disposed = true;
+		cancelRetry();
+		unbindCamera();
 	});
 	return {
 		camera,
@@ -966,12 +1377,163 @@ function useCameraById(cameraIdOrName) {
 	};
 }
 //#endregion
+//#region src/composables/resolvePluginId.ts
+var pluginIdCache = /* @__PURE__ */ new Map();
+var pluginNames = /* @__PURE__ */ new Map();
+var pendingResolves = /* @__PURE__ */ new Map();
+function clearPluginIdCache() {
+	pluginIdCache.clear();
+	pluginNames.clear();
+}
+function pluginNameOf(pluginId) {
+	return pluginNames.get(pluginId);
+}
+function forgetPluginId(pluginName) {
+	pluginIdCache.delete(pluginName);
+}
+async function resolvePluginId(rpcRef, pluginName) {
+	const cached = pluginIdCache.get(pluginName);
+	if (cached) return cached;
+	const pending = pendingResolves.get(pluginName);
+	if (pending) return pending;
+	const promise = (async () => {
+		const namespaces = NamespaceManager.coreManagerNamespaces();
+		const pluginInfo = await rpcCall(rpcRef, (rpc) => rpc.createProxy(namespaces.coreManagerRpc).getPlugin(pluginName));
+		if (pluginInfo) {
+			pluginIdCache.set(pluginName, pluginInfo.id);
+			pluginNames.set(pluginInfo.id, pluginName);
+			return pluginInfo.id;
+		}
+	})().finally(() => pendingResolves.delete(pluginName));
+	pendingResolves.set(pluginName, promise);
+	return promise;
+}
+//#endregion
+//#region src/composables/useOAuth.ts
+var POLL_ACTIVE_MS = 1500;
+var POLL_IDLE_MS = 3e4;
+var oauthStates = /* @__PURE__ */ new Map();
+function clearOAuthCache() {
+	for (const entry of oauthStates.values()) entry.stop();
+	oauthStates.clear();
+}
+function createOAuthState(pluginName) {
+	const ctx = useCameraUi();
+	const state = ref({ status: "disconnected" });
+	const metadata = ref(null);
+	let timer;
+	let timerMs = 0;
+	let users = 0;
+	let polling = false;
+	let seq = 0;
+	let appliedSeq = 0;
+	function proxyFor(rpc, id) {
+		return rpc.createProxy(NamespaceManager.pluginNamespaces(id).pluginChildRpc);
+	}
+	const call = (fn) => rpcCall(ctx.rpc, async (rpc) => {
+		const id = await resolvePluginId(ctx.rpc, pluginName);
+		if (!id) throw new Error(`Plugin "${pluginName}" not found`);
+		try {
+			return await fn(proxyFor(rpc, id));
+		} catch (err) {
+			if (!isNoRespondersError(err)) throw err;
+			forgetPluginId(pluginName);
+			const freshId = await resolvePluginId(ctx.rpc, pluginName);
+			if (!freshId || freshId === id) throw err;
+			return fn(proxyFor(rpc, freshId));
+		}
+	});
+	function apply(next, at = ++seq) {
+		if (at < appliedSeq) return;
+		appliedSeq = at;
+		state.value = next;
+		schedule();
+	}
+	async function refresh() {
+		const at = ++seq;
+		apply(await call((proxy) => proxy.getOAuthState()), at);
+		if (!metadata.value) metadata.value = await call((proxy) => proxy.getOAuthMetadata());
+	}
+	function poll() {
+		if (polling) return;
+		polling = true;
+		refresh().catch(() => void 0).finally(() => {
+			polling = false;
+		});
+	}
+	function schedule() {
+		const { status } = state.value;
+		const ms = users === 0 ? 0 : status === "awaiting_user" || status === "polling" ? POLL_ACTIVE_MS : POLL_IDLE_MS;
+		if (ms === timerMs) return;
+		clearInterval(timer);
+		timer = ms ? setInterval(poll, ms) : void 0;
+		timerMs = ms;
+	}
+	function retain() {
+		if (users++ > 0) return;
+		schedule();
+		poll();
+	}
+	function release() {
+		if (users === 0) return;
+		users--;
+		schedule();
+	}
+	function stop() {
+		users = 0;
+		schedule();
+	}
+	return {
+		state,
+		metadata,
+		call,
+		refresh,
+		apply,
+		retain,
+		release,
+		stop
+	};
+}
+function useOAuth(pluginName) {
+	if (!oauthStates.has(pluginName)) oauthStates.set(pluginName, createOAuthState(pluginName));
+	const entry = oauthStates.get(pluginName);
+	const { state, metadata, call, refresh, apply } = entry;
+	entry.retain();
+	tryOnScopeDispose(entry.release);
+	async function startDeviceFlow(scope) {
+		apply(await call((proxy) => proxy.startDeviceFlow(scope)));
+	}
+	async function startAuthCodeFlow(scope) {
+		apply(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/usePlugin.ts
 var RETRY_BASE_MS = 2e3;
 var RETRY_MAX_MS = 3e4;
 var pluginCache = createDebouncedCache({ releaseDelay: 1e3 });
 var pendingLoads = /* @__PURE__ */ new Map();
+var pendingChecks = /* @__PURE__ */ new Map();
 var instances = /* @__PURE__ */ new Set();
+var statusListeners = /* @__PURE__ */ new Set();
+var pluginRunning = /* @__PURE__ */ new Map();
 var reloaders = /* @__PURE__ */ new Map();
 var retryTimers = /* @__PURE__ */ new Map();
 var retryAttempts = /* @__PURE__ */ new Map();
@@ -980,6 +1542,8 @@ var statusUnsubscribe;
 function clearPluginCache() {
 	pluginCache.clear();
 	pendingLoads.clear();
+	pendingChecks.clear();
+	forgetPluginStatus();
 	for (const reset of instances) try {
 		reset();
 	} catch {}
@@ -1003,12 +1567,72 @@ function scheduleRetry(name) {
 	}, Math.min(RETRY_BASE_MS * 2 ** attempt, RETRY_MAX_MS));
 	retryTimers.set(name, timer);
 }
-function handleStatusMessage(message) {
-	if (message?.type !== "pluginStatusChanged") return;
-	const { pluginName, running } = message.data;
-	if (!running) pluginCache.forceRelease(pluginName);
+function onPluginStatus(listener) {
+	statusListeners.add(listener);
+	return () => {
+		statusListeners.delete(listener);
+	};
+}
+function isPluginStopped(pluginName) {
+	return pluginRunning.get(pluginName) === false;
+}
+function forgetPluginStatus() {
+	pluginRunning.clear();
+}
+function applyStatus(pluginName, running, stale = !running) {
+	pluginRunning.set(pluginName, running);
+	if (stale) {
+		pluginCache.forceRelease(pluginName);
+		forgetPluginId(pluginName);
+	}
 	stopRetry(pluginName);
 	notifyReloaders(pluginName);
+	for (const listener of [...statusListeners]) try {
+		listener(pluginName, running);
+	} catch {}
+}
+function handleStatusMessage(message) {
+	if (message?.type !== "pluginStatusChanged") return;
+	applyStatus(message.data.pluginName, message.data.running);
+}
+function checkPlugin(name, rpc) {
+	const cached = pluginCache.get(name);
+	if (!cached || pendingChecks.has(name)) return;
+	const check = rpcCall(rpc, (client) => client.createProxy(NamespaceManager.coreManagerNamespaces().coreManagerRpc).getPlugin(name)).then((info) => {
+		const pluginInfo = info;
+		if (pluginCache.get(name) !== cached) return;
+		const running = !!pluginInfo && pluginInfo.running !== false;
+		const moved = running && NamespaceManager.pluginNamespaces(pluginInfo.id).pluginChildRpc !== cached.namespace;
+		if (running && !moved) return;
+		applyStatus(name, running, true);
+	}).catch(() => {}).finally(() => {
+		if (pendingChecks.get(name) === check) pendingChecks.delete(name);
+	});
+	pendingChecks.set(name, check);
+}
+function createLaneProxy(namespace, main, lane) {
+	const proxies = /* @__PURE__ */ new WeakMap();
+	return new Proxy(main, { get(_target, prop) {
+		const client = liveBulkClient(lane);
+		if (!client) return Reflect.get(main, prop);
+		let proxy = proxies.get(client);
+		if (!proxy) {
+			proxy = client.createProxy(namespace);
+			proxies.set(client, proxy);
+		}
+		const member = Reflect.get(proxy, prop);
+		return typeof member === "function" ? watchTimeouts(member, lane, client) : member;
+	} });
+}
+function watchTimeouts(member, lane, client) {
+	return new Proxy(member, { apply(target, thisArg, args) {
+		const result = Reflect.apply(target, thisArg, args);
+		if (!(result instanceof Promise)) return result;
+		return result.catch((err) => {
+			if (err?.code === "TIMEOUT") noticeBulkTimeout(lane, client);
+			throw err;
+		});
+	} });
 }
 async function ensureStatusSubscription(rpc) {
 	const client = rpc.value;
@@ -1022,14 +1646,17 @@ async function ensureStatusSubscription(rpc) {
 		statusClient = void 0;
 	}
 }
-function usePlugin(pluginName) {
-	const { rpc, isConnected } = useCameraUi();
+function usePlugin(pluginName, options = {}) {
+	const ctx = useCameraUi();
+	const { rpc, bulkRpc, isConnected } = ctx;
+	const lane = options.lane === "bulk" ? bulkRpc : void 0;
 	const plugin = shallowRef();
 	const contract = ref();
 	const _isLoading = ref(false);
 	const initialLoadDone = ref(false);
 	const error = ref();
 	let currentPluginName;
+	let heldPlugin;
 	let watchedName;
 	function acquirePlugin(name) {
 		if (pluginCache.has(name)) return pluginCache.acquire(name, () => {
@@ -1037,7 +1664,8 @@ function usePlugin(pluginName) {
 		});
 	}
 	function releasePlugin(name) {
-		pluginCache.release(name);
+		pluginCache.release(name, heldPlugin);
+		heldPlugin = void 0;
 	}
 	function watchPlugin(name) {
 		if (watchedName === name) return;
@@ -1073,7 +1701,9 @@ function usePlugin(pluginName) {
 	}
 	function adopt(name, cached) {
 		currentPluginName = name;
-		plugin.value = cached.proxy;
+		heldPlugin = cached;
+		if (lane) cached.bulkProxy ??= createLaneProxy(cached.namespace, cached.proxy, lane);
+		plugin.value = lane ? cached.bulkProxy : cached.proxy;
 		contract.value = cached.contract;
 		error.value = void 0;
 		stopRetry(name);
@@ -1089,8 +1719,9 @@ function usePlugin(pluginName) {
 		}
 		watchPlugin(name);
 		ensureStatusSubscription(rpc);
-		if (currentPluginName === name && !pluginCache.has(name)) {
+		if (currentPluginName === name && pluginCache.get(name) !== heldPlugin) {
 			currentPluginName = void 0;
+			heldPlugin = void 0;
 			plugin.value = void 0;
 			contract.value = void 0;
 		} else if (currentPluginName === name && plugin.value) return;
@@ -1128,22 +1759,25 @@ function usePlugin(pluginName) {
 			const pluginInfo = await client.createProxy(coreNamespaces.coreManagerRpc).getPlugin(name);
 			if (!pluginInfo) throw new Error(`Plugin "${name}" not found`);
 			if (pluginInfo.running === false) return;
-			const pluginNamespaces = NamespaceManager.pluginNamespaces(pluginInfo.id);
+			const namespace = NamespaceManager.pluginNamespaces(pluginInfo.id).pluginChildRpc;
 			return {
-				proxy: client.createProxy(pluginNamespaces.pluginChildRpc),
-				contract: pluginInfo.contract
+				proxy: client.createProxy(namespace),
+				contract: pluginInfo.contract,
+				namespace,
+				client
 			};
 		});
 		pendingLoads.set(name, loadPromise);
 		try {
 			const result = await loadPromise;
+			pluginRunning.set(name, !!result);
 			if (result) {
-				pluginCache.acquire(name, () => result);
+				const held = pluginCache.acquire(name, () => result);
 				if (toValue(pluginName) !== name) {
-					pluginCache.release(name);
+					pluginCache.release(name, held);
 					return;
 				}
-				adopt(name, result);
+				adopt(name, held);
 			} else if (toValue(pluginName) === name) markUnavailable(name);
 		} catch (err) {
 			if (!silent) error.value = err instanceof Error ? err : new Error(String(err));
@@ -1158,8 +1792,10 @@ function usePlugin(pluginName) {
 		const name = toValue(pluginName);
 		if (!name) return;
 		if (currentPluginName) {
-			if (pluginCache.getRefCount(currentPluginName) <= 1) pluginCache.forceRelease(currentPluginName);
-			else pluginCache.release(currentPluginName);
+			if (pluginCache.get(currentPluginName) === heldPlugin && pluginCache.getRefCount(currentPluginName) <= 1) {
+				pluginCache.forceRelease(currentPluginName);
+				heldPlugin = void 0;
+			} else releasePlugin(currentPluginName);
 			plugin.value = void 0;
 			contract.value = void 0;
 			currentPluginName = void 0;
@@ -1171,22 +1807,28 @@ function usePlugin(pluginName) {
 		plugin.value = void 0;
 		contract.value = void 0;
 		currentPluginName = void 0;
+		heldPlugin = void 0;
 	};
 	instances.add(resetInstance);
+	function onReconnected() {
+		if (currentPluginName) checkPlugin(currentPluginName, rpc);
+	}
+	ctx.on("reconnected", onReconnected);
 	watch([
 		isConnected,
 		() => toValue(pluginName),
 		rpc
-	], async ([connected, name, currentClient], oldValues) => {
-		const prevClient = oldValues?.[2];
-		if (currentPluginName && prevClient && prevClient !== currentClient) {
+	], async ([connected, name, currentClient]) => {
+		const renamed = !!currentPluginName && name !== currentPluginName;
+		if (currentPluginName && (renamed || currentClient && heldPlugin && heldPlugin.client !== currentClient)) {
+			if (renamed) unwatchPlugin(currentPluginName);
 			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) {
+		else if (!connected && currentPluginName) {
 			unwatchPlugin(currentPluginName);
 			releasePlugin(currentPluginName);
 			plugin.value = void 0;
@@ -1196,6 +1838,7 @@ function usePlugin(pluginName) {
 	}, { immediate: true });
 	tryOnScopeDispose(() => {
 		instances.delete(resetInstance);
+		ctx.off("reconnected", onReconnected);
 		unwatchPlugin(toValue(pluginName));
 		if (currentPluginName) {
 			unwatchPlugin(currentPluginName);
@@ -1256,14 +1899,23 @@ var isReactivePowerSensor = createSensorTypeGuard(SensorType.Power);
 var isReactiveIlluminanceInfo = createSensorTypeGuard(SensorType.Illuminance);
 var isReactiveCarbonDioxideInfo = createSensorTypeGuard(SensorType.CarbonDioxide);
 var isReactiveGarageControl = createSensorTypeGuard(SensorType.Garage);
+function sameList(a, b) {
+	return a.length === b.length && a.every((value, i) => value === b[i]);
+}
+function sameIdentity(sensor, data) {
+	return sensor.type === data.type && sensor.name === data.name && sensor.pluginId === data.pluginId && sensor.nativeId === data.nativeId && sensor.boundCameraId === data.boundCameraId;
+}
 function createReactiveSensor(data, state, rpcRef) {
 	const displayName = ref(state.displayName ?? data.displayName ?? data.name);
 	const capabilities = ref(state.capabilities ?? data.capabilities ?? []);
 	const assignedCameraIds = ref([...data.assignedCameraIds]);
 	const exposed = ref(data.exposed);
 	const connected = ref(data.connected);
-	const properties = reactive({ ...state.properties });
+	const properties = shallowReactive({ ...state.properties });
 	const capabilityCallbacks = [];
+	function notifyCapabilitiesChanged() {
+		for (const callback of capabilityCallbacks) callback(capabilities.value);
+	}
 	return {
 		id: data.id,
 		type: data.type,
@@ -1298,23 +1950,61 @@ function createReactiveSensor(data, state, rpcRef) {
 				if (index !== -1) capabilityCallbacks.splice(index, 1);
 			};
 		},
-		_notifyCapabilitiesChanged() {
-			for (const callback of capabilityCallbacks) callback(capabilities.value);
+		_notifyCapabilitiesChanged: notifyCapabilitiesChanged,
+		_update(next, nextState) {
+			displayName.value = nextState.displayName ?? next.displayName ?? next.name;
+			if (!sameList(assignedCameraIds.value, next.assignedCameraIds)) assignedCameraIds.value = [...next.assignedCameraIds];
+			exposed.value = next.exposed;
+			connected.value = next.connected;
+			const nextProperties = nextState.properties ?? {};
+			for (const property of Object.keys(properties)) if (!(property in nextProperties)) delete properties[property];
+			Object.assign(properties, nextProperties);
+			const nextCapabilities = nextState.capabilities ?? next.capabilities ?? [];
+			if (!sameList(capabilities.value, nextCapabilities)) {
+				capabilities.value = nextCapabilities;
+				notifyCapabilitiesChanged();
+			}
 		}
 	};
 }
+var LIVE_RELEASE_DELAY_MS = 1e3;
+var ALL_LIVE_SCOPE = "all";
+function cameraLiveScope(cameraId) {
+	return `camera:${cameraId}`;
+}
+function sensorLiveScope(sensorId) {
+	return `sensor:${sensorId}`;
+}
 function createSensorManager(rpcOrContext) {
+	const manager = createScopedSensorManager(rpcOrContext);
+	manager.retainLive(ALL_LIVE_SCOPE);
+	return manager;
+}
+function createScopedSensorManager(rpcOrContext) {
 	const { sensorsSubject, sensorsRpc } = NamespaceManager.sensorRegistryNamespaces();
 	const ctx = "rpc" in rpcOrContext && "value" in rpcOrContext.rpc ? rpcOrContext : void 0;
 	const rpcRef = ctx ? ctx.rpc : shallowRef(rpcOrContext);
 	const sensorMap = shallowRef(/* @__PURE__ */ new Map());
 	let globalUnsubscribe;
 	const sensorSubscriptions = /* @__PURE__ */ new Map();
+	const pendingSubscriptions = /* @__PURE__ */ new Set();
+	const refreshing = /* @__PURE__ */ new Map();
+	const refreshRuns = /* @__PURE__ */ new Set();
+	let refreshBatch;
+	const refreshRetries = /* @__PURE__ */ new Set();
+	const refreshRetry = createRetryTimer();
+	const refreshOnConnect = /* @__PURE__ */ new Set();
+	const liveHolds = /* @__PURE__ */ new Map();
+	const liveReleaseTimers = /* @__PURE__ */ new Map();
+	let subscriptionEpoch = 0;
 	const initialized = ref(false);
 	let initPromise;
+	let generation = 0;
+	const initRetry = createRetryTimer();
 	function handlePerSensorEvent(sensorId, message) {
 		const sensor = sensorMap.value.get(sensorId);
 		if (!sensor) return;
+		refreshing.get(sensorId)?.add(message.type === "property:changed" ? message.data.property : message.type);
 		if (message.type === "property:changed") {
 			const event = message.data;
 			sensor.properties[event.property] = event.value;
@@ -1327,11 +2017,129 @@ function createSensorManager(rpcOrContext) {
 			sensor._notifyCapabilitiesChanged();
 		}
 	}
-	async function subscribeToSensorEvents(sensorId) {
-		if (sensorSubscriptions.has(sensorId)) return;
+	function isLive(sensor) {
+		if (liveHolds.has(ALL_LIVE_SCOPE) || liveHolds.has(sensorLiveScope(sensor.id))) return true;
+		const cameraIds = sensor.assignedCameraIds.value;
+		return cameraIds.length === 0 || cameraIds.some((cameraId) => liveHolds.has(cameraLiveScope(cameraId)));
+	}
+	function goLive(sensor, staleValues) {
+		if (sensorSubscriptions.has(sensor.id) || pendingSubscriptions.has(sensor.id)) return;
+		if (staleValues) for (const property of Object.keys(sensor.properties)) delete sensor.properties[property];
+		queueRefresh(sensor.id, subscribeSensorSubject(sensor.id).catch(() => void 0));
+	}
+	function queueRefresh(sensorId, subscribed) {
+		const changed = /* @__PURE__ */ new Set();
+		refreshing.set(sensorId, changed);
+		if (!refreshBatch) {
+			const batch = [];
+			refreshBatch = batch;
+			const run = Promise.resolve().then(() => {
+				refreshBatch = void 0;
+				return refreshStates(batch);
+			}).catch(() => {}).finally(() => refreshRuns.delete(run));
+			refreshRuns.add(run);
+		}
+		refreshBatch.push({
+			sensorId,
+			changed,
+			subscribed
+		});
+	}
+	async function refreshStates(batch) {
+		const subscriptions = await Promise.all(batch.map((refresh) => refresh.subscribed));
+		const current = batch.flatMap((refresh, i) => {
+			const unsubscribe = subscriptions[i];
+			return unsubscribe && sensorSubscriptions.get(refresh.sensorId) === unsubscribe ? [{
+				...refresh,
+				unsubscribe
+			}] : [];
+		});
+		let states;
+		if (current.length > 0) try {
+			states = await rpcCall(rpcRef, (c) => c.createProxy(sensorsRpc).getSensorStates());
+			refreshRetry.reset();
+		} catch {
+			states = void 0;
+		}
+		for (const { sensorId, unsubscribe, changed } of current) applyRefreshedState(sensorId, unsubscribe, changed, states);
+		for (const { sensorId, changed } of batch) if (refreshing.get(sensorId) === changed) refreshing.delete(sensorId);
+	}
+	function applyRefreshedState(sensorId, unsubscribe, changed, states) {
+		const sensor = sensorMap.value.get(sensorId);
+		if (!sensor || sensorSubscriptions.get(sensorId) !== unsubscribe) return;
+		const state = states?.[sensorId];
+		if (!state) {
+			if (states && !sensor.connected.value) refreshOnConnect.add(sensorId);
+			else retryRefresh(sensorId);
+			return;
+		}
+		for (const [property, value] of Object.entries(state.properties ?? {})) if (!changed.has(property)) sensor.properties[property] = value;
+		if (state.displayName !== void 0 && !changed.has("sensor:displayName:changed")) sensor.displayName.value = state.displayName;
+		const current = sensor.capabilities.value;
+		const capabilities = state.capabilities ?? current;
+		if (!changed.has("sensor:capabilities:changed") && !sameList(capabilities, current)) {
+			sensor.capabilities.value = capabilities;
+			sensor._notifyCapabilitiesChanged();
+		}
+	}
+	function retryRefresh(sensorId) {
+		refreshRetries.add(sensorId);
+		refreshRetry.schedule(() => {
+			const sensorIds = [...refreshRetries];
+			refreshRetries.clear();
+			for (const id of sensorIds) refreshLiveSensor(id);
+		});
+	}
+	function refreshLiveSensor(sensorId) {
+		const unsubscribe = sensorSubscriptions.get(sensorId);
+		if (unsubscribe) queueRefresh(sensorId, Promise.resolve(unsubscribe));
+	}
+	function whenRefreshed() {
+		return Promise.all(refreshRuns).then(() => {});
+	}
+	async function subscribeSensorSubject(sensorId) {
+		const epoch = subscriptionEpoch;
 		const namespace = NamespaceManager.sensorEventNamespaces(sensorId);
-		const unsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(namespace.sensorSubject, (msg) => handlePerSensorEvent(sensorId, msg)));
+		pendingSubscriptions.add(sensorId);
+		let unsubscribe;
+		try {
+			unsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(namespace.sensorSubject, (msg) => handlePerSensorEvent(sensorId, msg)));
+		} finally {
+			if (epoch === subscriptionEpoch) pendingSubscriptions.delete(sensorId);
+		}
+		const sensor = sensorMap.value.get(sensorId);
+		if (epoch !== subscriptionEpoch || !sensor || !isLive(sensor)) {
+			unsubscribe();
+			return;
+		}
 		sensorSubscriptions.set(sensorId, unsubscribe);
+		return unsubscribe;
+	}
+	function syncSensor(sensor, staleValues) {
+		if (!initialized.value) return;
+		if (isLive(sensor)) goLive(sensor, staleValues);
+		else unsubscribeFromSensorEvents(sensor.id);
+	}
+	function syncLive() {
+		for (const sensor of sensorMap.value.values()) syncSensor(sensor, true);
+	}
+	function retainLive(scope) {
+		clearTimeout(liveReleaseTimers.get(scope));
+		liveReleaseTimers.delete(scope);
+		const held = liveHolds.has(scope);
+		liveHolds.set(scope, (liveHolds.get(scope) ?? 0) + 1);
+		if (!held) syncLive();
+	}
+	function releaseLive(scope) {
+		const count = liveHolds.get(scope);
+		if (!count) return;
+		liveHolds.set(scope, count - 1);
+		if (count > 1) return;
+		liveReleaseTimers.set(scope, setTimeout(() => {
+			liveReleaseTimers.delete(scope);
+			liveHolds.delete(scope);
+			syncLive();
+		}, LIVE_RELEASE_DELAY_MS));
 	}
 	function unsubscribeFromSensorEvents(sensorId) {
 		const unsubscribe = sensorSubscriptions.get(sensorId);
@@ -1339,6 +2147,8 @@ function createSensorManager(rpcOrContext) {
 			unsubscribe();
 			sensorSubscriptions.delete(sensorId);
 		}
+		refreshRetries.delete(sensorId);
+		refreshOnConnect.delete(sensorId);
 	}
 	function handleGlobalSensorEvent(message) {
 		if (message.type === "sensor:added") {
@@ -1348,7 +2158,7 @@ function createSensorManager(rpcOrContext) {
 			const newMap = new Map(sensorMap.value);
 			newMap.set(event.sensor.id, reactiveSensor);
 			sensorMap.value = newMap;
-			subscribeToSensorEvents(event.sensor.id);
+			syncSensor(reactiveSensor, false);
 		} else if (message.type === "sensor:deleted") {
 			const event = message.data;
 			unsubscribeFromSensorEvents(event.sensorId);
@@ -1358,7 +2168,9 @@ function createSensorManager(rpcOrContext) {
 		} else if (message.type === "sensor:connected:changed") {
 			const event = message.data;
 			const sensor = sensorMap.value.get(event.sensorId);
-			if (sensor) sensor.connected.value = event.connected;
+			if (!sensor) return;
+			sensor.connected.value = event.connected;
+			if (event.connected && refreshOnConnect.delete(sensor.id)) refreshLiveSensor(sensor.id);
 		} else if (message.type === "sensor:assignment:changed") {
 			const event = message.data;
 			const sensor = sensorMap.value.get(event.sensorId);
@@ -1367,45 +2179,86 @@ function createSensorManager(rpcOrContext) {
 			if (event.assigned) cameras.add(event.cameraId);
 			else cameras.delete(event.cameraId);
 			sensor.assignedCameraIds.value = [...cameras];
+			syncSensor(sensor, true);
 		} else if (message.type === "sensor:exposed:changed") {
 			const event = message.data;
 			const sensor = sensorMap.value.get(event.sensorId);
 			if (sensor) sensor.exposed.value = event.exposed;
 		}
 	}
-	async function doInit() {
+	function dropSubscriptions() {
 		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(sensorsSubject, (msg) => {
-			if (pendingEvents) pendingEvents.push(msg);
-			else handleGlobalSensorEvent(msg);
-		}));
-		const [sensors, states] = await rpcCall(rpcRef, async (c) => {
-			const proxy = c.createProxy(sensorsRpc);
-			return Promise.all([proxy.getSensors(), proxy.getSensorStates()]);
+		subscriptionEpoch++;
+		pendingSubscriptions.clear();
+		refreshing.clear();
+		refreshRetries.clear();
+		refreshOnConnect.clear();
+		refreshRetry.cancel();
+		refreshRetry.reset();
+	}
+	function assertCurrent(run) {
+		if (run !== generation) throw new Error("sensor manager closed");
+	}
+	function scheduleRetry() {
+		initRetry.schedule(() => {
+			if (!initialized.value && !initPromise) launchInit().catch(() => {});
 		});
-		const newMap = /* @__PURE__ */ new Map();
-		for (const sensor of sensors) {
-			const reactiveSensor = createReactiveSensor(sensor, states[sensor.id] ?? {
-				properties: {},
-				capabilities: [],
-				type: sensor.type
-			}, rpcRef);
-			newMap.set(sensor.id, reactiveSensor);
-		}
-		sensorMap.value = newMap;
-		for (const sensorId of newMap.keys()) await subscribeToSensorEvents(sensorId);
+	}
+	async function doInit(run) {
+		assertCurrent(run);
+		dropSubscriptions();
+		const previous = sensorMap.value;
+		let pendingEvents = [];
+		try {
+			globalUnsubscribe = await rpcCall(rpcRef, (c) => c.subscribe(sensorsSubject, (msg) => {
+				if (pendingEvents) pendingEvents.push(msg);
+				else handleGlobalSensorEvent(msg);
+			}));
+			assertCurrent(run);
+			const [sensors, states] = await rpcCall(rpcRef, async (c) => {
+				const proxy = c.createProxy(sensorsRpc);
+				return Promise.all([proxy.getSensors(), proxy.getSensorStates()]);
+			});
+			assertCurrent(run);
+			const newMap = /* @__PURE__ */ new Map();
+			for (const sensor of sensors) {
+				const state = states[sensor.id] ?? {
+					properties: {},
+					capabilities: [],
+					type: sensor.type
+				};
+				const kept = previous.get(sensor.id);
+				if (kept && sameIdentity(kept, sensor)) {
+					kept._update(sensor, state);
+					newMap.set(sensor.id, kept);
+				} else newMap.set(sensor.id, createReactiveSensor(sensor, state, rpcRef));
+			}
+			sensorMap.value = newMap;
+			for (const sensor of newMap.values()) {
+				if (!isLive(sensor)) continue;
+				await subscribeSensorSubject(sensor.id);
+				assertCurrent(run);
+			}
+		} catch (err) {
+			dropSubscriptions();
+			if (run === generation) {
+				sensorMap.value = previous;
+				scheduleRetry();
+			}
+			throw err;
+		}
 		const queued = pendingEvents;
 		pendingEvents = void 0;
 		for (const msg of queued) handleGlobalSensorEvent(msg);
+		initRetry.reset();
 		initialized.value = true;
+		syncLive();
 	}
 	function launchInit() {
-		const p = doInit().finally(() => {
+		const p = doInit(generation).finally(() => {
 			if (initPromise === p) initPromise = void 0;
 		});
 		initPromise = p;
@@ -1419,7 +2272,9 @@ function createSensorManager(rpcOrContext) {
 	async function reconnect() {
 		initialized.value = false;
 		if (initPromise) {
-			const p = initPromise.catch(() => {}).then(() => doInit()).finally(() => {
+			const current = initPromise;
+			const run = generation;
+			const p = current.catch(() => {}).then(() => doInit(run)).finally(() => {
 				if (initPromise === p) initPromise = void 0;
 			});
 			initPromise = p;
@@ -1428,11 +2283,10 @@ function createSensorManager(rpcOrContext) {
 		return launchInit();
 	}
 	function close() {
-		globalUnsubscribe?.();
-		globalUnsubscribe = void 0;
-		for (const unsubscribe of sensorSubscriptions.values()) unsubscribe();
-		sensorSubscriptions.clear();
-		sensorMap.value.clear();
+		generation++;
+		initRetry.cancel();
+		dropSubscriptions();
+		sensorMap.value = /* @__PURE__ */ new Map();
 		initialized.value = false;
 		initPromise = void 0;
 	}
@@ -1454,7 +2308,10 @@ function createSensorManager(rpcOrContext) {
 		},
 		ensureInitialized,
 		reconnect,
-		close
+		close,
+		retainLive,
+		releaseLive,
+		whenRefreshed
 	};
 }
 var sensorManagerCache = createDebouncedCache({
@@ -1466,72 +2323,112 @@ function clearSensorCache() {
 }
 function reconnectAllSensorManagers() {
 	sensorManagerCache.forEachValue((cached) => {
-		cached.initPromise = cached.manager.reconnect();
+		cached.manager.reconnect().catch(() => {});
 	});
 }
 var GLOBAL_SENSOR_MANAGER_KEY = "sensors";
 function acquireSensorManager(rpcOrContext) {
-	return sensorManagerCache.acquire(GLOBAL_SENSOR_MANAGER_KEY, () => ({ manager: createSensorManager(rpcOrContext) }));
+	const cached = acquireSharedManager(rpcOrContext);
+	cached.manager.retainLive(ALL_LIVE_SCOPE);
+	return cached;
 }
 function releaseSensorManager() {
-	sensorManagerCache.release(GLOBAL_SENSOR_MANAGER_KEY);
+	sensorManagerCache.get(GLOBAL_SENSOR_MANAGER_KEY)?.manager.releaseLive(ALL_LIVE_SCOPE);
+	releaseSharedManager();
+}
+function acquireSharedManager(rpcOrContext) {
+	return sensorManagerCache.acquire(GLOBAL_SENSOR_MANAGER_KEY, () => ({ manager: createScopedSensorManager(rpcOrContext) }));
+}
+function releaseSharedManager(held) {
+	const cached = sensorManagerCache.get(GLOBAL_SENSOR_MANAGER_KEY);
+	if (!cached || held && cached.manager !== held) return;
+	sensorManagerCache.release(GLOBAL_SENSOR_MANAGER_KEY, cached);
 }
 function createSensorComposableState() {
 	return {
 		acquired: false,
-		cachedManager: void 0
+		cachedManager: void 0,
+		liveScope: void 0
 	};
 }
 function sensorsForCamera(manager, cameraId) {
 	return manager.sensors.value.filter((sensor) => sensor.assignedCameraIds.value.includes(cameraId));
 }
-async function ensureSensorManager(state, cameraUi, isConnected, isLoading, error) {
-	if (!cameraUi.rpc.value || !isConnected) return void 0;
+async function ensureSensorManager(state, cameraUi, isConnected, isLoading, error, liveScope) {
+	if (!isConnected) return void 0;
 	isLoading.value = true;
 	error.value = void 0;
 	try {
-		const cached = acquireSensorManager(cameraUi);
-		state.acquired = true;
-		state.cachedManager = cached.manager;
-		if (!cached.initPromise) cached.initPromise = cached.manager.ensureInitialized();
-		await cached.initPromise;
-		return cached.manager;
+		if (!holdsCachedManager(state)) {
+			state.cachedManager = acquireSharedManager(cameraUi).manager;
+			state.acquired = true;
+			state.liveScope = void 0;
+		}
+		holdLiveScope(state, liveScope);
+		await state.cachedManager?.ensureInitialized();
+		await state.cachedManager?.whenRefreshed();
 	} catch (err) {
 		error.value = err instanceof Error ? err : new Error(String(err));
-		return;
 	} finally {
 		isLoading.value = false;
 	}
+	return state.cachedManager;
+}
+function clearErrorOnRecovery(manager, error) {
+	watch(() => manager.value?.isInitialized.value, (ready) => {
+		if (ready) error.value = void 0;
+	});
+}
+function holdsCachedManager(state) {
+	return state.acquired && sensorManagerCache.get(GLOBAL_SENSOR_MANAGER_KEY)?.manager === state.cachedManager;
+}
+function holdLiveScope(state, liveScope) {
+	if (state.liveScope === liveScope) return;
+	state.cachedManager?.retainLive(liveScope);
+	if (state.liveScope) state.cachedManager?.releaseLive(state.liveScope);
+	state.liveScope = liveScope;
 }
 function cleanupSensorComposable(state) {
-	if (state.acquired) {
-		releaseSensorManager();
-		state.acquired = false;
-		state.cachedManager = void 0;
+	if (holdsCachedManager(state)) {
+		if (state.liveScope) state.cachedManager?.releaseLive(state.liveScope);
+		releaseSharedManager(state.cachedManager);
 	}
+	state.acquired = false;
+	state.cachedManager = void 0;
+	state.liveScope = void 0;
 }
 function useSensorById(camera, sensorId) {
 	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();
+	function resolveSensor() {
+		const senId = toValue(sensorId);
+		return senId ? cachedManager.value?.getSensor(senId) : void 0;
+	}
 	watch([
 		isConnected,
 		() => extractCameraId(toValue(camera)),
 		() => toValue(sensorId)
 	], async ([connected, camId, senId]) => {
 		if (connected && camId && senId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
-			sensor.value = manager?.getSensor(senId);
+			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, sensorLiveScope(senId));
+			sensor.value = resolveSensor();
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
+			cachedManager.value = void 0;
 			sensor.value = void 0;
 		}
 	}, { immediate: true });
+	watch(resolveSensor, (next) => {
+		sensor.value = next;
+	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensor.value = void 0;
@@ -1546,24 +2443,35 @@ function useSensorByType(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();
+	function resolveSensor() {
+		const camId = extractCameraId(toValue(camera));
+		const type = toValue(sensorType);
+		return cachedManager.value && camId ? sensorsForCamera(cachedManager.value, camId).find((s) => s.type === type) : void 0;
+	}
 	watch([
 		isConnected,
 		() => extractCameraId(toValue(camera)),
 		() => toValue(sensorType)
-	], async ([connected, camId, type]) => {
+	], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
-			sensor.value = manager ? sensorsForCamera(manager, camId).find((s) => s.type === type) : void 0;
+			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, cameraLiveScope(camId));
+			sensor.value = resolveSensor();
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
+			cachedManager.value = void 0;
 			sensor.value = void 0;
 		}
 	}, { immediate: true });
+	watch(resolveSensor, (next) => {
+		sensor.value = next;
+	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensor.value = void 0;
@@ -1589,7 +2497,7 @@ function useSensorsByType(camera, sensorType) {
 		() => toValue(sensorType)
 	], async ([connected, camId, type]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, cameraLiveScope(camId));
 			cachedManager.value = manager;
 			sensorsRef.value = manager ? sensorsForCamera(manager, camId).filter((s) => s.type === type) : [];
 			initialLoadDone.value = true;
@@ -1606,6 +2514,7 @@ function useSensorsByType(camera, sensorType) {
 		if (!camId) return [];
 		return sensorsForCamera(cachedManager.value, camId).filter((s) => s.type === type);
 	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensorsRef.value = [];
@@ -1627,7 +2536,7 @@ function useSensors(camera) {
 	const state = createSensorComposableState();
 	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, cameraLiveScope(camId));
 			cachedManager.value = manager;
 			sensorsRef.value = manager ? sensorsForCamera(manager, camId) : [];
 			initialLoadDone.value = true;
@@ -1643,6 +2552,7 @@ function useSensors(camera) {
 		if (!camId) return [];
 		return sensorsForCamera(cachedManager.value, camId);
 	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensorsRef.value = [];
@@ -1663,7 +2573,7 @@ function useAllSensors() {
 	const state = createSensorComposableState();
 	watch([isConnected], async ([connected]) => {
 		if (connected) {
-			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, ALL_LIVE_SCOPE);
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
@@ -1671,6 +2581,7 @@ function useAllSensors() {
 		}
 	}, { immediate: true });
 	const sensors = computed(() => cachedManager.value?.sensors.value ?? []);
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 	});
@@ -1697,32 +2608,30 @@ function useTypedSensor(camera, sensorType, preferredPluginId) {
 	const initialLoadDone = ref(false);
 	const error = ref();
 	const state = createSensorComposableState();
+	function resolveSensor() {
+		const camId = extractCameraId(toValue(camera));
+		if (!cachedManager.value || !camId) return void 0;
+		return pickSensorOfType(sensorsForCamera(cachedManager.value, camId), sensorType, toValue(preferredPluginId));
+	}
 	watch([
 		isConnected,
 		() => extractCameraId(toValue(camera)),
 		() => toValue(preferredPluginId)
-	], async ([connected, camId, preferred]) => {
+	], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
-			cachedManager.value = manager;
-			sensor.value = manager ? pickSensorOfType(sensorsForCamera(manager, camId), sensorType, preferred) : void 0;
+			cachedManager.value = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, cameraLiveScope(camId));
+			sensor.value = resolveSensor();
 			initialLoadDone.value = true;
 		} else {
 			cleanupSensorComposable(state);
+			cachedManager.value = void 0;
 			sensor.value = void 0;
 		}
 	}, { immediate: true });
-	watch(() => {
-		if (!cachedManager.value) return void 0;
-		const camId = extractCameraId(toValue(camera));
-		if (!camId) return void 0;
-		return pickSensorOfType(sensorsForCamera(cachedManager.value, camId), sensorType, toValue(preferredPluginId))?.id;
-	}, () => {
-		if (cachedManager.value) {
-			const camId = extractCameraId(toValue(camera));
-			sensor.value = camId ? pickSensorOfType(sensorsForCamera(cachedManager.value, camId), sensorType, toValue(preferredPluginId)) : void 0;
-		}
+	watch(resolveSensor, (next) => {
+		sensor.value = next;
 	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensor.value = void 0;
@@ -1762,7 +2671,7 @@ function useClassifierSensors(camera) {
 	const state = createSensorComposableState();
 	watch([isConnected, () => extractCameraId(toValue(camera))], async ([connected, camId]) => {
 		if (connected && camId) {
-			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error);
+			const manager = await ensureSensorManager(state, cameraUi, connected, _isLoading, error, cameraLiveScope(camId));
 			cachedManager.value = manager;
 			sensorsRef.value = manager ? sensorsForCamera(manager, camId).filter((s) => s.type === SensorType.Classifier) : [];
 			initialLoadDone.value = true;
@@ -1778,6 +2687,7 @@ function useClassifierSensors(camera) {
 		if (!camId) return [];
 		return sensorsForCamera(cachedManager.value, camId).filter((s) => s.type === SensorType.Classifier);
 	});
+	clearErrorOnRecovery(cachedManager, error);
 	tryOnScopeDispose(() => {
 		cleanupSensorComposable(state);
 		sensorsRef.value = [];
@@ -1789,29 +2699,6 @@ function useClassifierSensors(camera) {
 	};
 }
 //#endregion
-//#region src/composables/resolvePluginId.ts
-var pluginIdCache = /* @__PURE__ */ new Map();
-var pendingResolves = /* @__PURE__ */ new Map();
-function clearPluginIdCache() {
-	pluginIdCache.clear();
-}
-async function resolvePluginId(rpcRef, pluginName) {
-	const cached = pluginIdCache.get(pluginName);
-	if (cached) return cached;
-	const pending = pendingResolves.get(pluginName);
-	if (pending) return pending;
-	const promise = (async () => {
-		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;
-		}
-	})().finally(() => pendingResolves.delete(pluginName));
-	pendingResolves.set(pluginName, promise);
-	return promise;
-}
-//#endregion
 //#region src/composables/useStorage.ts
 function createReactiveStorage(proxy, client) {
 	const config = shallowRef();
@@ -1902,8 +2789,8 @@ function acquireStorage(key, client, createProxy) {
 	if (cached && cached.client !== client) storageCache.forceRelease(key);
 	return storageCache.acquire(key, () => createReactiveStorage(createProxy(), client));
 }
-function releaseStorage(key) {
-	storageCache.release(key);
+function releaseStorage(key, storage) {
+	storageCache.release(key, storage);
 }
 function clearStorageCache() {
 	storageCache.clear();
@@ -1912,12 +2799,22 @@ function clearStorageCache() {
 function createStorageState() {
 	return {
 		currentStorageKey: void 0,
-		cachedStorage: void 0
+		cachedStorage: void 0,
+		load: void 0,
+		disposed: false
 	};
 }
+function endLoad(state, config) {
+	const load = state.load;
+	if (!load) return;
+	clearTimeout(load.timer);
+	state.load = void 0;
+	load.settle(config);
+}
 function cleanupStorage(state, isConnected, config) {
+	endLoad(state, void 0);
 	if (state.currentStorageKey) {
-		releaseStorage(state.currentStorageKey);
+		releaseStorage(state.currentStorageKey, state.cachedStorage);
 		state.currentStorageKey = void 0;
 	}
 	isConnected.value = false;
@@ -1927,7 +2824,7 @@ function cleanupStorage(state, isConnected, config) {
 function bindStorage(state, storageKey, client, config, createProxy) {
 	if (state.currentStorageKey === storageKey && state.cachedStorage?.client === client) return;
 	if (state.currentStorageKey && state.currentStorageKey !== storageKey) {
-		releaseStorage(state.currentStorageKey);
+		releaseStorage(state.currentStorageKey, state.cachedStorage);
 		config.value = void 0;
 	}
 	state.currentStorageKey = storageKey;
@@ -1943,45 +2840,90 @@ var GET_CONFIG_RETRY_DELAYS = [
 	15e3,
 	15e3
 ];
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function createStorageOperations(state, config, isLoading, error) {
-	let inflightGetConfig;
-	let inflightStorage;
+function createStorageOperations(state, config, isLoading, error, rebind, status) {
+	let visibleAttempts = 0;
+	if (status) tryOnScopeDispose(onPluginStatus(onStatus));
+	function onStatus(pluginName, running) {
+		if (pluginName !== status?.pluginName()) return;
+		if (!running) {
+			if (state.load?.timer) endLoad(state, void 0);
+		} else if (state.load || error.value) getConfig();
+	}
 	function getConfig() {
-		if (!inflightGetConfig || inflightStorage !== state.cachedStorage) {
-			inflightStorage = state.cachedStorage;
-			const request = getConfigWithRetry().finally(() => {
-				if (inflightGetConfig === request) {
-					inflightGetConfig = void 0;
-					inflightStorage = void 0;
-				}
-			});
-			inflightGetConfig = request;
-		}
-		return inflightGetConfig;
+		if (!state.cachedStorage) return Promise.resolve(void 0);
+		if (status) ensureStatusSubscription(status.rpc);
+		if (state.load && state.load.key !== state.currentStorageKey) endLoad(state, void 0);
+		const load = state.load ?? startLoad();
+		load.retries = 0;
+		load.rebound = false;
+		if (load.storage !== state.cachedStorage) {
+			clearTimeout(load.timer);
+			load.timer = void 0;
+			attempt(load, true);
+		}
+		return load.result;
+	}
+	function startLoad() {
+		let settle;
+		const result = new Promise((resolve) => settle = resolve);
+		const load = {
+			key: state.currentStorageKey,
+			result,
+			settle,
+			storage: void 0,
+			retries: 0,
+			rebound: false,
+			timer: void 0
+		};
+		state.load = load;
+		return load;
 	}
-	async function getConfigWithRetry() {
+	async function attempt(load, visible) {
 		const cached = state.cachedStorage;
-		if (!cached) return void 0;
-		isLoading.value = true;
+		if (!cached) {
+			endLoad(state, void 0);
+			return;
+		}
+		load.storage = cached;
+		if (visible) {
+			visibleAttempts++;
+			isLoading.value = true;
+		}
 		try {
-			let result = await cached.getConfig();
-			for (const delay of GET_CONFIG_RETRY_DELAYS) {
-				if (!cached.error.value || state.cachedStorage !== cached) break;
-				await sleep(delay);
-				if (state.cachedStorage !== cached) break;
-				result = await cached.getConfig();
+			const result = await cached.getConfig();
+			if (state.load !== load || state.cachedStorage !== cached) return;
+			if (rebind && !load.rebound && isNoRespondersError(cached.error.value)) {
+				load.rebound = true;
+				if (await rebind()) {
+					if (state.load !== load) return;
+					load.key = state.currentStorageKey;
+					await attempt(load, visible);
+					return;
+				}
+				if (state.load !== load || state.cachedStorage !== cached) return;
 			}
-			if (state.cachedStorage !== cached) return result;
 			config.value = cached.config.value;
 			error.value = cached.error.value;
-			return result;
+			if (cached.error.value) scheduleRetry(load);
+			else endLoad(state, result);
 		} finally {
-			isLoading.value = false;
+			if (load.storage === cached) load.storage = void 0;
+			if (visible && --visibleAttempts === 0) isLoading.value = false;
 		}
 	}
+	function scheduleRetry(load) {
+		const pluginName = status?.pluginName();
+		const delay = pluginName && isPluginStopped(pluginName) ? void 0 : GET_CONFIG_RETRY_DELAYS[load.retries++];
+		if (delay === void 0) {
+			endLoad(state, void 0);
+			return;
+		}
+		load.timer = setTimeout(() => {
+			load.timer = void 0;
+			if (load.key === state.currentStorageKey) attempt(load, false);
+			else endLoad(state, void 0);
+		}, delay);
+	}
 	async function setValue(key, value) {
 		const cached = state.cachedStorage;
 		if (!cached) throw new Error("Storage not connected");
@@ -2044,17 +2986,24 @@ function usePluginStorage(pluginName) {
 	const error = ref();
 	const isConnected = ref(false);
 	const state = createStorageState();
-	const operations = createStorageOperations(state, config, _isLoading, error);
+	const operations = createStorageOperations(state, config, _isLoading, error, rebind, {
+		rpc,
+		pluginName: () => toValue(pluginName)
+	});
+	function bind(pluginId, client) {
+		bindStorage(state, getPluginStorageKey(pluginId), client, config, () => {
+			const namespaces = NamespaceManager.pluginNamespaces(pluginId);
+			return client.createProxy(namespaces.pluginStorageRpc);
+		});
+	}
 	async function connect(name) {
 		const client = rpc.value;
 		if (!client || !clientConnected.value) return false;
 		try {
 			const pluginId = await resolvePluginId(rpc, name);
+			if (state.disposed) return false;
 			if (!pluginId) throw new Error(`Plugin "${name}" not found`);
-			bindStorage(state, getPluginStorageKey(pluginId), client, config, () => {
-				const namespaces = NamespaceManager.pluginNamespaces(pluginId);
-				return client.createProxy(namespaces.pluginStorageRpc);
-			});
+			bind(pluginId, client);
 			isConnected.value = true;
 			return true;
 		} catch (err) {
@@ -2063,6 +3012,17 @@ function usePluginStorage(pluginName) {
 			return false;
 		}
 	}
+	async function rebind() {
+		const name = toValue(pluginName);
+		const storage = state.cachedStorage;
+		if (!name || !storage) return false;
+		forgetPluginId(name);
+		const pluginId = await resolvePluginId(rpc, name).catch(() => void 0);
+		if (!pluginId || state.disposed || state.cachedStorage !== storage) return false;
+		const key = state.currentStorageKey;
+		bind(pluginId, storage.client);
+		return state.currentStorageKey !== key;
+	}
 	async function getConfig() {
 		const name = toValue(pluginName);
 		if (!name) return void 0;
@@ -2080,6 +3040,7 @@ function usePluginStorage(pluginName) {
 	watch([clientConnected, () => toValue(pluginName)], sync, { immediate: true });
 	cameraUi.on("reconnected", sync);
 	tryOnScopeDispose(() => {
+		state.disposed = true;
 		cameraUi.off("reconnected", sync);
 		cleanupStorage(state, isConnected, config);
 	});
@@ -2103,17 +3064,24 @@ function useCameraStorage(camera, pluginName) {
 	const error = ref();
 	const isConnected = ref(false);
 	const state = createStorageState();
-	const operations = createStorageOperations(state, config, _isLoading, error);
+	const operations = createStorageOperations(state, config, _isLoading, error, rebind, {
+		rpc,
+		pluginName: () => toValue(pluginName)
+	});
+	function bind(pluginId, cameraId, client) {
+		bindStorage(state, getCameraStorageKey(pluginId, cameraId), client, config, () => {
+			const namespaces = NamespaceManager.pluginCameraNamespaces(pluginId, cameraId);
+			return client.createProxy(namespaces.cameraStorageRpc);
+		});
+	}
 	async function connect(cameraId, name) {
 		const client = rpc.value;
 		if (!client || !clientConnected.value) return false;
 		try {
 			const pluginId = await resolvePluginId(rpc, name);
+			if (state.disposed) return false;
 			if (!pluginId) throw new Error(`Plugin "${name}" not found`);
-			bindStorage(state, getCameraStorageKey(pluginId, cameraId), client, config, () => {
-				const namespaces = NamespaceManager.pluginCameraNamespaces(pluginId, cameraId);
-				return client.createProxy(namespaces.cameraStorageRpc);
-			});
+			bind(pluginId, cameraId, client);
 			isConnected.value = true;
 			return true;
 		} catch (err) {
@@ -2122,6 +3090,18 @@ function useCameraStorage(camera, pluginName) {
 			return false;
 		}
 	}
+	async function rebind() {
+		const cameraId = extractCameraId(toValue(camera));
+		const name = toValue(pluginName);
+		const storage = state.cachedStorage;
+		if (!cameraId || !name || !storage) return false;
+		forgetPluginId(name);
+		const pluginId = await resolvePluginId(rpc, name).catch(() => void 0);
+		if (!pluginId || state.disposed || state.cachedStorage !== storage) return false;
+		const key = state.currentStorageKey;
+		bind(pluginId, cameraId, storage.client);
+		return state.currentStorageKey !== key;
+	}
 	async function getConfig() {
 		const cameraId = extractCameraId(toValue(camera));
 		const name = toValue(pluginName);
@@ -2145,6 +3125,7 @@ function useCameraStorage(camera, pluginName) {
 	], sync, { immediate: true });
 	cameraUi.on("reconnected", sync);
 	tryOnScopeDispose(() => {
+		state.disposed = true;
 		cameraUi.off("reconnected", sync);
 		cleanupStorage(state, isConnected, config);
 	});
@@ -2168,7 +3149,13 @@ function useSensorStorage(sensorId, pluginId) {
 	const error = ref();
 	const isConnected = ref(false);
 	const state = createStorageState();
-	const operations = createStorageOperations(state, config, _isLoading, error);
+	const operations = createStorageOperations(state, config, _isLoading, error, void 0, {
+		rpc,
+		pluginName: () => {
+			const plugId = toValue(pluginId);
+			return plugId ? pluginNameOf(plugId) : void 0;
+		}
+	});
 	function connect(senId, plugId) {
 		const client = rpc.value;
 		if (!client || !clientConnected.value) return false;
@@ -2208,6 +3195,7 @@ function useSensorStorage(sensorId, pluginId) {
 	], sync, { immediate: true });
 	cameraUi.on("reconnected", sync);
 	tryOnScopeDispose(() => {
+		state.disposed = true;
 		cameraUi.off("reconnected", sync);
 		cleanupStorage(state, isConnected, config);
 	});
@@ -2230,12 +3218,17 @@ function resetClientState() {
 	clearStorageCache();
 	clearSensorCache();
 	clearSnapshotCache();
+	clearOAuthCache();
 }
 function refreshClientSubscriptions() {
 	clearPluginCache();
 	reconnectAllCameraDevices();
 	reconnectAllSensorManagers();
 }
+function refreshClientStates() {
+	forgetPluginStatus();
+	refreshAllCameraDevices();
+}
 //#endregion
 //#region src/plugin.ts
 var CAMERA_UI_INJECTION_KEY = Symbol("camera-ui");
@@ -2245,7 +3238,7 @@ function isContext(input) {
 }
 var DOWN_DEBOUNCE_MS = 4e3;
 function makeContextFromTransport(input) {
-	const { natsTransport, target, wsTransport } = input;
+	const { natsTransport, bulkTransport, target, wsTransport } = input;
 	let hasBeenConnected = natsTransport.getClient() !== null;
 	let lastClient = natsTransport.getClient();
 	let downTimer = null;
@@ -2255,11 +3248,7 @@ function makeContextFromTransport(input) {
 	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 extraProxyQuery = computed(() => void 0);
 	const listeners = /* @__PURE__ */ new Map();
 	function on(event, cb) {
 		let set = listeners.get(event);
@@ -2293,11 +3282,15 @@ function makeContextFromTransport(input) {
 			rpc.value = next;
 			isConnected.value = true;
 			error.value = void 0;
+			if (hasBeenConnected && (!wasConnected || clientChanged || sawDrop)) markLinkRestored(rpc);
 			if (!wasConnected || clientChanged) {
 				refreshClientSubscriptions();
 				if (hasBeenConnected) emit("reconnected");
 				hasBeenConnected = true;
-			} else if (sawDrop && hasBeenConnected) emit("reconnected");
+			} else if (sawDrop && hasBeenConnected) {
+				refreshClientStates();
+				emit("reconnected");
+			}
 			sawDrop = false;
 		} else {
 			sawDrop = true;
@@ -2319,8 +3312,17 @@ function makeContextFromTransport(input) {
 	natsTransport.on("up", () => {
 		error.value = void 0;
 	});
+	let bulkRpc;
+	if (bulkTransport) {
+		const lane = shallowRef();
+		bulkTransport.subscribeClient((next) => {
+			lane.value = next ?? void 0;
+		});
+		bulkRpc = lane;
+	}
 	return markRaw({
 		rpc,
+		bulkRpc,
 		target: readonly(target),
 		isConnected: readonly(isConnected),
 		endpoint,
@@ -2342,7 +3344,8 @@ function createCameraUiPlugin(input) {
 //#region src/streaming/activityMode.ts
 var DEFAULT_CONFIG = {
 	standbyTimeout: 5e3,
-	activityTimeout: 5e3
+	activityTimeout: 5e3,
+	wakeTimeout: 3e4
 };
 function createActivityMode(options) {
 	const { initialMode = "always-on", config = {}, onStreamStart, onStreamStop, isStreamPlaying } = options;
@@ -2355,6 +3358,8 @@ function createActivityMode(options) {
 	const hasActivity = ref(false);
 	let activityTimeout;
 	let idleTimeout;
+	let keepAwake = false;
+	let engaged = false;
 	function clearActivityTimeout() {
 		if (activityTimeout) {
 			clearTimeout(activityTimeout);
@@ -2406,22 +3411,34 @@ function createActivityMode(options) {
 	}
 	function startIdleTimer() {
 		clearIdleTimeout();
+		if (keepAwake) return;
+		const timeout = isStreamPlaying() ? resolvedConfig.standbyTimeout : resolvedConfig.wakeTimeout;
 		idleTimeout = setTimeout(() => {
 			if (mode.value === "standby") goToStandby();
-		}, resolvedConfig.standbyTimeout);
+		}, timeout);
 	}
 	function setMode(newMode) {
 		if (mode.value !== newMode) {
 			mode.value = newMode;
-			manageStreamState();
+			if (engaged) manageStreamState();
+		}
+	}
+	function engage() {
+		engaged = true;
+		if ((mode.value === "standby" || mode.value === "activity" && !hasActivity.value) && !isStreamPlaying()) {
+			clearAllTimers();
+			goToStandby();
+			return;
 		}
+		manageStreamState();
 	}
 	function reportActivity(detected) {
 		if (mode.value !== "activity") return;
 		if (detected) {
 			hasActivity.value = true;
 			clearActivityTimeout();
-			if (inStandby.value || !isStreamPlaying()) exitStandby();
+			if (inStandby.value) exitStandby();
+			else if (!isStreamPlaying()) onStreamStart();
 		} else {
 			hasActivity.value = false;
 			clearActivityTimeout();
@@ -2445,7 +3462,13 @@ function createActivityMode(options) {
 		}
 	}
 	function resetIdleTimer() {
-		if (mode.value === "standby" && !inStandby.value) startIdleTimer();
+		if (engaged && mode.value === "standby" && !inStandby.value) startIdleTimer();
+	}
+	function setKeepAwake(awake) {
+		if (keepAwake === awake) return;
+		keepAwake = awake;
+		if (awake) clearIdleTimeout();
+		else resetIdleTimer();
 	}
 	function dispose() {
 		clearAllTimers();
@@ -2455,9 +3478,11 @@ function createActivityMode(options) {
 		inStandby,
 		hasActivity,
 		setMode,
+		engage,
 		reportActivity,
 		resumeFromStandby,
 		resetIdleTimer,
+		setKeepAwake,
 		dispose
 	};
 }
@@ -2510,7 +3535,8 @@ function _init() {
 			} catch (err) {
 				log$1.error("onTabHidden listener threw:", err);
 			}
-			for (const entry of _pausedListeners) _schedulePausedEntry(entry);
+			for (const entry of _pausedListeners) if (entry.delayMs <= 0) _firePausedEntry(entry);
+			else _schedulePausedEntry(entry);
 		} else if (visible && !_isVisible.value) {
 			_cancelPausedEntries();
 			const hiddenMs = _hiddenAt != null ? Date.now() - _hiddenAt : 0;
@@ -2524,6 +3550,14 @@ function _init() {
 			}
 		}
 	});
+	document.addEventListener("freeze", () => {
+		for (const entry of _pausedListeners) {
+			if (entry.timer === null) continue;
+			clearTimeout(entry.timer);
+			entry.timer = null;
+			_firePausedEntry(entry);
+		}
+	});
 }
 function useTabVisibility() {
 	_init();
@@ -2540,7 +3574,7 @@ function useTabVisibility() {
 	function onTabPaused(cb, options = {}) {
 		const entry = {
 			cb,
-			delayMs: options.delayMs ?? DEFAULT_TAB_PAUSE_MS,
+			delayMs: options.delayMs ?? 3e4,
 			timer: null
 		};
 		_pausedListeners.add(entry);
@@ -2581,7 +3615,8 @@ var STREAM_CONFIG = {
 	},
 	MSE: {
 		BUFFER_SIZE: 2097152,
-		BUFFER_WINDOW: 5
+		BUFFER_WINDOW: 5,
+		MAX_BUFFER_WINDOW: 60
 	},
 	CODECS: {
 		DEFAULT: [
@@ -2608,11 +3643,236 @@ var STREAM_CONFIG = {
 	}
 };
 //#endregion
+//#region src/streaming/mjpeg.ts
+function isJpegFrame(data) {
+	if (data.byteLength < 2) return false;
+	const bytes = new Uint8Array(data, 0, 2);
+	return bytes[0] === 255 && bytes[1] === 216;
+}
+function createMJPEGHandler(options) {
+	const { signal } = options;
+	const canvas = document.createElement("canvas");
+	const context = canvas.getContext("2d", { alpha: false });
+	const stream = canvas.captureStream();
+	let frames = 0;
+	let decoding = false;
+	let pending;
+	let closed = false;
+	function appendFrame(data) {
+		if (closed || signal.aborted) return;
+		if (decoding) {
+			pending = data;
+			return;
+		}
+		decode(data);
+	}
+	async function decode(data) {
+		decoding = true;
+		try {
+			const bitmap = await createImageBitmap(new Blob([data], { type: "image/jpeg" }));
+			if (!closed) draw(bitmap);
+			bitmap.close();
+		} catch {}
+		decoding = false;
+		const next = pending;
+		pending = void 0;
+		if (next && !closed) decode(next);
+	}
+	function draw(bitmap) {
+		if (!context) return;
+		if (canvas.width !== bitmap.width || canvas.height !== bitmap.height) {
+			canvas.width = bitmap.width;
+			canvas.height = bitmap.height;
+		}
+		context.drawImage(bitmap, 0, 0);
+		frames++;
+	}
+	function close() {
+		closed = true;
+		pending = void 0;
+		for (const track of stream.getTracks()) track.stop();
+	}
+	signal.addEventListener("abort", close, { once: true });
+	return {
+		stream,
+		get frames() {
+			return frames;
+		},
+		appendFrame,
+		close
+	};
+}
+//#endregion
+//#region src/streaming/fmp4.ts
+var MOOV = 1836019574;
+var TRAK = 1953653099;
+var TKHD = 1953196132;
+var MDIA = 1835297121;
+var MDHD = 1835296868;
+var HDLR = 1751411826;
+var MVEX = 1836475768;
+var TREX = 1953654136;
+var MOOF = 1836019558;
+var TRAF = 1953653094;
+var TFHD = 1952868452;
+var TFDT = 1952867444;
+var TRUN = 1953658222;
+var VIDE = 1986618469;
+var SAMPLE_IS_NON_SYNC = 65536;
+var MAX_RUN_SAMPLES = 4096;
+function createFmp4KeyframeScanner() {
+	const tracks = /* @__PURE__ */ new Map();
+	let hasVideo;
+	function parseInit(view, start, end) {
+		const parsed = /* @__PURE__ */ new Map();
+		const defaults = /* @__PURE__ */ new Map();
+		forEachBox(view, start, end, (type, s, e) => {
+			if (type === TRAK) {
+				const trak = {
+					id: -1,
+					timescale: 0,
+					video: false
+				};
+				forEachBox(view, s, e, (t, ts, te) => {
+					if (t === TKHD && ts + 24 <= te) trak.id = view.getUint32(ts + (view.getUint8(ts) === 1 ? 20 : 12));
+					else if (t === MDIA) forEachBox(view, ts, te, (m, ms, me) => {
+						if (m === MDHD && ms + 24 <= me) trak.timescale = view.getUint32(ms + (view.getUint8(ms) === 1 ? 20 : 12));
+						else if (m === HDLR && ms + 12 <= me) trak.video = view.getUint32(ms + 8) === VIDE;
+					});
+				});
+				if (trak.id >= 0 && trak.timescale > 0) parsed.set(trak.id, trak);
+			} else if (type === MVEX) forEachBox(view, s, e, (t, ts, te) => {
+				if (t === TREX && ts + 24 <= te) defaults.set(view.getUint32(ts + 4), {
+					duration: view.getUint32(ts + 12),
+					flags: view.getUint32(ts + 20)
+				});
+			});
+		});
+		tracks.clear();
+		for (const [id, { timescale, video }] of parsed) {
+			const trex = defaults.get(id);
+			tracks.set(id, {
+				timescale,
+				video,
+				defaultDuration: trex?.duration ?? 0,
+				defaultFlags: trex?.flags ?? 0
+			});
+		}
+		hasVideo = [...tracks.values()].some((track) => track.video);
+	}
+	function scanTrackFragment(view, start, end, onKeyframe) {
+		const fragment = {
+			duration: 0,
+			flags: 0
+		};
+		forEachBox(view, start, end, (type, s, e) => {
+			if (type === TFHD && s + 8 <= e) {
+				const track = tracks.get(view.getUint32(s + 4));
+				const flags = view.getUint32(s) & 16777215;
+				const length = 8 + (flags & 1 ? 8 : 0) + (flags & 2 ? 4 : 0) + (flags & 8 ? 4 : 0) + (flags & 16 ? 4 : 0) + (flags & 32 ? 4 : 0);
+				if (!track?.video || s + length > e) return;
+				let p = s + 8 + (flags & 1 ? 8 : 0) + (flags & 2 ? 4 : 0);
+				fragment.duration = track.defaultDuration;
+				fragment.flags = track.defaultFlags;
+				if (flags & 8) {
+					fragment.duration = view.getUint32(p);
+					p += 4;
+				}
+				if (flags & 16) p += 4;
+				if (flags & 32) fragment.flags = view.getUint32(p);
+				fragment.track = track;
+			} else if (type === TFDT && s + 8 <= e) {
+				if (view.getUint8(s) === 0) fragment.baseTime = view.getUint32(s + 4);
+				else if (s + 12 <= e) fragment.baseTime = view.getUint32(s + 4) * 2 ** 32 + view.getUint32(s + 8);
+			} else if (type === TRUN && isPlaced(fragment)) fragment.baseTime = scanRun(view, s, e, fragment, onKeyframe);
+		});
+	}
+	function scan(data, onKeyframe) {
+		const view = new DataView(data);
+		forEachBox(view, 0, view.byteLength, (type, start, end) => {
+			if (type === MOOV) parseInit(view, start, end);
+			else if (type === MOOF && hasVideo) forEachBox(view, start, end, (t, s, e) => {
+				if (t === TRAF) scanTrackFragment(view, s, e, onKeyframe);
+			});
+		});
+	}
+	return {
+		get hasVideo() {
+			return hasVideo;
+		},
+		scan
+	};
+}
+function forEachBox(view, from, to, visit) {
+	let offset = from;
+	while (offset + 8 <= to) {
+		let size = view.getUint32(offset);
+		let header = 8;
+		if (size === 1) {
+			if (offset + 16 > to) return;
+			size = view.getUint32(offset + 8) * 2 ** 32 + view.getUint32(offset + 12);
+			header = 16;
+		} else if (size === 0) size = to - offset;
+		if (size < header || offset + size > to) return;
+		visit(view.getUint32(offset + 4), offset + header, offset + size);
+		offset += size;
+	}
+}
+function isPlaced(fragment) {
+	return fragment.track !== void 0 && fragment.baseTime !== void 0;
+}
+function scanRun(view, start, end, fragment, onKeyframe) {
+	if (start + 8 > end) return fragment.baseTime;
+	const version = view.getUint8(start);
+	const flags = view.getUint32(start) & 16777215;
+	const count = view.getUint32(start + 4);
+	let p = start + 8;
+	if (flags & 1) p += 4;
+	let firstFlags;
+	if (flags & 4) {
+		if (p + 4 > end) return fragment.baseTime;
+		firstFlags = view.getUint32(p);
+		p += 4;
+	}
+	const stride = (flags & 256 ? 4 : 0) + (flags & 512 ? 4 : 0) + (flags & 1024 ? 4 : 0) + (flags & 2048 ? 4 : 0);
+	if (count > MAX_RUN_SAMPLES || p + count * stride > end) return fragment.baseTime;
+	let time = fragment.baseTime;
+	for (let i = 0; i < count; i++) {
+		let duration = fragment.duration;
+		let sampleFlags = i === 0 && firstFlags !== void 0 ? firstFlags : fragment.flags;
+		let offset = 0;
+		if (flags & 256) {
+			duration = view.getUint32(p);
+			p += 4;
+		}
+		if (flags & 512) p += 4;
+		if (flags & 1024) {
+			sampleFlags = view.getUint32(p);
+			p += 4;
+		}
+		if (flags & 2048) {
+			offset = version === 0 ? view.getUint32(p) : view.getInt32(p);
+			p += 4;
+		}
+		if (!(sampleFlags & SAMPLE_IS_NON_SYNC)) onKeyframe((time + offset) / fragment.track.timescale);
+		time += duration;
+	}
+	return time;
+}
+//#endregion
 //#region src/streaming/utils.ts
 var H265_TEST_CODEC = "hvc1.1.6.L153.B0";
 function safariVersion() {
 	return navigator.userAgent.match(/version\/(\d+)/i);
 }
+function isMobile() {
+	return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
+}
+function suspendsWhenHidden() {
+	if (globalThis.Capacitor?.isNativePlatform?.()) return true;
+	if (typeof navigator === "undefined") return false;
+	return isMobile() || /Macintosh/i.test(navigator.userAgent) && navigator.maxTouchPoints > 1;
+}
 function getSupportedCodecs() {
 	const codecs = [...STREAM_CONFIG.CODECS.DEFAULT];
 	const version = safariVersion();
@@ -2657,6 +3917,9 @@ function canPlayH265(transport) {
 	}
 	return webrtcH265;
 }
+function canPlayMjpeg() {
+	return typeof createImageBitmap === "function" && typeof HTMLCanvasElement === "function" && typeof HTMLCanvasElement.prototype.captureStream === "function";
+}
 function reportH265DecodeFailure(transport) {
 	if (transport === "mse") mseH265 = false;
 	else webrtcH265 = false;
@@ -2686,6 +3949,11 @@ function getMediaSourceConstructor() {
 	if (hasManagedMediaSource()) return window.ManagedMediaSource;
 	if ("MediaSource" in window) return window.MediaSource;
 }
+function isVideoInPictureInPicture(video) {
+	if (!video) return false;
+	if (typeof document !== "undefined" && "pictureInPictureElement" in document && document.pictureInPictureElement === video) return true;
+	return video.webkitPresentationMode === "picture-in-picture";
+}
 function abortableSleep(ms, signal) {
 	return new Promise((resolve, reject) => {
 		if (signal.aborted) {
@@ -2701,6 +3969,10 @@ function abortableSleep(ms, signal) {
 }
 //#endregion
 //#region src/streaming/mse.ts
+var CUT_MARGIN = .001;
+var MAX_KEYFRAMES = 256;
+var LIVE_EDGE_MARGIN = .3;
+var PENDING_INITIAL_SIZE = 262144;
 function createMSEHandler(options) {
 	const { videoElement, onReady, onFirstData, onError, signal } = options;
 	let mediaSource = null;
@@ -2708,15 +3980,18 @@ function createMSEHandler(options) {
 	let objectUrl = null;
 	let isReady = false;
 	let hasFirstData = false;
-	let pendingBuffer = new Uint8Array(STREAM_CONFIG.MSE.BUFFER_SIZE);
+	let failed = false;
+	let pendingBuffer = /* @__PURE__ */ new Uint8Array(0);
 	let pendingLength = 0;
 	const earlyDataBuffer = [];
 	const supportedCodecs = getSupportedCodecs();
+	const scanner = createFmp4KeyframeScanner();
+	const keyframes = [];
 	function setup() {
 		if (signal.aborted) return void 0;
 		const MediaSourceConstructor = getMediaSourceConstructor();
 		if (!MediaSourceConstructor) {
-			onError(/* @__PURE__ */ new Error("MediaSource not supported"));
+			fail(/* @__PURE__ */ new Error("MediaSource not supported"), "setup");
 			return;
 		}
 		mediaSource = new MediaSourceConstructor();
@@ -2734,6 +4009,7 @@ function createMSEHandler(options) {
 			videoElement.src = objectUrl;
 			videoElement.srcObject = null;
 		}
+		videoElement.addEventListener("error", handleVideoError);
 		return filterSupportedCodecs(supportedCodecs, MediaSourceConstructor.isTypeSupported.bind(MediaSourceConstructor));
 	}
 	function initializeBuffer(mimeType) {
@@ -2745,48 +4021,63 @@ function createMSEHandler(options) {
 			return;
 		}
 		pendingLength = 0;
-		pendingBuffer = new Uint8Array(STREAM_CONFIG.MSE.BUFFER_SIZE);
+		keyframes.length = 0;
 		const MediaSourceConstructor = getMediaSourceConstructor();
 		if (MediaSourceConstructor && !MediaSourceConstructor.isTypeSupported(mimeType)) {
-			onError(/* @__PURE__ */ new Error(`MIME type not supported: ${mimeType}`));
+			fail(/* @__PURE__ */ new Error(`MIME type not supported: ${mimeType}`), "setup");
 			return;
 		}
 		try {
 			sourceBuffer = mediaSource.addSourceBuffer(mimeType);
 			sourceBuffer.mode = "segments";
 			sourceBuffer.addEventListener("updateend", handleUpdateEnd);
+			sourceBuffer.addEventListener("error", handleSourceBufferError);
 			isReady = true;
 			if (earlyDataBuffer.length > 0) {
 				for (const earlyData of earlyDataBuffer) appendBuffer(earlyData);
 				earlyDataBuffer.length = 0;
 			}
+			if (failed || signal.aborted) return;
 			onReady();
 		} catch (err) {
-			onError(err instanceof Error ? err : new Error(String(err)));
+			fail(err, isReady ? "runtime" : "setup");
 		}
 	}
 	function handleUpdateEnd() {
-		if (signal.aborted || !sourceBuffer || !mediaSource) return;
+		if (signal.aborted || failed || !sourceBuffer || !mediaSource) return;
 		if (!sourceBuffer.updating && pendingLength > 0) try {
-			const data = pendingBuffer.slice(0, pendingLength);
-			sourceBuffer.appendBuffer(data);
+			sourceBuffer.appendBuffer(pendingBuffer.subarray(0, pendingLength));
 			pendingLength = 0;
 		} catch (err) {
-			if (!recoverFromQuota(err)) onError(err instanceof Error ? err : new Error(String(err)));
+			if (!recoverFromQuota(err)) {
+				fail(err, "runtime");
+				return;
+			}
 		}
 		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);
+			const margin = STREAM_CONFIG.MSE.BUFFER_WINDOW;
 			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;
+			let cut = cutPoint(Math.min(videoElement.currentTime, end) - margin);
+			if (end - start0 > STREAM_CONFIG.MSE.MAX_BUFFER_WINDOW) {
+				const keyframe = cutPoint(end - margin);
+				cut = keyframe !== void 0 && keyframe > start0 + CUT_MARGIN ? keyframe : end - margin;
+			}
+			if (cut !== void 0 && cut > start0 + CUT_MARGIN) {
+				try {
+					sourceBuffer.remove(start0, cut - CUT_MARGIN);
+					mediaSource.setLiveSeekableRange(cut, end);
+				} catch {}
+				forgetKeyframesBefore(cut);
+			}
+			if (videoElement.currentTime < end - margin) {
+				const target = seekPoint(end - margin, end);
+				if (target > videoElement.currentTime) videoElement.currentTime = target;
+			}
 			const gap = end - videoElement.currentTime;
 			if (gap > 1) videoElement.playbackRate = 1.1;
 			else if (gap < .1) videoElement.playbackRate = .9;
@@ -2794,35 +4085,42 @@ function createMSEHandler(options) {
 		}
 	}
 	function appendBuffer(data) {
-		if (signal.aborted) return;
+		if (signal.aborted || failed) return;
 		if (!sourceBuffer) {
 			earlyDataBuffer.push(data);
 			return;
 		}
-		if (mediaSource?.readyState === "closed") {
-			onError(/* @__PURE__ */ new Error("MediaSource closed"));
+		if (mediaSource?.readyState === "closed" || mediaSource?.readyState === "ended") {
+			fail(/* @__PURE__ */ new Error(`MediaSource ${mediaSource.readyState}`), "runtime");
 			return;
 		}
+		scanner.scan(data, noteKeyframe);
 		if (sourceBuffer.updating || pendingLength > 0) {
-			const bytes = new Uint8Array(data);
-			if (pendingLength + bytes.byteLength > pendingBuffer.byteLength) {
+			if (!enqueue(new Uint8Array(data))) {
 				pendingLength = 0;
-				onError(/* @__PURE__ */ new Error("MSE pending buffer overflow"));
+				fail(/* @__PURE__ */ new Error("MSE pending buffer overflow"), "runtime");
 				return;
 			}
-			pendingBuffer.set(bytes, pendingLength);
-			pendingLength += bytes.byteLength;
 		} else try {
 			sourceBuffer.appendBuffer(data);
 		} catch (err) {
-			if (recoverFromQuota(err)) {
-				const bytes = new Uint8Array(data);
-				if (bytes.byteLength <= pendingBuffer.byteLength) {
-					pendingBuffer.set(bytes, 0);
-					pendingLength = bytes.byteLength;
-				}
-			}
-		}
+			if (recoverFromQuota(err)) enqueue(new Uint8Array(data));
+			else fail(err, "runtime");
+		}
+	}
+	function enqueue(bytes) {
+		const needed = pendingLength + bytes.byteLength;
+		if (needed > STREAM_CONFIG.MSE.BUFFER_SIZE) return false;
+		if (needed > pendingBuffer.byteLength) {
+			let size = Math.max(pendingBuffer.byteLength, PENDING_INITIAL_SIZE);
+			while (size < needed) size *= 2;
+			const grown = new Uint8Array(Math.min(size, STREAM_CONFIG.MSE.BUFFER_SIZE));
+			grown.set(pendingBuffer.subarray(0, pendingLength));
+			pendingBuffer = grown;
+		}
+		pendingBuffer.set(bytes, pendingLength);
+		pendingLength = needed;
+		return true;
 	}
 	function recoverFromQuota(err) {
 		if (err?.name !== "QuotaExceededError") return false;
@@ -2830,17 +4128,54 @@ function createMSEHandler(options) {
 		try {
 			const start0 = sourceBuffer.buffered.start(0);
 			const end = sourceBuffer.buffered.end(sourceBuffer.buffered.length - 1);
-			const evictTo = Math.max(start0 + 1, end - STREAM_CONFIG.MSE.BUFFER_WINDOW);
-			if (evictTo <= start0) return false;
-			sourceBuffer.remove(start0, evictTo);
+			const evictTo = cutPoint(Math.min(videoElement.currentTime, end)) ?? Math.max(start0 + 1, end - STREAM_CONFIG.MSE.BUFFER_WINDOW);
+			if (evictTo <= start0 + CUT_MARGIN) return false;
+			sourceBuffer.remove(start0, evictTo - CUT_MARGIN);
+			forgetKeyframesBefore(evictTo);
 			return true;
 		} catch {
 			return false;
 		}
 	}
+	function noteKeyframe(time) {
+		while (keyframes.length && keyframes[keyframes.length - 1] >= time) keyframes.pop();
+		keyframes.push(time);
+		if (keyframes.length > MAX_KEYFRAMES) keyframes.shift();
+	}
+	function forgetKeyframesBefore(time) {
+		while (keyframes.length && keyframes[0] < time) keyframes.shift();
+	}
+	function cutPoint(time) {
+		if (scanner.hasVideo === false) return time;
+		for (let i = keyframes.length - 1; i >= 0; i--) if (keyframes[i] <= time) return keyframes[i];
+	}
+	function seekPoint(time, end) {
+		if (!scanner.hasVideo) return time;
+		let point = time;
+		for (const keyframe of keyframes) {
+			if (keyframe > end) break;
+			point = keyframe;
+			if (keyframe >= time) break;
+		}
+		return point;
+	}
+	function handleSourceBufferError() {
+		fail(/* @__PURE__ */ new Error("SourceBuffer error"), "runtime");
+	}
+	function handleVideoError() {
+		const error = videoElement.error;
+		fail(new Error(error?.message || `Video element error ${error?.code ?? "unknown"}`), "runtime");
+	}
+	function fail(err, phase) {
+		if (failed || signal.aborted) return;
+		failed = true;
+		onError(err instanceof Error ? err : new Error(String(err)), phase);
+	}
 	function close() {
+		videoElement.removeEventListener("error", handleVideoError);
 		if (sourceBuffer) {
 			sourceBuffer.removeEventListener("updateend", handleUpdateEnd);
+			sourceBuffer.removeEventListener("error", handleSourceBufferError);
 			if (mediaSource?.readyState === "open") try {
 				mediaSource.removeSourceBuffer(sourceBuffer);
 			} catch {}
@@ -2858,6 +4193,7 @@ function createMSEHandler(options) {
 		hasFirstData = false;
 		pendingLength = 0;
 		earlyDataBuffer.length = 0;
+		keyframes.length = 0;
 	}
 	signal.addEventListener("abort", close, { once: true });
 	return {
@@ -2876,6 +4212,12 @@ function createMSEHandler(options) {
 		close
 	};
 }
+function chaseLiveEdge(video) {
+	if (video.buffered.length > 0) {
+		const end = video.buffered.end(video.buffered.length - 1);
+		if (end - video.currentTime > 1) video.currentTime = end - LIVE_EDGE_MARGIN;
+	}
+}
 async function playVideo(videoElement) {
 	try {
 		await videoElement.play();
@@ -2961,7 +4303,6 @@ function createWebRTCHandler(options) {
 		};
 		peerConnection.addTransceiver("video", { direction: "recvonly" });
 		peerConnection.addTransceiver("audio", { direction: "recvonly" });
-		state.micTransceiver = peerConnection.addTransceiver("audio", { direction: "sendonly" });
 		return peerConnection;
 	}
 	async function createOffer() {
@@ -2979,37 +4320,49 @@ function createWebRTCHandler(options) {
 		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 { filterUdp, onConnected, onFailed, onCandidate, signal } = options;
 	const state = {
 		pc: null,
 		micTransceiver: null,
 		isConnected: false
 	};
+	let answered = false;
+	const heldCandidates = [];
+	function sendCandidate(candidate) {
+		if (answered) onCandidate(candidate);
+		else heldCandidates.push(candidate);
+	}
+	async function handleAnswer(sdp) {
+		if (signal.aborted || !state.pc) return;
+		answered = true;
+		for (const candidate of heldCandidates.splice(0)) onCandidate(candidate);
+		await state.pc.setRemoteDescription({
+			type: "answer",
+			sdp
+		});
+	}
 	function createPeerConnection() {
-		const peerConnection = createBasePeerConnection(signal, onCandidate, false);
+		const peerConnection = createBasePeerConnection(signal, sendCandidate, filterUdp);
 		peerConnection.onconnectionstatechange = () => {
 			if (signal.aborted) return;
 			const connectionState = peerConnection.connectionState;
 			if (connectionState === "connected") {
 				state.isConnected = true;
 				onConnected();
-			} else if (connectionState === "disconnected" || connectionState === "failed") {
+			} else if (connectionState === "disconnected") state.isConnected = false;
+			else if (connectionState === "failed") {
 				state.isConnected = false;
-				onDisconnected();
+				onFailed();
 			}
 		};
 		state.micTransceiver = peerConnection.addTransceiver("audio", { direction: "sendonly" });
@@ -3031,8 +4384,8 @@ function createBackchannelHandler(options) {
 			return state.isConnected;
 		},
 		createOffer,
-		handleAnswer: (sdp) => handleSdpAnswer(state.pc, signal, sdp),
-		handleCandidate: (candidate) => handleIceCandidate(state.pc, signal, candidate, false),
+		handleAnswer,
+		handleCandidate: (candidate) => handleIceCandidate(state.pc, signal, candidate, filterUdp),
 		setMicrophoneTrack: (track) => setMicTrack(state.micTransceiver, signal, track),
 		close
 	};
@@ -3049,10 +4402,23 @@ async function processWebRTCMessage(handler, msg) {
 //#region src/streaming/streamConnection.ts
 var log = new Logger("StreamConnection");
 var MSE_AUDIO_CODEC = /mp4a|opus|flac|mp3/i;
-function isVideoInPictureInPicture(video) {
-	if (!video) return false;
-	if (typeof document !== "undefined" && "pictureInPictureElement" in document && document.pictureInPictureElement === video) return true;
-	return video.webkitPresentationMode === "picture-in-picture";
+var RETRY_BASE_DELAY = 1e3;
+var RETRY_MAX_DELAY = 3e4;
+var RETRY_RESET_AFTER = 3e4;
+var WS_RESOLVE_TIMEOUT = 15e3;
+var HEALTH_CHECK_INTERVAL = 1e3;
+var STALL_AFTER = 3e3;
+var STALL_RECONNECT_AFTER = 15e3;
+var HAVE_CURRENT_DATA$1 = 2;
+var PROBE_WAIT_MS = 2e3;
+function isPageHidden() {
+	return typeof document !== "undefined" && document.visibilityState === "hidden";
+}
+function decodedFrames(video) {
+	return typeof video.getVideoPlaybackQuality === "function" ? video.getVideoPlaybackQuality().totalVideoFrames : void 0;
+}
+function withJitter(delayMs) {
+	return delayMs * (1 - Math.random() / 2);
 }
 var StreamConnection = class {
 	status;
@@ -3067,6 +4433,7 @@ var StreamConnection = class {
 	hasAudio;
 	hasBackchannel;
 	isPlaying;
+	stalled;
 	error;
 	probeInfo;
 	muted;
@@ -3082,20 +4449,43 @@ var StreamConnection = class {
 	options;
 	wsTransport;
 	scope = effectScope(true);
+	stopsWhenHidden = suspendsWhenHidden();
 	connectionGeneration = 0;
 	abortController = new AbortController();
 	probedSourceId;
+	probeInFlight;
+	probing;
 	wasPausedByVisibility = false;
+	hiddenPauseRan = false;
 	disarmPipWatch = null;
 	wsHandle;
+	wsOpenedAt = 0;
 	webrtcHandler;
 	mseHandler;
-	firstFrameCallbackId;
+	mjpegHandler;
+	audioHandler;
+	audioElement;
+	cancelFirstFrameWatch;
+	awaitingWebRTCFrame = false;
 	backchannelHandler;
 	pendingMicTrack = null;
+	offerPeer;
+	answeredPeer;
 	lastMediaStream = null;
 	stopWatchers = [];
-	mseMonitorInterval;
+	failures = 0;
+	playingSince;
+	connectToken;
+	rejectedToken;
+	lastError;
+	mseRejected = false;
+	mseAnswerPending = false;
+	mseStopPending = false;
+	healthInterval;
+	lastProgressAt = 0;
+	lastMediaTime = 0;
+	lastFrameCount;
+	frameCounterLive = false;
 	offTabVisible;
 	offTabPaused;
 	onVideoPauseBound;
@@ -3107,8 +4497,6 @@ var StreamConnection = class {
 	stopConnectTimeout;
 	startMseConnectTimeout;
 	stopMseConnectTimeout;
-	startReconnectTimeout;
-	stopReconnectTimeout;
 	constructor(options) {
 		this.options = options;
 		const ctx = useCameraUi();
@@ -3126,6 +4514,7 @@ var StreamConnection = class {
 		this.hasAudio = ref(false);
 		this.hasBackchannel = ref(false);
 		this.isPlaying = ref(false);
+		this.stalled = ref(false);
 		this.error = ref();
 		this.probeInfo = shallowRef();
 		this.muted = ref(true);
@@ -3140,47 +4529,44 @@ var StreamConnection = class {
 		this.isReady = computed(() => !!this.camera.value && !!this.videoElement.value && !!this.target.value);
 		this.scope.run(() => {
 			const { onTabPaused, onTabVisible } = useTabVisibility();
+			const hiddenStopDelay = this.stopsWhenHidden ? 0 : DEFAULT_TAB_PAUSE_MS;
 			const wsConnectTimeout = useTimeoutFn(() => {
-				if (this.wsHandle?.readyState === WebSocket.CONNECTING) {
-					this.disconnectWebSocket();
-					if (!this.abortController.signal.aborted && this.status.value !== "closed") this.restart();
+				const handle = this.wsHandle;
+				if (!handle || handle.readyState === WebSocket.OPEN) return;
+				if (handle.readyState === WebSocket.CLOSED && performance.now() - this.wsOpenedAt < WS_RESOLVE_TIMEOUT) {
+					this.startWsConnectTimeout();
+					return;
 				}
+				this.disconnectWebSocket();
+				if (!this.abortController.signal.aborted && this.status.value !== "closed") this.retryLater();
 			}, STREAM_CONFIG.WEBRTC.WS_CONNECT_TIMEOUT, { immediate: false });
 			const connectTimeout = useTimeoutFn(() => {
+				if (this.abortController.signal.aborted) return;
 				if (this.webrtcHandler && !this.webrtcHandler.isConnected) {
-					if (this.requestedMode.value === "auto") {
-						this.webrtcHandler.close();
-						this.webrtcHandler = void 0;
-						this.activeMode.value = "mse";
-						if (this.mseHandler?.isReady) this.status.value = "connected";
-						else this.startMSE();
-					} else {
-						this.markSourceUndecodable();
-						this.restart();
+					if (this.requestedMode.value === "auto") this.fallBackToMSE();
+					else this.retryAfterNoMedia();
+				} else if (this.webrtcHandler && this.awaitingWebRTCFrame || this.mjpegHandler && !this.isPlaying.value || this.status.value === "connected" && !this.isPlaying.value) {
+					if (isPageHidden()) {
+						this.startConnectTimeout();
+						return;
 					}
-				} else if (this.status.value === "connected" && !this.isPlaying.value && !this.abortController.signal.aborted) this.handleNoFramesWhileConnected();
-			}, STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
+					this.handleNoFramesWhileConnected();
+				}
+			}, () => this.webrtcTookOver() ? STALL_RECONNECT_AFTER : STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
 			const mseConnectTimeout = useTimeoutFn(() => {
 				if (this.abortController.signal.aborted || this.status.value === "connected" || this.status.value === "closed") return;
-				if (this.mseHandler && !this.mseHandler.isReady) {
-					this.markSourceUndecodable();
-					this.restart();
-				}
+				if (this.mseHandler && !this.mseHandler.isReady) this.retryAfterNoMedia();
 			}, STREAM_CONFIG.WEBRTC.CONNECT_TIMEOUT, { immediate: false });
-			const reconnectTimeout = useTimeoutFn(() => {
-				if (!this.abortController.signal.aborted) this.restart();
-			}, STREAM_CONFIG.WEBRTC.RECONNECT_DELAY, { immediate: false });
 			this.startWsConnectTimeout = wsConnectTimeout.start;
 			this.stopWsConnectTimeout = wsConnectTimeout.stop;
 			this.startConnectTimeout = connectTimeout.start;
 			this.stopConnectTimeout = connectTimeout.stop;
 			this.startMseConnectTimeout = mseConnectTimeout.start;
 			this.stopMseConnectTimeout = mseConnectTimeout.stop;
-			this.startReconnectTimeout = reconnectTimeout.start;
-			this.stopReconnectTimeout = reconnectTimeout.stop;
 			this.setupWatchers();
 			this.offTabPaused = onTabPaused(() => {
 				log.debug(`onTabPaused fired — status=${this.status.value}, isReady=${this.isReady.value}, target=${!!this.target.value}`);
+				this.hiddenPauseRan = true;
 				if (this.status.value === "idle" || this.status.value === "closed") {
 					log.debug(`onTabPaused — already in ${this.status.value}, skipping stop()`);
 					return;
@@ -3193,16 +4579,23 @@ var StreamConnection = class {
 				this.wasPausedByVisibility = true;
 				this.stop();
 				log.debug("onTabPaused — stop() done, wasPausedByVisibility=true");
-			});
-			this.offTabVisible = onTabVisible(() => {
+			}, { delayMs: hiddenStopDelay });
+			this.offTabVisible = onTabVisible(({ hiddenMs }) => {
 				log.debug(`onTabVisible fired — wasPausedByVisibility=${this.wasPausedByVisibility}, status=${this.status.value}, isReady=${this.isReady.value}, target=${!!this.target.value}`);
 				this.disarmPipWatch?.();
-				if (!this.wasPausedByVisibility) {
-					log.debug("onTabVisible — not paused by visibility, no-op");
+				const pauseRan = this.hiddenPauseRan;
+				this.hiddenPauseRan = false;
+				if (this.wasPausedByVisibility) {
+					this.wasPausedByVisibility = false;
+					this.startWhenReady();
+					return;
+				}
+				if (!pauseRan && hiddenMs >= hiddenStopDelay && this.status.value === "connected") {
+					log.debug(`onTabVisible: hidden for ${hiddenMs}ms without a stop, reconnecting`);
+					this.restart();
 					return;
 				}
-				this.wasPausedByVisibility = false;
-				this.startWhenReady();
+				log.debug("onTabVisible — not paused by visibility, no-op");
 			});
 			if (autoStart) whenever(this.isReady, () => {
 				if (this.status.value === "idle" || this.status.value === "closed") this.start();
@@ -3240,10 +4633,17 @@ var StreamConnection = class {
 			log.debug("start() — skipped, isReady=false");
 			return;
 		}
+		if (this.stopsWhenHidden && isPageHidden()) {
+			log.debug("start() — page hidden, starting once it is visible");
+			this.wasPausedByVisibility = true;
+			return;
+		}
 		this.cleanup();
 		this.abortController = new AbortController();
 		const gen = ++this.connectionGeneration;
 		this.triedSourceIds.clear();
+		this.failures = 0;
+		this.playingSince = void 0;
 		this.status.value = "connecting";
 		this.error.value = void 0;
 		this.isPlaying.value = false;
@@ -3260,9 +4660,12 @@ var StreamConnection = class {
 				this.status.value = "error";
 				return;
 			}
+			let dialedSourceId;
 			for (let attempt = 0; attempt < 3; attempt++) {
 				const probedSourceId = this.source.value?._id;
-				const probe = await this.probeStream();
+				dialedSourceId = probedSourceId;
+				log.debug("start(): connecting WebSocket");
+				const probe = await this.dialWithProbe();
 				if (gen !== this.connectionGeneration) {
 					log.debug("start() — generation stale after probe, aborting");
 					return;
@@ -3270,18 +4673,19 @@ var StreamConnection = class {
 				if (probe && probedSourceId && this.probeSaysUnplayable(probe)) this.triedSourceIds.add(probedSourceId);
 				const reinit = this.initializeSource();
 				if (reinit === "unsupported") {
+					this.disconnectWebSocket();
 					this.setUnsupported();
 					return;
 				}
 				if (!reinit) {
+					this.disconnectWebSocket();
 					this.error.value = /* @__PURE__ */ new Error("No streaming source available");
 					this.status.value = "error";
 					return;
 				}
 				if (!probe || this.source.value?._id === probedSourceId) break;
 			}
-			log.debug("start() — connecting WebSocket");
-			this.connectWebSocket();
+			if (this.source.value?._id !== dialedSourceId) this.dialWithProbe();
 		} catch (err) {
 			if (gen !== this.connectionGeneration) return;
 			log.debug("start() — error:", err);
@@ -3297,6 +4701,7 @@ var StreamConnection = class {
 		log.debug(`stop() — was ${this.status.value}, transitioning to closed`);
 		++this.connectionGeneration;
 		this.status.value = "closed";
+		this.isPlaying.value = false;
 		this.cleanup();
 	}
 	async setMode(mode) {
@@ -3328,21 +4733,20 @@ var StreamConnection = class {
 		}
 	}
 	async setMicrophone(track) {
-		if (this.webrtcHandler) {
-			await this.webrtcHandler.setMicrophoneTrack(track);
+		if (!track) {
+			this.closeBackchannel();
 			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);
-		}
+		if (!this.hasBackchannel.value) return;
+		this.pendingMicTrack = track;
+		if (!this.backchannelHandler) await this.startBackchannel();
+		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;
+		if (this.audioElement) this.audioElement.muted = muted;
 	}
 	async play() {
 		this.paused.value = false;
@@ -3359,11 +4763,17 @@ var StreamConnection = class {
 				} catch {}
 			}
 		}
+		const audio = this.audioElement;
+		if (audio) {
+			audio.muted = this.muted.value;
+			audio.play().catch(() => {});
+		}
 	}
 	pause() {
 		this.paused.value = true;
 		const video = this.videoElement.value;
 		if (video) video.pause();
+		this.audioElement?.pause();
 	}
 	destroy() {
 		for (const stopWatcher of this.stopWatchers) stopWatcher();
@@ -3382,14 +4792,21 @@ var StreamConnection = class {
 		this.stop();
 		this.scope.stop();
 	}
-	async restart() {
-		this.status.value = "reconnecting";
+	restart() {
+		return this.reconnect(1e3);
+	}
+	invalidateProbe() {
+		this.probeInfo.value = void 0;
+		this.probeInFlight = void 0;
+	}
+	async reconnect(delayMs, waitStatus = "reconnecting") {
+		this.status.value = waitStatus;
 		this.isPlaying.value = false;
 		this.cleanup();
 		this.abortController = new AbortController();
 		const gen = ++this.connectionGeneration;
 		try {
-			await abortableSleep(1e3, this.abortController.signal);
+			await abortableSleep(delayMs, this.abortController.signal);
 		} catch {
 			return;
 		}
@@ -3398,6 +4815,7 @@ var StreamConnection = class {
 			this.status.value = "idle";
 			return;
 		}
+		this.status.value = "reconnecting";
 		try {
 			const init = this.initializeSource();
 			if (init === "unsupported") {
@@ -3409,13 +4827,32 @@ var StreamConnection = class {
 				this.status.value = "error";
 				return;
 			}
-			this.connectWebSocket();
+			this.dialWithProbe();
 		} catch (err) {
 			if (gen !== this.connectionGeneration) return;
 			this.error.value = err instanceof Error ? err : new Error(String(err));
 			this.status.value = "error";
 		}
 	}
+	retryLater(err) {
+		const delay = this.nextRetryDelay();
+		if (err) this.error.value = err;
+		this.reconnect(delay, err ? "error" : "reconnecting");
+	}
+	nextRetryDelay() {
+		if (this.playingSince !== void 0 && performance.now() - this.playingSince >= RETRY_RESET_AFTER) this.failures = 0;
+		this.playingSince = void 0;
+		const base = Math.min(RETRY_BASE_DELAY * 2 ** this.failures, RETRY_MAX_DELAY);
+		this.failures++;
+		return withJitter(base);
+	}
+	retryAfterNoMedia() {
+		if (this.markSourceUndecodable()) {
+			this.restart();
+			return;
+		}
+		this.retryLater(this.lastError);
+	}
 	startWhenReady() {
 		if (this.isReady.value) {
 			log.debug("startWhenReady — already ready, calling start() now");
@@ -3438,6 +4875,13 @@ var StreamConnection = class {
 			this.restart();
 		});
 		this.stopWatchers.push(stopAuthWatch);
+		const stopTokenWatch = watch(() => this.target.value?.tokens.access, (token) => {
+			if (this.rejectedToken === void 0 || !token || token === this.rejectedToken) return;
+			this.rejectedToken = void 0;
+			if (this.status.value === "idle" || this.status.value === "closed") return;
+			this.reconnect(0);
+		});
+		this.stopWatchers.push(stopTokenWatch);
 		const stopSourcesWatch = watch(() => this.camera.value?.sources.value, () => {
 			if (this.status.value !== "unsupported") return;
 			this.stop();
@@ -3481,11 +4925,11 @@ var StreamConnection = class {
 			}
 		}, { immediate: true });
 		this.stopWatchers.push(stopVideoElWatch);
-		const stopMseWatch = watch(this.activeMode, (mode) => {
-			this.stopMseMonitor();
-			if (mode === "mse") this.mseMonitorInterval = setInterval(() => this.monitorMseBuffer(), 1e3);
+		const stopHealthWatch = watch(() => this.status.value === "connected" && this.isPlaying.value, (active) => {
+			this.stopHealthCheck();
+			if (active) this.startHealthCheck();
 		}, { immediate: true });
-		this.stopWatchers.push(stopMseWatch);
+		this.stopWatchers.push(stopHealthWatch);
 		const stopCameraWatch = watch([
 			this.camera,
 			this.videoElement,
@@ -3536,6 +4980,7 @@ var StreamConnection = class {
 	}
 	isSourcePlayable(source) {
 		if (this.triedSourceIds.has(source._id)) return false;
+		if (source.videoCodec === "JPEG") return canPlayMjpeg();
 		if (source.videoCodec !== "H265") return true;
 		const mode = this.requestedMode.value;
 		if (mode === "auto") return canPlayH265("auto");
@@ -3598,6 +5043,7 @@ var StreamConnection = class {
 	probeSaysUnplayable(probe) {
 		const video = probe.video.filter((v) => v.direction === "sendonly");
 		if (!video.length) return false;
+		if (video.every((v) => v.codec === "JPEG")) return !canPlayMjpeg();
 		if (!video.every((v) => v.codec === "H265")) return false;
 		const mode = this.requestedMode.value;
 		return !canPlayH265(mode === "auto" ? "auto" : mode === "mse" ? "mse" : "webrtc");
@@ -3612,38 +5058,55 @@ var StreamConnection = class {
 	}
 	markSourceUndecodable() {
 		const src = this.source.value;
-		if (!src || !this.sourceLikelyH265()) return;
+		if (!src || !this.sourceLikelyH265()) return false;
 		this.triedSourceIds.add(src._id);
+		this.invalidateProbe();
+		return true;
 	}
 	handleNoFramesWhileConnected() {
-		if (this.sourceLikelyH265()) reportH265DecodeFailure(this.activeMode.value === "mse" ? "mse" : "webrtc");
-		if (this.requestedMode.value === "auto" && this.activeMode.value !== "mse") {
+		if (this.sourceLikelyH265() && !this.webrtcTookOver()) reportH265DecodeFailure(this.activeMode.value === "mse" ? "mse" : "webrtc");
+		if (this.requestedMode.value === "auto" && this.activeMode.value !== "mse" && !this.mjpegHandler && !this.mseRejected) {
 			this.webrtcHandler?.close();
 			this.webrtcHandler = void 0;
+			this.awaitingWebRTCFrame = false;
 			this.activeMode.value = "mse";
+			this.isPlaying.value = false;
 			this.status.value = "reconnecting";
 			this.startMSE();
+			this.resumeBackchannel();
 			return;
 		}
-		this.markSourceUndecodable();
-		this.restart();
+		this.retryAfterNoMedia();
+	}
+	webrtcTookOver() {
+		return this.awaitingWebRTCFrame && this.isPlaying.value;
 	}
 	noteDeliveredAudio(delivered) {
 		if (delivered && !this.hasAudio.value) this.hasAudio.value = true;
 	}
-	async probeStream() {
+	probeStream() {
 		const cam = this.camera.value;
 		const source = this.source.value;
-		if (!cam || !source || this.abortController.signal.aborted) return void 0;
+		if (!cam || !source || this.abortController.signal.aborted) return Promise.resolve(void 0);
+		if (this.probeInFlight?.sourceId === source._id) return this.probeInFlight.result;
+		const entry = {
+			sourceId: source._id,
+			result: Promise.resolve(void 0)
+		};
+		this.probeInFlight = entry;
+		entry.result = this.askProbe(cam, entry);
+		return entry.result;
+	}
+	async askProbe(cam, entry) {
 		try {
-			const probe = await cam.probeStream(source._id, {
+			const probe = await cam.probeStream(entry.sourceId, {
 				video: true,
 				audio: ["pcma", "opus"],
 				microphone: true
 			});
-			if (probe && !this.abortController.signal.aborted) {
+			if (probe && this.probeInFlight === entry && !this.abortController.signal.aborted) {
 				this.probeInfo.value = probe;
-				this.probedSourceId = source._id;
+				this.probedSourceId = entry.sourceId;
 				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;
@@ -3651,14 +5114,46 @@ var StreamConnection = class {
 			return probe;
 		} catch {
 			return;
+		} finally {
+			if (this.probeInFlight === entry) this.probeInFlight = void 0;
 		}
 	}
+	dialWithProbe() {
+		const probing = this.settledProbe(this.probeForSource());
+		this.probing = probing;
+		this.connectWebSocket();
+		return probing;
+	}
+	probeForSource() {
+		const source = this.source.value;
+		const known = this.probeInfo.value;
+		return known && source && this.probedSourceId === source._id ? Promise.resolve(known) : this.probeStream();
+	}
+	settledProbe(probe) {
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => resolve(void 0), PROBE_WAIT_MS);
+			const settle = (result) => {
+				clearTimeout(timer);
+				resolve(result);
+			};
+			probe.then(settle, () => settle(void 0));
+		});
+	}
 	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.connectToken = this.target.value.tokens.access;
+		this.rejectedToken = void 0;
+		this.lastError = void 0;
+		this.mseRejected = false;
+		this.mseAnswerPending = false;
+		this.mseStopPending = false;
+		this.offerPeer = void 0;
+		this.answeredPeer = void 0;
+		this.wsOpenedAt = performance.now();
 		this.startWsConnectTimeout();
 		this.wsHandle = this.wsTransport.open({
 			path: "/api/go2rtc",
@@ -3666,7 +5161,7 @@ var StreamConnection = class {
 			binaryType: "arraybuffer"
 		});
 		this.wsHandle.on("open", () => this.handleWsOpen());
-		this.wsHandle.on("close", () => this.handleWsClose());
+		this.wsHandle.on("close", (info) => this.handleWsClose(info));
 		this.wsHandle.on("message", (ev) => this.handleWsMessage(ev));
 		this.wsHandle.on("error", () => {});
 	}
@@ -3684,13 +5179,45 @@ var StreamConnection = class {
 		if (this.abortController.signal.aborted) return;
 		this.stopWsConnectTimeout();
 		this.status.value = "connecting";
+		const handle = this.wsHandle;
+		(this.probing ?? Promise.resolve(void 0)).then(() => {
+			if (this.abortController.signal.aborted || this.wsHandle !== handle) return;
+			this.requestStream();
+		});
+	}
+	requestStream() {
+		if (this.sourceIsMjpeg()) {
+			this.startMjpeg();
+			return;
+		}
 		const mode = this.requestedMode.value;
 		if (mode === "auto") this.startAutoMode();
 		else if (mode === "webrtc" || mode === "webrtc/tcp") this.startWebRTC(mode);
 		else if (mode === "mse") this.startMSE();
 	}
-	handleWsClose() {
-		if (this.status.value !== "closed" && !this.abortController.signal.aborted) this.startReconnectTimeout();
+	handleWsClose(info) {
+		if (this.status.value === "closed" || this.abortController.signal.aborted) return;
+		const kind = info ? classifyClose(info) : "other";
+		if (kind === "other") {
+			this.retryLater();
+			return;
+		}
+		const rejected = this.connectToken;
+		log.debug(`go2rtc socket closed (${info?.code}): ${info?.reason}`);
+		if (kind === "forbidden") {
+			this.error.value = new Error(info?.reason || `Stream refused (${info?.code})`);
+			this.status.value = "error";
+			this.isPlaying.value = false;
+			this.cleanup();
+			this.rejectedToken = rejected;
+			return;
+		}
+		if (this.target.value?.tokens.access !== rejected) {
+			this.reconnect(0);
+			return;
+		}
+		this.reconnect(withJitter(RETRY_MAX_DELAY));
+		this.rejectedToken = rejected;
 	}
 	handleWsMessage(ev) {
 		if (this.abortController.signal.aborted) return;
@@ -3702,34 +5229,82 @@ var StreamConnection = class {
 				return;
 			}
 			this.handleMessage(msg);
-		} else if (this.mseHandler) {
-			this.mseHandler.appendBuffer(ev.data);
-			this.handleFirstFrame();
-		}
+		} else if (this.mjpegHandler && isJpegFrame(ev.data)) this.mjpegHandler.appendFrame(ev.data);
+		else (this.mseHandler ?? this.audioHandler)?.appendBuffer(ev.data);
 	}
 	handleMessage(msg) {
 		switch (msg.type) {
 			case "webrtc/answer":
+				this.answeredPeer = this.takeOfferReply();
+				if (this.answeredPeer) processWebRTCMessage(this.answeredPeer, msg);
+				this.resumeBackchannel();
+				break;
 			case "webrtc/candidate":
-				if (this.webrtcHandler) processWebRTCMessage(this.webrtcHandler, msg);
-				else if (this.backchannelHandler) processWebRTCMessage(this.backchannelHandler, msg);
+				if (this.answeredPeer && this.isCurrentPeer(this.answeredPeer)) processWebRTCMessage(this.answeredPeer, msg);
 				break;
 			case "mse":
-				if (this.mseHandler && typeof msg.value === "string") {
+				this.mseAnswerPending = false;
+				if (this.mseStopPending) {
+					this.mseStopPending = false;
+					this.sendWsMessage({ type: "mse/stop" });
+				}
+				if (typeof msg.value === "string") {
+					const handler = this.mseHandler ?? this.audioHandler;
+					if (!handler) break;
 					this.noteDeliveredAudio(MSE_AUDIO_CODEC.test(msg.value));
-					this.mseHandler.initializeBuffer(msg.value);
+					handler.initializeBuffer(msg.value);
 				}
 				break;
-			case "error": if (this.requestedMode.value !== "auto") {
-				this.error.value = new Error(msg.value);
-				this.status.value = "error";
+			case "mjpeg":
+				if (this.mjpegHandler) this.status.value = "connected";
+				break;
+			case "error": this.handleGo2rtcError(String(msg.value));
+		}
+	}
+	handleGo2rtcError(message) {
+		const request = message.slice(0, Math.max(0, message.indexOf(":")));
+		const err = new Error(message);
+		log.debug(`go2rtc error: ${message}`);
+		if (request === "webrtc/offer") {
+			const peer = this.takeOfferReply();
+			if (peer && peer === this.webrtcHandler && !peer.isConnected) {
+				this.lastError = err;
+				this.stopConnectTimeout();
+				if (this.requestedMode.value === "auto") this.fallBackToMSE();
+				else this.retryLater(err);
+				return;
+			}
+			if (peer && peer === this.backchannelHandler) this.closeBackchannel();
+			this.resumeBackchannel();
+			return;
+		}
+		if (request === "mjpeg") {
+			if (this.mjpegHandler) this.retryLater(err);
+			return;
+		}
+		if (request === "mse") {
+			this.mseAnswerPending = false;
+			this.mseStopPending = false;
+			if (this.audioHandler) {
+				this.closeAudio();
+				return;
+			}
+			if (!this.mseHandler) return;
+			this.lastError = err;
+			this.mseRejected = true;
+			if (this.requestedMode.value === "auto" && this.webrtcHandler) {
+				this.dropMSE();
+				return;
 			}
+			this.retryLater(err);
+			return;
 		}
+		if (!request.startsWith("webrtc")) this.lastError = err;
 	}
 	async startWebRTC(mode) {
 		if (this.abortController.signal.aborted) return;
 		this.startConnectTimeout();
-		this.webrtcHandler = createWebRTCHandler({
+		const handler = createWebRTCHandler({
 			mode,
 			signal: this.abortController.signal,
 			onConnected: (stream) => this.handleWebRTCConnected(stream),
@@ -3740,11 +5315,9 @@ var StreamConnection = class {
 				value: candidate
 			})
 		});
-		const offer = await this.webrtcHandler.createOffer();
-		if (offer && !this.abortController.signal.aborted) this.sendWsMessage({
-			type: "webrtc/offer",
-			value: offer
-		});
+		this.webrtcHandler = handler;
+		const offer = await handler.createOffer();
+		if (offer && !this.abortController.signal.aborted && this.webrtcHandler === handler) this.sendOffer(handler, offer);
 	}
 	handleWebRTCConnected(stream) {
 		if (this.abortController.signal.aborted) return;
@@ -3761,13 +5334,13 @@ var StreamConnection = class {
 		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;
-			this.stopMseConnectTimeout();
-			this.sendWsMessage({ type: "mse/stop" });
-		}
+		if (stream.getVideoTracks().length > 0) {
+			this.awaitingWebRTCFrame = true;
+			if (this.webrtcTookOver()) this.startConnectTimeout();
+			this.resetHealthBaseline(video);
+			this.watchFirstFrame(video);
+		} else this.handleFirstFrame();
+		if (this.requestedMode.value === "auto" && this.mseHandler) this.dropMSE();
 	}
 	handleWebRTCDisconnected() {
 		if (this.status.value !== "closed" && !this.abortController.signal.aborted) {
@@ -3777,22 +5350,28 @@ var StreamConnection = class {
 				this.webrtcHandler = void 0;
 				this.activeMode.value = "mse";
 				this.status.value = "connected";
-			} else this.restart();
+				this.resumeBackchannel();
+			} else this.retryLater();
 		}
 	}
 	handleWebRTCFailed() {
 		if (this.abortController.signal.aborted) return;
 		this.stopConnectTimeout();
-		if (this.requestedMode.value === "auto") {
-			this.webrtcHandler?.close();
-			this.webrtcHandler = void 0;
-			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";
+		if (this.requestedMode.value === "auto") this.fallBackToMSE();
+		else this.retryLater(this.lastError ?? /* @__PURE__ */ new Error("WebRTC connection failed"));
+	}
+	fallBackToMSE() {
+		this.webrtcHandler?.close();
+		this.webrtcHandler = void 0;
+		this.awaitingWebRTCFrame = false;
+		if (this.mseRejected) {
+			this.retryLater(this.lastError);
+			return;
 		}
+		this.activeMode.value = "mse";
+		if (this.mseHandler?.isReady) this.handleMSEReady();
+		else this.startMSE();
+		this.resumeBackchannel();
 	}
 	startMSE() {
 		if (this.mseHandler) return;
@@ -3803,22 +5382,19 @@ var StreamConnection = class {
 			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";
-				} else if (this.activeMode.value === "mse" && this.status.value === "connected") {
-					log.debug("MSE error while active in auto mode — restarting:", err);
-					this.restart();
-				}
-			}
+			onError: (err, phase) => this.handleMSEError(err, phase)
 		});
 		const codecs = this.mseHandler.setup();
 		if (codecs) {
+			if (this.mseStopPending) {
+				this.mseStopPending = false;
+				this.sendWsMessage({ type: "mse/stop" });
+			}
 			this.sendWsMessage({
 				type: "mse",
 				value: codecs
 			});
+			this.mseAnswerPending = true;
 			this.startMseConnectTimeout();
 		}
 	}
@@ -3834,15 +5410,54 @@ var StreamConnection = class {
 			this.activeMode.value = "mse";
 			this.status.value = "connected";
 		}
+		if (!this.webrtcHandler && !this.isPlaying.value) this.startConnectTimeout();
 	}
 	handleMSEFirstData() {
 		if (this.abortController.signal.aborted) return;
 		const video = this.videoElement.value;
-		if (video) playVideo(video);
+		if (video) {
+			this.watchFirstFrame(video);
+			playVideo(video);
+		}
+	}
+	handleMSEError(err, phase) {
+		if (this.abortController.signal.aborted) return;
+		log.debug(`MSE ${phase} error:`, err);
+		if (this.requestedMode.value === "auto" && this.webrtcHandler) {
+			const tookOver = this.isPlaying.value || this.status.value === "connected";
+			this.dropMSE();
+			if (tookOver) {
+				this.isPlaying.value = false;
+				this.status.value = "reconnecting";
+			}
+			return;
+		}
+		const video = this.videoElement.value;
+		const beforeFirstFrame = !video || video.readyState < HAVE_CURRENT_DATA$1;
+		if ((phase === "setup" || beforeFirstFrame) && this.sourceLikelyH265()) {
+			reportH265DecodeFailure("mse");
+			this.markSourceUndecodable();
+			this.restart();
+			return;
+		}
+		if (phase === "setup") {
+			this.error.value = err;
+			this.status.value = "error";
+			this.cleanup();
+			return;
+		}
+		this.retryLater();
+	}
+	dropMSE() {
+		this.mseHandler?.close();
+		this.mseHandler = void 0;
+		this.stopMseConnectTimeout();
+		if (this.mseAnswerPending) this.mseStopPending = true;
+		else this.sendWsMessage({ type: "mse/stop" });
 	}
-	async startAutoMode() {
+	startAutoMode() {
 		if (this.abortController.signal.aborted) return;
-		const probe = this.probeInfo.value ?? await this.probeStream();
+		const probe = this.probeInfo.value;
 		if (probe) {
 			if (!checkWebRTCCompatibility(probe).compatible) {
 				this.activeMode.value = "mse";
@@ -3850,69 +5465,171 @@ var StreamConnection = class {
 				return;
 			}
 		}
-		this.startMSE();
 		this.startWebRTC("webrtc");
+		this.startMSE();
+	}
+	sourceIsMjpeg() {
+		const video = this.probeInfo.value?.video.filter((v) => v.direction === "sendonly") ?? [];
+		if (video.length) return video.every((v) => v.codec === "JPEG");
+		return this.source.value?.videoCodec === "JPEG";
+	}
+	startMjpeg() {
+		const video = this.videoElement.value;
+		if (this.abortController.signal.aborted || !video) return;
+		const handler = createMJPEGHandler({ signal: this.abortController.signal });
+		this.mjpegHandler = handler;
+		this.activeMode.value = "mjpeg";
+		this.lastMediaStream = handler.stream;
+		video.srcObject = handler.stream;
+		playVideo(video);
+		this.sendWsMessage({ type: "mjpeg" });
+		this.startConnectTimeout();
+		this.watchFirstFrame(video);
+		if (this.hasAudio.value) this.startAudio();
+	}
+	startAudio() {
+		if (this.audioHandler || this.abortController.signal.aborted) return;
+		const audio = document.createElement("audio");
+		audio.muted = this.muted.value;
+		const handler = createMSEHandler({
+			videoElement: audio,
+			signal: this.abortController.signal,
+			onReady: () => {},
+			onFirstData: () => playVideo(audio),
+			onError: (err) => {
+				log.debug("MJPEG audio error:", err);
+				this.dropAudio();
+			}
+		});
+		const codecs = handler.setup()?.split(",").filter((codec) => MSE_AUDIO_CODEC.test(codec)).join(",");
+		if (!codecs) {
+			handler.close();
+			return;
+		}
+		this.audioElement = audio;
+		this.audioHandler = handler;
+		this.sendWsMessage({
+			type: "mse",
+			value: codecs
+		});
+		this.mseAnswerPending = true;
+	}
+	dropAudio() {
+		if (!this.audioHandler) return;
+		this.closeAudio();
+		if (this.mseAnswerPending) this.mseStopPending = true;
+		else this.sendWsMessage({ type: "mse/stop" });
+	}
+	closeAudio() {
+		this.audioHandler?.close();
+		this.audioHandler = void 0;
+		const audio = this.audioElement;
+		if (!audio) return;
+		this.audioElement = void 0;
+		audio.pause();
+		audio.removeAttribute("src");
+		audio.load();
 	}
 	handleFirstFrame() {
-		if (!this.isPlaying.value && !this.abortController.signal.aborted) {
+		if (this.abortController.signal.aborted) return;
+		if (!this.webrtcHandler || this.webrtcHandler.isConnected) {
 			this.stopConnectTimeout();
+			this.awaitingWebRTCFrame = false;
+			this.resumeBackchannel();
+		}
+		this.error.value = void 0;
+		if (!this.isPlaying.value) {
 			this.isPlaying.value = true;
+			this.playingSince = performance.now();
 		}
 	}
-	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;
+	watchFirstFrame(video) {
+		this.cancelFirstFrameWatch?.();
+		if (video.readyState >= HAVE_CURRENT_DATA$1) {
+			this.handleFirstFrame();
+			return;
 		}
+		const target = video;
+		const onFrame = () => {
+			this.cancelFirstFrameWatch?.();
+			this.handleFirstFrame();
+		};
+		const callbackId = target.requestVideoFrameCallback?.(onFrame);
+		video.addEventListener("loadeddata", onFrame);
+		this.cancelFirstFrameWatch = () => {
+			this.cancelFirstFrameWatch = void 0;
+			video.removeEventListener("loadeddata", onFrame);
+			if (callbackId !== void 0) target.cancelVideoFrameCallback?.(callbackId);
+		};
+	}
+	startHealthCheck() {
+		const video = this.videoElement.value;
+		if (video) this.resetHealthBaseline(video);
+		this.healthInterval = setInterval(() => this.checkHealth(), HEALTH_CHECK_INTERVAL);
 	}
-	stopMseMonitor() {
-		if (this.mseMonitorInterval !== void 0) {
-			clearInterval(this.mseMonitorInterval);
-			this.mseMonitorInterval = void 0;
+	stopHealthCheck() {
+		if (this.healthInterval !== void 0) {
+			clearInterval(this.healthInterval);
+			this.healthInterval = void 0;
 		}
+		this.stalled.value = false;
 	}
-	handleFirstFrameWebRTC(stream) {
+	resetHealthBaseline(video) {
+		this.lastProgressAt = performance.now();
+		this.lastMediaTime = video.currentTime;
+		this.lastFrameCount = this.frameCount(video);
+		this.frameCounterLive = false;
+		this.stalled.value = false;
+	}
+	checkHealth() {
 		const video = this.videoElement.value;
-		if (this.isPlaying.value || this.abortController.signal.aborted || !video) return;
-		if (!stream.getVideoTracks()[0]) {
-			this.handleFirstFrame();
+		if (!video) return;
+		const mse = this.activeMode.value === "mse";
+		const frames = this.frameCount(video);
+		if (frames !== void 0 && frames > 0) this.frameCounterLive = true;
+		const progressed = frames !== this.lastFrameCount || mse && video.currentTime !== this.lastMediaTime;
+		if (mse) chaseLiveEdge(video);
+		if (this.audioElement) chaseLiveEdge(this.audioElement);
+		this.lastMediaTime = video.currentTime;
+		this.lastFrameCount = frames;
+		const now = performance.now();
+		if (progressed || !this.expectsFrames(video)) {
+			this.lastProgressAt = now;
+			this.stalled.value = false;
 			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);
-		}
+		const silentFor = now - this.lastProgressAt;
+		if (silentFor >= STALL_RECONNECT_AFTER) {
+			log.debug(`no frame for ${Math.round(silentFor)}ms, reconnecting`);
+			this.retryLater();
+		} else if (silentFor >= STALL_AFTER) this.stalled.value = true;
+	}
+	frameCount(video) {
+		return this.mjpegHandler ? this.mjpegHandler.frames : decodedFrames(video);
+	}
+	expectsFrames(video) {
+		if (this.paused.value || video.paused || isVideoInPictureInPicture(video) || isPageHidden()) return false;
+		return this.activeMode.value === "mse" || this.frameCounterLive;
 	}
 	cleanup() {
 		this.abortController.abort();
 		this.stopConnectTimeout();
 		this.stopWsConnectTimeout();
 		this.stopMseConnectTimeout();
-		this.stopReconnectTimeout();
-		this.stopMseMonitor();
+		this.stopHealthCheck();
+		this.cancelFirstFrameWatch?.();
+		this.awaitingWebRTCFrame = false;
 		this.lastMediaStream = null;
 		this.webrtcHandler?.close();
 		this.webrtcHandler = void 0;
 		this.mseHandler?.close();
 		this.mseHandler = void 0;
+		this.mjpegHandler?.close();
+		this.mjpegHandler = void 0;
+		this.closeAudio();
 		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();
@@ -3923,27 +5640,52 @@ var StreamConnection = class {
 	}
 	async startBackchannel() {
 		if (this.abortController.signal.aborted || !this.wsHandle || this.wsHandle.readyState !== WebSocket.OPEN) return;
-		this.backchannelHandler = createBackchannelHandler({
+		if (this.offerPeer) return;
+		if (this.webrtcHandler && (!this.webrtcHandler.isConnected || this.awaitingWebRTCFrame)) return;
+		const handler = createBackchannelHandler({
+			filterUdp: this.requestedMode.value === "webrtc/tcp",
 			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);
+				if (this.pendingMicTrack && this.backchannelHandler === handler) await handler.setMicrophoneTrack(this.pendingMicTrack);
 			},
-			onDisconnected: () => {
-				this.backchannelHandler = void 0;
-			}
+			onFailed: () => this.closeBackchannel(handler)
 		});
-		const offer = await this.backchannelHandler.createOffer();
-		if (offer && !this.abortController.signal.aborted) this.sendWsMessage({
+		this.backchannelHandler = handler;
+		let offer;
+		try {
+			offer = await handler.createOffer();
+		} catch {
+			this.closeBackchannel(handler);
+			return;
+		}
+		if (offer && !this.abortController.signal.aborted && this.backchannelHandler === handler) this.sendOffer(handler, offer);
+	}
+	resumeBackchannel() {
+		if (this.pendingMicTrack && !this.backchannelHandler) this.startBackchannel();
+	}
+	sendOffer(peer, sdp) {
+		if (this.wsHandle?.readyState !== WebSocket.OPEN) return;
+		this.offerPeer = peer;
+		this.wsHandle.send(JSON.stringify({
 			type: "webrtc/offer",
-			value: offer
-		});
+			value: sdp
+		}));
 	}
-	closeBackchannel() {
-		this.backchannelHandler?.close();
+	takeOfferReply() {
+		const peer = this.offerPeer;
+		this.offerPeer = void 0;
+		return peer && this.isCurrentPeer(peer) ? peer : void 0;
+	}
+	isCurrentPeer(peer) {
+		return peer === this.webrtcHandler || peer === this.backchannelHandler;
+	}
+	closeBackchannel(handler = this.backchannelHandler) {
+		handler?.close();
+		if (handler !== this.backchannelHandler) return;
 		this.backchannelHandler = void 0;
 		this.pendingMicTrack = null;
 	}
@@ -3955,6 +5697,7 @@ function createStreamConnection(options) {
 //#region src/streaming/streamManager.ts
 var StreamManager = class {
 	streams = /* @__PURE__ */ new Map();
+	standalone = /* @__PURE__ */ new Set();
 	releaseTimers = /* @__PURE__ */ new Map();
 	releaseDelay;
 	DEFAULT_RELEASE_DELAY = 2e3;
@@ -4033,6 +5776,23 @@ var StreamManager = class {
 			this.releaseTimers.set(cameraName, timer);
 		}
 	}
+	track(stream) {
+		this.standalone.add(stream);
+		return () => {
+			this.standalone.delete(stream);
+		};
+	}
+	restartConnected() {
+		const streams = new Set(this.standalone);
+		for (const entry of this.streams.values()) streams.add(entry.stream);
+		let restarted = 0;
+		for (const stream of streams) {
+			if (stream.status.value !== "connected" || stream.paused.value) continue;
+			stream.restart().catch(() => {});
+			restarted++;
+		}
+		return restarted;
+	}
 	forceRelease(cameraName) {
 		this.cancelRelease(cameraName);
 		this.doRelease(cameraName);
@@ -4092,6 +5852,9 @@ function destroyStream(stream) {
 	else s.stop();
 }
 var streamManager = new StreamManager();
+function restartConnectedStreams() {
+	return streamManager.restartConnected();
+}
 //#endregion
 //#region src/composables/useFullscreen.ts
 var fsRegistry = /* @__PURE__ */ new WeakMap();
@@ -4220,6 +5983,9 @@ function applyWrapperStyles(wrapper, mode) {
 //#region src/composables/useCameraStream.ts
 var AUTO_STAGGER_STEP_MS = 75;
 var AUTO_STAGGER_RESET_MS = 500;
+var OFFSCREEN_STOP_DELAY_MS = 1e4;
+var HAVE_CURRENT_DATA = 2;
+var EMPTY_POSTER = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
 var autoStaggerIndex = 0;
 var autoStaggerLastTouch = 0;
 function acquireAutoStaggerDelay() {
@@ -4269,7 +6035,13 @@ function useCameraStream(options) {
 	const nativeWidth = ref(0);
 	const nativeHeight = ref(0);
 	const isPip = ref(false);
+	const keepAwake = ref(false);
+	const offscreen = ref(false);
 	const autoStartReady = ref(startDelay <= 0);
+	let offscreenTimer;
+	let resumeTimer;
+	let stoppedOffscreen = false;
+	let seenInViewport = false;
 	if (startDelay > 0) startDelayTimer = setTimeout(() => {
 		autoStartReady.value = true;
 	}, startDelay);
@@ -4279,6 +6051,7 @@ function useCameraStream(options) {
 	const isCameraDisabled = computed(() => cameraDeviceRef.value?.disabled.value === true);
 	const status = computed(() => currentStream.value?.status.value ?? "idle");
 	const isPlaying = computed(() => currentStream.value?.isPlaying.value ?? false);
+	const stalled = computed(() => currentStream.value?.stalled?.value ?? false);
 	const activeMode = computed(() => currentStream.value?.activeMode.value ?? "webrtc");
 	const activeResolution = computed(() => currentStream.value?.activeResolution.value ?? "low-resolution");
 	const degradedFrom = computed(() => currentStream.value?.degradedFrom.value ?? null);
@@ -4299,7 +6072,7 @@ function useCameraStream(options) {
 		initialMode: toValue(options.activityMode) ?? "always-on",
 		config: activityConfig,
 		onStreamStart: () => {
-			if (!isCameraDisabled.value) currentStream.value?.start();
+			if (!isCameraDisabled.value && !deferUntilSeen()) currentStream.value?.start();
 		},
 		onStreamStop: () => {
 			if (isUsingCachedStream.value) {
@@ -4330,7 +6103,7 @@ function useCameraStream(options) {
 		video.muted = true;
 		video.disablePictureInPicture = false;
 		video.preload = "auto";
-		video.poster = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+		video.poster = EMPTY_POSTER;
 		video.style.position = "absolute";
 		video.style.width = "100%";
 		video.style.height = "100%";
@@ -4360,6 +6133,74 @@ function useCameraStream(options) {
 	function onLeavePip() {
 		isPip.value = false;
 	}
+	function onPresentationModeChange() {
+		isPip.value = isVideoInPictureInPicture(videoElement.value);
+	}
+	function isRunning() {
+		return status.value !== "idle" && status.value !== "closed" && status.value !== "unsupported";
+	}
+	function capturePoster() {
+		const video = videoElement.value;
+		if (!video || video.readyState < HAVE_CURRENT_DATA || !video.videoWidth || !video.videoHeight) return;
+		const tileWidth = Math.round((containerElement.value?.clientWidth || video.videoWidth) * (globalThis.devicePixelRatio || 1));
+		const canvas = document.createElement("canvas");
+		canvas.width = Math.min(video.videoWidth, tileWidth);
+		canvas.height = Math.round(video.videoHeight * canvas.width / video.videoWidth);
+		try {
+			canvas.getContext("2d")?.drawImage(video, 0, 0, canvas.width, canvas.height);
+			video.poster = canvas.toDataURL("image/jpeg", .8);
+		} catch {}
+	}
+	function clearOffscreenTimer() {
+		clearTimeout(offscreenTimer);
+		offscreenTimer = void 0;
+	}
+	function clearResumeTimer() {
+		clearTimeout(resumeTimer);
+		resumeTimer = void 0;
+	}
+	function syncOffscreen() {
+		if (!offscreen.value) {
+			clearOffscreenTimer();
+			if (stoppedOffscreen) scheduleResume();
+			return;
+		}
+		clearResumeTimer();
+		if (isPip.value || keepAwake.value || paused.value || !isRunning()) {
+			clearOffscreenTimer();
+			return;
+		}
+		offscreenTimer ??= setTimeout(stopOffscreen, seenInViewport ? OFFSCREEN_STOP_DELAY_MS : 0);
+	}
+	function deferUntilSeen() {
+		if (!offscreen.value || seenInViewport) return false;
+		stoppedOffscreen = true;
+		return true;
+	}
+	function stopOffscreen() {
+		offscreenTimer = void 0;
+		if (!offscreen.value || isPip.value || keepAwake.value || paused.value || activityModeManager.inStandby.value || !isRunning()) return;
+		if (isVideoInPictureInPicture(videoElement.value)) {
+			isPip.value = true;
+			return;
+		}
+		if (registeredCamName && streamManager.getRefCount(registeredCamName) > 1) {
+			offscreenTimer = setTimeout(stopOffscreen, OFFSCREEN_STOP_DELAY_MS);
+			return;
+		}
+		capturePoster();
+		currentStream.value?.stop();
+		stoppedOffscreen = true;
+	}
+	function scheduleResume() {
+		resumeTimer ??= setTimeout(() => {
+			resumeTimer = void 0;
+			if (offscreen.value || !stoppedOffscreen) return;
+			stoppedOffscreen = false;
+			if (isCameraDisabled.value || !shouldAutoStart() || activityModeManager.inStandby.value) return;
+			if (status.value === "idle" || status.value === "closed") currentStream.value?.start();
+		}, acquireAutoStaggerDelay());
+	}
 	function initializeIsolated() {
 		if (initialized.value) return;
 		const container = containerElement.value;
@@ -4368,10 +6209,11 @@ function useCameraStream(options) {
 		initialized.value = true;
 		isUsingCachedStream.value = false;
 		currentStream.value = ownedStream;
+		cleanupFns.push(streamManager.track(ownedStream));
 		const video = createVideoElement();
 		videoElement.value = video;
 		streamVideoElementRef.value = video;
-		if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value) ownedStream.start();
+		if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value && !deferUntilSeen()) ownedStream.start();
 	}
 	function initialize() {
 		if (initialized.value) return;
@@ -4422,7 +6264,7 @@ function useCameraStream(options) {
 			videoElement.value = video;
 			cached.videoElementRef.value = video;
 			setupCachedStreamWatchers(cached.stream, video, camName);
-			if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value) {
+			if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value && !deferUntilSeen()) {
 				if (cached.stream.activeMode.value !== "mse") attachCachedStream(cached, video, camName);
 				else video.play().catch(() => {});
 			}
@@ -4435,7 +6277,7 @@ function useCameraStream(options) {
 			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();
+			if (shouldAutoStart() && autoStartReady.value && activityModeManager.mode.value === "always-on" && !isCameraDisabled.value && !deferUntilSeen()) ownedStream.start();
 			const stopPlayingWatch = watch(() => ownedStream.isPlaying.value, (playing) => {
 				if (playing && video.srcObject instanceof MediaStream) streamManager.updateMediaStream(camName, video.srcObject);
 			}, { immediate: true });
@@ -4539,9 +6381,20 @@ function useCameraStream(options) {
 	function setActivityMode(mode) {
 		activityModeManager.setMode(mode);
 	}
+	function syncActivityMode() {
+		const mode = toValue(options.activityMode);
+		if (mode && mode !== activityModeManager.mode.value) activityModeManager.setMode(mode);
+	}
 	function reportActivity(detected) {
 		activityModeManager.reportActivity(detected);
 	}
+	function resetIdleTimer() {
+		activityModeManager.resetIdleTimer();
+	}
+	function setKeepAwake(awake) {
+		keepAwake.value = awake;
+		activityModeManager.setKeepAwake(awake);
+	}
 	function setMuted(newMuted) {
 		currentStream.value?.setMuted(newMuted);
 		const video = videoElement.value;
@@ -4573,6 +6426,8 @@ function useCameraStream(options) {
 			clearTimeout(startDelayTimer);
 			startDelayTimer = void 0;
 		}
+		clearOffscreenTimer();
+		clearResumeTimer();
 		currentStream.value?.setMuted(true);
 		const video = videoElement.value;
 		if (video) video.muted = true;
@@ -4603,19 +6458,37 @@ function useCameraStream(options) {
 			else for (const [name, active] of Object.entries(cls)) canvas.classList.toggle(name, !!active);
 		}
 	}
-	if (!isolated && typeof IntersectionObserver !== "undefined") {
+	if (typeof IntersectionObserver !== "undefined") {
 		let visibilityObserver;
 		const stopVisibilityWatch = watch(containerElement, (container) => {
 			visibilityObserver?.disconnect();
 			visibilityObserver = void 0;
 			if (!container) return;
+			const tileHeight = Math.round(container.getBoundingClientRect().height);
+			const margin = tileHeight > 0 ? `${tileHeight}px 0px` : "25% 0px";
 			visibilityObserver = new IntersectionObserver((entries) => {
-				if (entries.some((e) => e.isIntersecting)) reclaimSharedVideo();
+				const entry = entries[entries.length - 1];
+				if (!entry) return;
+				offscreen.value = !entry.isIntersecting;
+				if (!entry.isIntersecting) return;
+				seenInViewport = true;
+				reclaimSharedVideo();
+			}, {
+				rootMargin: margin,
+				scrollMargin: margin
 			});
 			visibilityObserver.observe(container);
 		}, { immediate: true });
+		const stopOffscreenWatch = watch([
+			offscreen,
+			status,
+			isPip,
+			keepAwake,
+			paused
+		], syncOffscreen);
 		cleanupFns.push(() => {
 			stopVisibilityWatch();
+			stopOffscreenWatch();
 			visibilityObserver?.disconnect();
 		});
 	}
@@ -4676,19 +6549,19 @@ function useCameraStream(options) {
 		if (oldVideo) {
 			oldVideo.removeEventListener("enterpictureinpicture", onEnterPip);
 			oldVideo.removeEventListener("leavepictureinpicture", onLeavePip);
+			oldVideo.removeEventListener("webkitpresentationmodechanged", onPresentationModeChange);
 		}
 		if (video) {
 			video.addEventListener("enterpictureinpicture", onEnterPip);
 			video.addEventListener("leavepictureinpicture", onLeavePip);
+			video.addEventListener("webkitpresentationmodechanged", onPresentationModeChange);
 		}
 	}, { immediate: true });
 	cleanupFns.push(stopPipWatch);
 	watch([containerElement, videoElement], ([container, video]) => {
 		if (container && video) insertVideoIntoContainer(video, container);
 	}, { immediate: true });
-	watch(() => toValue(options.activityMode), (newMode) => {
-		if (newMode && newMode !== activityModeManager.mode.value) activityModeManager.setMode(newMode);
-	});
+	watch(() => toValue(options.activityMode), syncActivityMode);
 	watch([
 		containerElement,
 		resolvedCameraDevice,
@@ -4696,18 +6569,32 @@ function useCameraStream(options) {
 		autoStartReady
 	], () => {
 		if (!initialized.value) initialize();
-		else if (autoStartReady.value && shouldAutoStart() && activityModeManager.mode.value === "always-on" && !isPlaying.value && status.value === "idle" && !isCameraDisabled.value) currentStream.value?.start();
+		else if (autoStartReady.value && shouldAutoStart() && activityModeManager.mode.value === "always-on" && !isPlaying.value && status.value === "idle" && !isCameraDisabled.value && !deferUntilSeen()) currentStream.value?.start();
+	}, { immediate: true });
+	let activityEngaged = false;
+	watch(() => initialized.value && autoStartReady.value && shouldAutoStart() && !isCameraDisabled.value, (ready) => {
+		if (!ready || activityEngaged) return;
+		activityEngaged = true;
+		syncActivityMode();
+		activityModeManager.engage();
 	}, { immediate: true });
+	watch(isPlaying, (playing) => {
+		if (!playing) return;
+		activityModeManager.resetIdleTimer();
+		const video = videoElement.value;
+		if (video && video.poster !== EMPTY_POSTER) video.poster = EMPTY_POSTER;
+	});
 	watch(isCameraDisabled, (disabled, wasDisabled) => {
 		if (!initialized.value) return;
 		if (!wasDisabled && disabled) currentStream.value?.stop();
-		else if (wasDisabled && !disabled && shouldAutoStart()) currentStream.value?.restart();
+		else if (wasDisabled && !disabled && shouldAutoStart() && !activityModeManager.inStandby.value) currentStream.value?.restart();
 	});
 	onBeforeUnmount(cleanup);
 	tryOnScopeDispose(cleanup);
 	return {
 		status,
 		isPlaying,
+		stalled,
 		activeMode,
 		activeResolution,
 		degradedFrom,
@@ -4743,6 +6630,8 @@ function useCameraStream(options) {
 		setMicrophone,
 		setActivityMode,
 		reportActivity,
+		resetIdleTimer,
+		setKeepAwake,
 		setMuted,
 		play: playStream,
 		pause: pauseStream,
@@ -4762,73 +6651,9 @@ function useCoreManager() {
 		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)),
-		getCloudServerId: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getCloudServerId())
-	};
-}
-//#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
+		getCloudServerId: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getCloudServerId()),
+		getRestoreGeneration: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getRestoreGeneration()),
+		getInstanceId: () => rpcCall(ctx.rpc, (rpc) => proxy(rpc).getInstanceId())
 	};
 }
 //#endregion
@@ -4848,6 +6673,10 @@ function useTerminal() {
 	let streamAbortController;
 	let currentOptions;
 	let streamGen = 0;
+	let stream;
+	let streamClient;
+	let wentOffline = false;
+	let keptAcrossBlip = false;
 	const proxy = (r) => r.createProxy(namespaces.terminalManagerRpc);
 	async function connect(options) {
 		if (isConnecting.value || isConnected.value) return;
@@ -4861,11 +6690,13 @@ function useTerminal() {
 				cwd: options?.cwd,
 				shell: options?.shell,
 				env: options?.env
-			}));
+			}), { maxRetries: 0 });
 			sessionId.value = session.sessionId;
 			dimensions.value = session.dimensions;
 			isConnected.value = true;
 			streamAbortController = new AbortController();
+			wentOffline = false;
+			keptAcrossBlip = false;
 			const gen = ++streamGen;
 			consumeOutputStream(session.sessionId, options, gen);
 		} catch (err) {
@@ -4879,18 +6710,26 @@ function useTerminal() {
 		try {
 			const current = rpc.value;
 			if (!current) return;
-			for await (const chunk of proxy(current).generateOutput(sid)) {
+			const output = proxy(current).generateOutput(sid);
+			stream = output;
+			streamClient = current;
+			for await (const chunk of output) {
 				if (gen !== streamGen || streamAbortController?.signal.aborted) break;
 				options?.onData?.(chunk);
 			}
 		} catch (err) {
 			if (gen === streamGen && !streamAbortController?.signal.aborted) {
+				if (keptAcrossBlip) {
+					restart();
+					return;
+				}
 				error.value = err instanceof Error ? err : new Error(String(err));
 				options?.onError?.(error.value);
 			}
 		} finally {
 			if (gen === streamGen && !streamAbortController?.signal.aborted) {
 				isConnected.value = false;
+				closeRemote(sid);
 				options?.onClose?.();
 			}
 		}
@@ -4915,32 +6754,53 @@ function useTerminal() {
 		}
 	}
 	async function close() {
-		streamAbortController?.abort();
-		streamGen++;
-		if (sessionId.value) try {
-			await rpcCall(rpc, (r) => proxy(r).closeSession(sessionId.value), {
-				awaitConnect: false,
-				maxRetries: 0
-			});
-		} catch {}
+		stopStream();
+		if (sessionId.value) await closeRemote(sessionId.value);
 		sessionId.value = void 0;
 		isConnected.value = false;
 		currentOptions = void 0;
 	}
-	function handleReconnected() {
-		if (!sessionId.value && !isConnected.value) return;
-		const savedOptions = currentOptions;
+	function stopStream() {
 		streamAbortController?.abort();
 		streamGen++;
+		stream?.return(void 0).catch(() => void 0);
+		stream = void 0;
+		streamClient = void 0;
+		keptAcrossBlip = false;
+	}
+	function closeRemote(sid) {
+		return rpcCall(rpc, (r) => proxy(r).closeSession(sid), {
+			awaitConnect: false,
+			maxRetries: 0
+		}).catch(() => void 0);
+	}
+	function restart() {
+		const savedOptions = currentOptions;
+		const sid = sessionId.value;
+		stopStream();
+		if (sid) closeRemote(sid);
 		sessionId.value = void 0;
 		isConnected.value = false;
 		currentOptions = void 0;
 		savedOptions?.onClose?.();
 		if (savedOptions) connect(savedOptions);
 	}
+	function handleReconnected() {
+		if (!sessionId.value && !isConnected.value) return;
+		if (isConnected.value && !wentOffline && rpc.value === streamClient) {
+			keptAcrossBlip = true;
+			return;
+		}
+		restart();
+	}
+	function handleDisconnected() {
+		wentOffline = true;
+	}
 	cameraUi.on("reconnected", handleReconnected);
+	cameraUi.on("disconnected", handleDisconnected);
 	tryOnScopeDispose(() => {
 		cameraUi.off("reconnected", handleReconnected);
+		cameraUi.off("disconnected", handleDisconnected);
 		close();
 	});
 	return {
@@ -4957,4 +6817,4 @@ function useTerminal() {
 	};
 }
 //#endregion
-export { CAMERA_UI_INJECTION_KEY, NamespaceManager, STREAM_CONFIG, acquireSensorManager, clearCameraCache, clearOAuthCache, clearPluginCache, clearSensorCache, clearSnapshotCache, clearStorageCache, createActivityMode, createCameraUiPlugin, createReactiveCameraDevice, createSensorManager, getSnapshotUrl, isReactiveAudioSensor, isReactiveBatteryInfo, isReactiveCarbonDioxideInfo, isReactiveCarbonMonoxideSensor, isReactiveClassifierSensor, isReactiveColdSensor, isReactiveContactSensor, isReactiveDoorbellTrigger, isReactiveFaceSensor, isReactiveGarageControl, isReactiveGasSensor, isReactiveHeatSensor, isReactiveHumidityInfo, isReactiveIlluminanceInfo, isReactiveLeakSensor, isReactiveLicensePlateSensor, isReactiveLightControl, isReactiveLockControl, isReactiveMotionSensor, isReactiveObjectSensor, isReactiveOccupancySensor, isReactivePTZControl, isReactivePowerSensor, isReactiveProblemSensor, isReactiveSecuritySystem, isReactiveSirenControl, isReactiveSmokeSensor, isReactiveSwitchControl, isReactiveTamperSensor, isReactiveTemperatureInfo, isReactiveVibrationSensor, refreshClientSubscriptions, releaseSensorManager, resetClientState, rpcCall, setFullscreenRoot, useAllSensors, useAudioSensor, useCameraById, useCameraStorage, useCameraStream, useCameraUi, useClassifierSensors, useCoreManager, useCuiFullscreen, useDeviceManager, useFaceSensor, useLicensePlateSensor, useMotionSensor, useOAuth, useObjectSensor, usePTZControl, usePlugin, usePluginStorage, useRpcCall, useRpcSubscription, useSensorById, useSensorByType, useSensorStorage, useSensors, useSensorsByType, useSnapshot, useTabVisibility, useTerminal, useTopmostFullscreenElement };
+export { CAMERA_UI_INJECTION_KEY, NamespaceManager, STREAM_CONFIG, acquireSensorManager, clearCameraCache, clearOAuthCache, clearPluginCache, clearSensorCache, clearSnapshotCache, clearStorageCache, createActivityMode, createCameraUiPlugin, createReactiveCameraDevice, createSensorManager, getSnapshotUrl, isReactiveAudioSensor, isReactiveBatteryInfo, isReactiveCarbonDioxideInfo, isReactiveCarbonMonoxideSensor, isReactiveClassifierSensor, isReactiveColdSensor, isReactiveContactSensor, isReactiveDoorbellTrigger, isReactiveFaceSensor, isReactiveGarageControl, isReactiveGasSensor, isReactiveHeatSensor, isReactiveHumidityInfo, isReactiveIlluminanceInfo, isReactiveLeakSensor, isReactiveLicensePlateSensor, isReactiveLightControl, isReactiveLockControl, isReactiveMotionSensor, isReactiveObjectSensor, isReactiveOccupancySensor, isReactivePTZControl, isReactivePowerSensor, isReactiveProblemSensor, isReactiveSecuritySystem, isReactiveSirenControl, isReactiveSmokeSensor, isReactiveSwitchControl, isReactiveTamperSensor, isReactiveTemperatureInfo, isReactiveVibrationSensor, refreshClientSubscriptions, releaseSensorManager, resetClientState, restartConnectedStreams, rpcCall, setFullscreenRoot, useAllSensors, useAudioSensor, useCameraById, useCameraStorage, useCameraStream, useCameraUi, useClassifierSensors, useCoreManager, useCuiFullscreen, useDeviceManager, useFaceSensor, useLicensePlateSensor, useMotionSensor, useOAuth, useObjectSensor, usePTZControl, usePlugin, usePluginStorage, useRpcCall, useRpcSubscription, useSensorById, useSensorByType, useSensorStorage, useSensors, useSensorsByType, useSnapshot, useTabVisibility, useTerminal, useTopmostFullscreenElement };