cursor-buddy 0.0.0-beta.2

package/dist/client-D-LeEdoH.mjs

@@ -0,0 +1,2254 @@
+import { atom } from "nanostores";
+import html2canvas from "html2canvas-pro";
+//#region src/core/atoms.ts
+/**
+* Nanostores atoms for reactive values that don't need state machine semantics.
+* These update frequently (e.g., 60fps audio levels) and are framework-agnostic.
+*/
+const $audioLevel = atom(0);
+const $cursorPosition = atom({
+	x: 0,
+	y: 0
+});
+const $buddyPosition = atom({
+	x: 0,
+	y: 0
+});
+const $buddyRotation = atom(0);
+const $buddyScale = atom(1);
+const $pointingTarget = atom(null);
+const $isEnabled = atom(true);
+atom(false);
+const $conversationHistory = atom([]);
+//#endregion
+//#region src/core/utils/error.ts
+/**
+* Normalize unknown thrown values into Error instances.
+*/
+function toError(error, fallbackMessage = "Unknown error") {
+	if (error instanceof Error) return error;
+	if (typeof error === "string" && error) return new Error(error);
+	return new Error(fallbackMessage);
+}
+//#endregion
+//#region src/core/services/audio-playback.ts
+/**
+* Framework-agnostic service for audio playback with abort support.
+*/
+var AudioPlaybackService = class {
+	audio = null;
+	currentUrl = null;
+	settlePlayback = null;
+	removeAbortListener = null;
+	/**
+	* Play audio from a blob. Stops any currently playing audio first.
+	* @param blob - Audio blob to play
+	* @param signal - Optional AbortSignal to cancel playback
+	* @returns Promise that resolves when playback completes
+	*/
+	async play(blob, signal) {
+		this.stop();
+		if (signal?.aborted) return;
+		const url = URL.createObjectURL(blob);
+		this.currentUrl = url;
+		this.audio = new Audio(url);
+		return new Promise((resolve, reject) => {
+			if (!this.audio) {
+				this.cleanup();
+				resolve();
+				return;
+			}
+			let settled = false;
+			const audio = this.audio;
+			const settle = (outcome, error) => {
+				if (settled) return;
+				settled = true;
+				if (this.settlePlayback === settle) this.settlePlayback = null;
+				this.removeAbortListener?.();
+				this.removeAbortListener = null;
+				if (this.audio === audio) {
+					this.audio.onended = null;
+					this.audio.onerror = null;
+					this.audio = null;
+				}
+				this.cleanup();
+				if (outcome === "resolve") {
+					resolve();
+					return;
+				}
+				reject(error ?? /* @__PURE__ */ new Error("Audio playback failed"));
+			};
+			this.settlePlayback = settle;
+			const abortHandler = () => {
+				audio.pause();
+				settle("resolve");
+			};
+			if (signal) {
+				signal.addEventListener("abort", abortHandler, { once: true });
+				this.removeAbortListener = () => {
+					signal.removeEventListener("abort", abortHandler);
+				};
+			}
+			this.audio.onended = () => {
+				settle("resolve");
+			};
+			this.audio.onerror = () => {
+				settle("reject", /* @__PURE__ */ new Error("Audio playback failed"));
+			};
+			this.audio.play().catch((err) => {
+				settle("reject", toError(err, "Audio playback failed"));
+			});
+		});
+	}
+	/**
+	* Stop any currently playing audio.
+	*/
+	stop() {
+		if (this.audio) this.audio.pause();
+		if (this.settlePlayback) {
+			const settlePlayback = this.settlePlayback;
+			this.settlePlayback = null;
+			settlePlayback("resolve");
+			return;
+		}
+		this.removeAbortListener?.();
+		this.removeAbortListener = null;
+		if (this.audio) {
+			this.audio.onended = null;
+			this.audio.onerror = null;
+			this.audio = null;
+		}
+		this.cleanup();
+	}
+	cleanup() {
+		if (this.currentUrl) {
+			URL.revokeObjectURL(this.currentUrl);
+			this.currentUrl = null;
+		}
+	}
+};
+//#endregion
+//#region src/core/utils/web-speech.ts
+/**
+* Normalize browser speech input and transcript output to a single-space form
+* so UI state and speech synthesis stay stable across browser event quirks.
+*/
+function normalizeSpeechText(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+/**
+* Resolve the best browser locale to use for Web Speech APIs.
+*
+* We prefer the document language when the host app declares one, then fall
+* back to the browser locale, and finally to English as a stable default.
+*/
+function resolveBrowserLanguage() {
+	if (typeof document !== "undefined") {
+		const documentLanguage = document.documentElement.lang.trim();
+		if (documentLanguage) return documentLanguage;
+	}
+	if (typeof navigator !== "undefined" && navigator.language) return navigator.language;
+	return "en-US";
+}
+//#endregion
+//#region src/core/services/browser-speech.ts
+function getSpeechSynthesis() {
+	return typeof globalThis.speechSynthesis === "undefined" ? void 0 : globalThis.speechSynthesis;
+}
+function getSpeechSynthesisUtterance() {
+	return typeof globalThis.SpeechSynthesisUtterance === "undefined" ? void 0 : globalThis.SpeechSynthesisUtterance;
+}
+function toSpeechError(event) {
+	const errorCode = event?.error;
+	return /* @__PURE__ */ new Error(errorCode ? `Browser speech failed: ${errorCode}` : "Browser speech failed");
+}
+/**
+* Browser-backed speech synthesis using the Web Speech API.
+*/
+var BrowserSpeechService = class {
+	removeAbortListener = null;
+	settleSpeech = null;
+	utterance = null;
+	/**
+	* Report whether this runtime exposes the browser Web Speech synthesis APIs.
+	*/
+	isAvailable() {
+		return Boolean(getSpeechSynthesis() && getSpeechSynthesisUtterance());
+	}
+	/**
+	* Speak a single text segment in the browser.
+	*
+	* Each queue item owns its own utterance. We only stop an existing utterance
+	* when this service still has one in flight, so streamed playback does not
+	* spam global `speechSynthesis.cancel()` between already-completed segments.
+	*/
+	async speak(text, signal) {
+		const speechSynthesis = getSpeechSynthesis();
+		const SpeechSynthesisUtteranceCtor = getSpeechSynthesisUtterance();
+		if (!speechSynthesis || !SpeechSynthesisUtteranceCtor) throw new Error("Browser speech is not supported");
+		if (this.hasActiveSpeech()) this.stop();
+		const normalizedText = normalizeSpeechText(text);
+		if (!normalizedText || signal?.aborted) return;
+		const utterance = new SpeechSynthesisUtteranceCtor(normalizedText);
+		utterance.lang = resolveBrowserLanguage();
+		this.utterance = utterance;
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			const settle = (outcome, error) => {
+				if (settled) return;
+				settled = true;
+				if (this.settleSpeech === settle) this.settleSpeech = null;
+				this.removeAbortListener?.();
+				this.removeAbortListener = null;
+				this.clearUtterance(utterance);
+				if (outcome === "resolve") {
+					resolve();
+					return;
+				}
+				reject(error ?? /* @__PURE__ */ new Error("Browser speech failed"));
+			};
+			this.settleSpeech = settle;
+			const abortHandler = () => {
+				try {
+					speechSynthesis.cancel();
+				} catch {}
+				settle("resolve");
+			};
+			if (signal) {
+				signal.addEventListener("abort", abortHandler, { once: true });
+				this.removeAbortListener = () => {
+					signal.removeEventListener("abort", abortHandler);
+				};
+			}
+			utterance.onend = () => {
+				settle("resolve");
+			};
+			utterance.onerror = (event) => {
+				if (signal?.aborted) {
+					settle("resolve");
+					return;
+				}
+				settle("reject", toSpeechError(event));
+			};
+			try {
+				speechSynthesis.speak(utterance);
+			} catch (error) {
+				settle("reject", toError(error, "Browser speech failed to start"));
+			}
+		});
+	}
+	/**
+	* Stop the current utterance owned by this service, if one is active.
+	*
+	* We intentionally do nothing when the service is idle so we do not cancel
+	* unrelated speech synthesis work that host apps may be doing elsewhere.
+	*/
+	stop() {
+		if (!this.hasActiveSpeech()) return;
+		const speechSynthesis = getSpeechSynthesis();
+		if (speechSynthesis) try {
+			speechSynthesis.cancel();
+		} catch {}
+		if (this.settleSpeech) {
+			const settleSpeech = this.settleSpeech;
+			this.settleSpeech = null;
+			settleSpeech("resolve");
+			return;
+		}
+		this.removeAbortListener?.();
+		this.removeAbortListener = null;
+		this.clearUtterance(this.utterance);
+	}
+	hasActiveSpeech() {
+		return Boolean(this.utterance || this.settleSpeech);
+	}
+	clearUtterance(utterance) {
+		if (!utterance) return;
+		utterance.onend = null;
+		utterance.onerror = null;
+		if (this.utterance === utterance) this.utterance = null;
+	}
+};
+//#endregion
+//#region src/core/services/live-transcription.ts
+function getSpeechRecognitionConstructor() {
+	const globalScope = globalThis;
+	return globalScope.SpeechRecognition ?? globalScope.webkitSpeechRecognition;
+}
+function toRecognitionError(event) {
+	const errorCode = event?.error;
+	const message = event?.message || (errorCode ? `Browser transcription failed: ${errorCode}` : "Browser transcription failed");
+	return new Error(message);
+}
+function buildTranscripts(results) {
+	let finalTranscript = "";
+	let interimTranscript = "";
+	for (let index = 0; index < results.length; index += 1) {
+		const result = results[index];
+		const transcript = (result?.[0])?.transcript ?? "";
+		if (!transcript) continue;
+		if (result.isFinal) finalTranscript += `${transcript} `;
+		else interimTranscript += `${transcript} `;
+	}
+	const normalizedFinal = normalizeSpeechText(finalTranscript);
+	return {
+		finalTranscript: normalizedFinal,
+		liveTranscript: normalizeSpeechText([normalizedFinal, normalizeSpeechText(interimTranscript)].filter(Boolean).join(" "))
+	};
+}
+/**
+* Browser-backed live transcription using the Web Speech API.
+*/
+var LiveTranscriptionService = class {
+	finalTranscript = "";
+	hasStarted = false;
+	hasEnded = false;
+	lastError = null;
+	partialCallback = null;
+	recognition = null;
+	startReject = null;
+	startResolve = null;
+	stopReject = null;
+	stopResolve = null;
+	isAvailable() {
+		return Boolean(getSpeechRecognitionConstructor());
+	}
+	/**
+	* Register a callback for the latest browser transcript while the user is
+	* still speaking.
+	*/
+	onPartial(callback) {
+		this.partialCallback = callback;
+	}
+	/**
+	* Start a new Web Speech recognition session.
+	*/
+	async start() {
+		const SpeechRecognitionCtor = getSpeechRecognitionConstructor();
+		if (!SpeechRecognitionCtor) throw new Error("Browser transcription is not supported");
+		this.dispose();
+		const recognition = new SpeechRecognitionCtor();
+		this.recognition = recognition;
+		recognition.continuous = true;
+		recognition.interimResults = true;
+		recognition.maxAlternatives = 1;
+		recognition.lang = resolveBrowserLanguage();
+		recognition.onstart = () => {
+			this.hasStarted = true;
+			this.startResolve?.();
+			this.startResolve = null;
+			this.startReject = null;
+		};
+		recognition.onresult = (event) => {
+			const transcripts = buildTranscripts(event.results);
+			this.finalTranscript = transcripts.finalTranscript;
+			this.partialCallback?.(transcripts.liveTranscript);
+		};
+		recognition.onerror = (event) => {
+			this.lastError = toRecognitionError(event);
+			if (!this.hasStarted) {
+				this.startReject?.(this.lastError);
+				this.startResolve = null;
+				this.startReject = null;
+			}
+		};
+		recognition.onend = () => {
+			this.hasEnded = true;
+			if (!this.hasStarted) {
+				const error = this.lastError ?? /* @__PURE__ */ new Error("Browser transcription ended before it could start");
+				this.startReject?.(error);
+				this.startResolve = null;
+				this.startReject = null;
+			}
+			if (this.stopResolve || this.stopReject) {
+				if (this.lastError) this.stopReject?.(this.lastError);
+				else this.stopResolve?.(normalizeSpeechText(this.finalTranscript));
+				this.stopResolve = null;
+				this.stopReject = null;
+			}
+		};
+		const started = new Promise((resolve, reject) => {
+			this.startResolve = resolve;
+			this.startReject = reject;
+		});
+		try {
+			recognition.start();
+		} catch (error) {
+			this.clearRecognition();
+			throw toError(error, "Browser transcription failed to start");
+		}
+		try {
+			await started;
+		} catch (error) {
+			this.clearRecognition();
+			throw toError(error, "Browser transcription failed to start");
+		}
+	}
+	/**
+	* Stop the current recognition session and resolve with the final transcript.
+	*/
+	async stop() {
+		if (!this.recognition) {
+			if (this.lastError) throw this.lastError;
+			return normalizeSpeechText(this.finalTranscript);
+		}
+		if (this.hasEnded) {
+			const transcript = normalizeSpeechText(this.finalTranscript);
+			const error = this.lastError;
+			this.clearRecognition();
+			if (error) throw error;
+			return transcript;
+		}
+		const recognition = this.recognition;
+		return normalizeSpeechText(await new Promise((resolve, reject) => {
+			this.stopResolve = resolve;
+			this.stopReject = reject;
+			try {
+				recognition.stop();
+			} catch (error) {
+				reject(toError(error, "Browser transcription failed to stop"));
+			}
+		}).finally(() => {
+			this.clearRecognition();
+		}));
+	}
+	/**
+	* Abort the current recognition session and reset the service for reuse.
+	*/
+	dispose() {
+		if (this.recognition) try {
+			this.recognition.abort();
+		} catch {}
+		this.startReject?.(/* @__PURE__ */ new Error("Browser transcription aborted"));
+		this.stopResolve?.(normalizeSpeechText(this.finalTranscript));
+		this.startResolve = null;
+		this.startReject = null;
+		this.stopResolve = null;
+		this.stopReject = null;
+		this.clearRecognition();
+		this.resetSessionState();
+	}
+	clearRecognition() {
+		if (!this.recognition) return;
+		this.recognition.onstart = null;
+		this.recognition.onresult = null;
+		this.recognition.onerror = null;
+		this.recognition.onend = null;
+		this.recognition = null;
+	}
+	resetSessionState() {
+		this.finalTranscript = "";
+		this.hasStarted = false;
+		this.hasEnded = false;
+		this.lastError = null;
+		this.partialCallback?.("");
+	}
+};
+//#endregion
+//#region src/core/bezier.ts
+/**
+* Bezier flight animation for cursor pointing.
+*/
+/**
+* Quadratic bezier curve: B(t) = (1-t)²P₀ + 2(1-t)t·P₁ + t²P₂
+*/
+function quadraticBezier(p0, p1, p2, t) {
+	const oneMinusT = 1 - t;
+	return {
+		x: oneMinusT * oneMinusT * p0.x + 2 * oneMinusT * t * p1.x + t * t * p2.x,
+		y: oneMinusT * oneMinusT * p0.y + 2 * oneMinusT * t * p1.y + t * t * p2.y
+	};
+}
+/**
+* Bezier tangent (derivative): B'(t) = 2(1-t)(P₁-P₀) + 2t(P₂-P₁)
+*/
+function bezierTangent(p0, p1, p2, t) {
+	const oneMinusT = 1 - t;
+	return {
+		x: 2 * oneMinusT * (p1.x - p0.x) + 2 * t * (p2.x - p1.x),
+		y: 2 * oneMinusT * (p1.y - p0.y) + 2 * t * (p2.y - p1.y)
+	};
+}
+/**
+* Ease-in-out cubic for smooth acceleration/deceleration
+*/
+function easeInOutCubic(t) {
+	return t < .5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
+}
+/**
+* Animate cursor along a parabolic bezier arc from start to end.
+* Used when the AI points at a UI element.
+*
+* @param from - Starting position
+* @param to - Target position
+* @param durationMs - Flight duration in milliseconds
+* @param callbacks - Frame and completion callbacks
+* @returns Cancel function to stop the animation
+*/
+function animateBezierFlight(from, to, durationMs, callbacks) {
+	const startTime = performance.now();
+	const distance = Math.hypot(to.x - from.x, to.y - from.y);
+	const controlPoint = {
+		x: (from.x + to.x) / 2,
+		y: Math.min(from.y, to.y) - distance * .2
+	};
+	let animationFrameId;
+	function animate(now) {
+		const elapsed = now - startTime;
+		const linearProgress = Math.min(elapsed / durationMs, 1);
+		const easedProgress = easeInOutCubic(linearProgress);
+		const position = quadraticBezier(from, controlPoint, to, easedProgress);
+		const tangent = bezierTangent(from, controlPoint, to, easedProgress);
+		const rotation = Math.atan2(tangent.y, tangent.x);
+		const scale = 1 + Math.sin(linearProgress * Math.PI) * .3;
+		callbacks.onFrame(position, rotation, scale);
+		if (linearProgress < 1) animationFrameId = requestAnimationFrame(animate);
+		else callbacks.onComplete();
+	}
+	animationFrameId = requestAnimationFrame(animate);
+	return () => cancelAnimationFrame(animationFrameId);
+}
+//#endregion
+//#region src/core/services/pointer-controller.ts
+const POINTING_LOCK_TIMEOUT_MS = 1e4;
+/**
+* Controller for cursor pointing behavior.
+* Manages the pointer state machine (follow -> flying -> anchored -> follow)
+* and cursor animation.
+*/
+var PointerController = class {
+	mode = "follow";
+	cancelAnimation = null;
+	releaseTimeout = null;
+	listeners = /* @__PURE__ */ new Set();
+	/**
+	* Animate cursor to point at a target.
+	*/
+	pointAt(target) {
+		this.release();
+		this.mode = "flying";
+		$pointingTarget.set(target);
+		const startPos = $buddyPosition.get();
+		const endPos = {
+			x: target.x,
+			y: target.y
+		};
+		this.cancelAnimation = animateBezierFlight(startPos, endPos, 800, {
+			onFrame: (position, rotation, scale) => {
+				$buddyPosition.set(position);
+				$buddyRotation.set(rotation);
+				$buddyScale.set(scale);
+			},
+			onComplete: () => {
+				this.cancelAnimation = null;
+				this.mode = "anchored";
+				$buddyPosition.set(endPos);
+				$buddyRotation.set(0);
+				$buddyScale.set(1);
+				this.scheduleRelease();
+				this.notify();
+			}
+		});
+		this.notify();
+	}
+	/**
+	* Release the cursor from pointing mode back to follow mode.
+	*/
+	release() {
+		if (this.cancelAnimation) {
+			this.cancelAnimation();
+			this.cancelAnimation = null;
+		}
+		if (this.releaseTimeout) {
+			clearTimeout(this.releaseTimeout);
+			this.releaseTimeout = null;
+		}
+		this.mode = "follow";
+		$pointingTarget.set(null);
+		$buddyPosition.set($cursorPosition.get());
+		$buddyRotation.set(0);
+		$buddyScale.set(1);
+		this.notify();
+	}
+	/**
+	* Check if cursor is currently pointing (flying or anchored).
+	*/
+	isPointing() {
+		return this.mode !== "follow";
+	}
+	/**
+	* Get current pointer mode.
+	*/
+	getMode() {
+		return this.mode;
+	}
+	/**
+	* Subscribe to pointer state changes.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Update buddy position to follow cursor when in follow mode.
+	* Call this on cursor position changes.
+	*/
+	updateFollowPosition() {
+		if (this.mode === "follow") {
+			$buddyPosition.set($cursorPosition.get());
+			$buddyRotation.set(0);
+			$buddyScale.set(1);
+		}
+	}
+	scheduleRelease() {
+		this.releaseTimeout = setTimeout(() => {
+			this.releaseTimeout = null;
+			this.release();
+		}, POINTING_LOCK_TIMEOUT_MS);
+	}
+	notify() {
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#endregion
+//#region src/core/utils/annotations.ts
+const DEFAULT_STYLE = {
+	borderColor: "rgba(255, 0, 0, 0.8)",
+	labelBackground: "rgba(255, 0, 0, 0.9)",
+	labelColor: "#ffffff",
+	borderWidth: 2,
+	fontSize: 15,
+	labelPadding: 4
+};
+/**
+* Draw annotation markers onto a canvas.
+* Modifies the canvas in place.
+*
+* @param ctx Canvas 2D context to draw on
+* @param markers Marker map from element discovery
+* @param style Optional style overrides
+*/
+function drawAnnotations(ctx, markers, style = {}) {
+	const s = {
+		...DEFAULT_STYLE,
+		...style
+	};
+	ctx.save();
+	for (const marker of markers.values()) {
+		const { rect, id } = marker;
+		ctx.strokeStyle = s.borderColor;
+		ctx.lineWidth = s.borderWidth;
+		ctx.strokeRect(rect.left, rect.top, rect.width, rect.height);
+		const label = String(id);
+		ctx.font = `bold ${s.fontSize}px monospace`;
+		const textWidth = ctx.measureText(label).width;
+		const textHeight = s.fontSize;
+		const labelWidth = textWidth + s.labelPadding * 2;
+		const labelHeight = textHeight + s.labelPadding;
+		const labelX = rect.left - s.borderWidth;
+		const labelY = rect.top < labelHeight + 4 ? rect.top + 2 : rect.top - labelHeight;
+		ctx.fillStyle = s.labelBackground;
+		ctx.beginPath();
+		ctx.roundRect(labelX, labelY, labelWidth, labelHeight, 2);
+		ctx.fill();
+		ctx.fillStyle = s.labelColor;
+		ctx.textBaseline = "top";
+		ctx.fillText(label, labelX + s.labelPadding, labelY + s.labelPadding / 2);
+	}
+	ctx.restore();
+}
+/**
+* Create an annotated copy of a canvas.
+* Does not modify the original canvas.
+*
+* @param sourceCanvas Original screenshot canvas
+* @param markers Marker map from element discovery
+* @returns New canvas with annotations drawn
+*/
+function createAnnotatedCanvas(sourceCanvas, markers) {
+	const canvas = document.createElement("canvas");
+	canvas.width = sourceCanvas.width;
+	canvas.height = sourceCanvas.height;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) throw new Error("Failed to get canvas 2D context");
+	ctx.drawImage(sourceCanvas, 0, 0);
+	drawAnnotations(ctx, markers);
+	return canvas;
+}
+/**
+* Generate marker context string for AI prompt.
+* Lists available markers with their descriptions.
+*
+* @param markers Marker map from element discovery
+* @returns Formatted string listing markers
+*/
+function generateMarkerContext(markers) {
+	if (markers.size === 0) return "No interactive elements detected.";
+	const lines = ["Interactive elements (use marker number to point):"];
+	for (const marker of markers.values()) lines.push(`  ${marker.id}: ${marker.description}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/core/utils/elements.ts
+/**
+* Element discovery for annotated screenshots.
+* Finds visible interactive elements and assigns marker IDs.
+*/
+/** Max characters for element descriptions passed to the model. */
+const MAX_DESCRIPTION_LENGTH = 50;
+/** Pixels tolerance for grouping elements into the same visual row. */
+const ROW_TOLERANCE_PX = 20;
+/**
+* Interactive element selectors - elements users would want to click/interact with.
+* Mirrors accessibility roles from agent-browser but using CSS selectors.
+*/
+const INTERACTIVE_SELECTORS = [
+	"button",
+	"[role=\"button\"]",
+	"input[type=\"button\"]",
+	"input[type=\"submit\"]",
+	"input[type=\"reset\"]",
+	"a[href]",
+	"[role=\"link\"]",
+	"input:not([type=\"hidden\"])",
+	"textarea",
+	"select",
+	"[role=\"textbox\"]",
+	"[role=\"searchbox\"]",
+	"[role=\"combobox\"]",
+	"[role=\"listbox\"]",
+	"[role=\"slider\"]",
+	"[role=\"spinbutton\"]",
+	"[role=\"checkbox\"]",
+	"[role=\"radio\"]",
+	"[role=\"switch\"]",
+	"[role=\"menuitem\"]",
+	"[role=\"menuitemcheckbox\"]",
+	"[role=\"menuitemradio\"]",
+	"[role=\"option\"]",
+	"[role=\"tab\"]",
+	"[role=\"treeitem\"]",
+	"video",
+	"audio",
+	"[data-cursor-buddy-interactive]"
+];
+/**
+* Check if an element is visible in the viewport.
+*/
+function isElementVisible(element, rect = element.getBoundingClientRect()) {
+	if (rect.width <= 0 || rect.height <= 0) return false;
+	if (rect.bottom < 0 || rect.top > window.innerHeight || rect.right < 0 || rect.left > window.innerWidth) return false;
+	const style = window.getComputedStyle(element);
+	if (style.visibility === "hidden" || style.display === "none") return false;
+	if (Number.parseFloat(style.opacity) === 0) return false;
+	return true;
+}
+function truncateDescription(value) {
+	return value.slice(0, MAX_DESCRIPTION_LENGTH);
+}
+/**
+* Generate a brief description for an element.
+*/
+function describeElement(element) {
+	const tag = element.tagName.toLowerCase();
+	const ariaLabel = element.getAttribute("aria-label");
+	if (ariaLabel) return truncateDescription(ariaLabel);
+	if (tag === "button" || tag === "a") {
+		const text = element.textContent?.trim();
+		if (text) return truncateDescription(text);
+	}
+	if (tag === "input" || tag === "textarea") {
+		const placeholder = element.getAttribute("placeholder");
+		if (placeholder) return truncateDescription(placeholder);
+		return `${element.getAttribute("type") || "text"} input`;
+	}
+	if (tag === "img") {
+		const alt = element.getAttribute("alt");
+		if (alt) return truncateDescription(alt);
+		return "image";
+	}
+	const role = element.getAttribute("role");
+	if (role) return role;
+	return tag;
+}
+function collectVisibleInteractiveElements() {
+	const selector = INTERACTIVE_SELECTORS.join(",");
+	const allElements = document.querySelectorAll(selector);
+	const visible = [];
+	for (const element of allElements) {
+		const rect = element.getBoundingClientRect();
+		if (!isElementVisible(element, rect)) continue;
+		visible.push({
+			element,
+			rect
+		});
+	}
+	visible.sort((a, b) => {
+		const rowDiff = Math.floor(a.rect.top / ROW_TOLERANCE_PX) - Math.floor(b.rect.top / ROW_TOLERANCE_PX);
+		if (rowDiff !== 0) return rowDiff;
+		return a.rect.left - b.rect.left;
+	});
+	return visible;
+}
+/**
+* Create marker map from visible interactive elements.
+* Assigns sequential IDs starting from 1.
+*/
+function createMarkerMap() {
+	const elements = collectVisibleInteractiveElements();
+	const map = /* @__PURE__ */ new Map();
+	elements.forEach(({ element, rect }, index) => {
+		const id = index + 1;
+		map.set(id, {
+			id,
+			element,
+			rect,
+			description: describeElement(element)
+		});
+	});
+	return map;
+}
+/**
+* Get the center point of an element in viewport coordinates.
+*/
+function getElementCenter(element) {
+	const rect = element.getBoundingClientRect();
+	return {
+		x: Math.round(rect.left + rect.width / 2),
+		y: Math.round(rect.top + rect.height / 2)
+	};
+}
+/**
+* Resolve a marker ID to viewport coordinates.
+* Returns null if marker not found or element no longer visible.
+*/
+function resolveMarkerToCoordinates(markerMap, markerId) {
+	const marker = markerMap.get(markerId);
+	if (!marker) return null;
+	if (!document.contains(marker.element)) return null;
+	if (!isElementVisible(marker.element)) return null;
+	return getElementCenter(marker.element);
+}
+//#endregion
+//#region src/core/utils/screenshot.ts
+const CLONE_RESOURCE_TIMEOUT_MS = 3e3;
+/** Maximum width for compressed screenshots (maintains aspect ratio) */
+const MAX_SCREENSHOT_WIDTH = 1280;
+/** JPEG quality for compressed screenshots (0-1) */
+const JPEG_QUALITY = .8;
+/**
+* Compress a canvas image by downscaling and converting to JPEG.
+* Maintains aspect ratio and falls back to original if compression fails.
+*
+* @param sourceCanvas - The source canvas to compress
+* @param maxWidth - Maximum width for the compressed image (default: MAX_SCREENSHOT_WIDTH)
+* @param quality - JPEG quality 0-1 (default: JPEG_QUALITY)
+* @returns Compression result with compressed image data and dimensions
+*/
+function compressImage(sourceCanvas, maxWidth = MAX_SCREENSHOT_WIDTH, quality = JPEG_QUALITY) {
+	const sourceWidth = sourceCanvas.width;
+	const sourceHeight = sourceCanvas.height;
+	if (sourceWidth <= maxWidth) return {
+		imageData: sourceCanvas.toDataURL("image/jpeg", quality),
+		width: sourceWidth,
+		height: sourceHeight
+	};
+	const scale = maxWidth / sourceWidth;
+	const targetWidth = Math.round(maxWidth);
+	const targetHeight = Math.round(sourceHeight * scale);
+	const canvas = document.createElement("canvas");
+	canvas.width = targetWidth;
+	canvas.height = targetHeight;
+	const ctx = canvas.getContext("2d");
+	if (!ctx) return {
+		imageData: sourceCanvas.toDataURL("image/jpeg", quality),
+		width: sourceWidth,
+		height: sourceHeight
+	};
+	ctx.imageSmoothingEnabled = true;
+	ctx.imageSmoothingQuality = "high";
+	ctx.drawImage(sourceCanvas, 0, 0, targetWidth, targetHeight);
+	return {
+		imageData: canvas.toDataURL("image/jpeg", quality),
+		width: targetWidth,
+		height: targetHeight
+	};
+}
+function getCaptureMetrics() {
+	return {
+		viewportWidth: window.innerWidth,
+		viewportHeight: window.innerHeight
+	};
+}
+function waitForNextPaint(doc) {
+	const view = doc.defaultView;
+	if (!view?.requestAnimationFrame) return Promise.resolve();
+	return new Promise((resolve) => {
+		view.requestAnimationFrame(() => {
+			view.requestAnimationFrame(() => resolve());
+		});
+	});
+}
+function isStylesheetReady(link) {
+	const sheet = link.sheet;
+	if (!sheet) return false;
+	try {
+		sheet.cssRules;
+		return true;
+	} catch (error) {
+		return error instanceof DOMException && error.name === "SecurityError";
+	}
+}
+function waitForStylesheetLink(link) {
+	if (isStylesheetReady(link)) return Promise.resolve();
+	return new Promise((resolve) => {
+		let settled = false;
+		let timeoutId = 0;
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			window.clearTimeout(timeoutId);
+			link.removeEventListener("load", handleReady);
+			link.removeEventListener("error", handleReady);
+			resolve();
+		};
+		const handleReady = () => {
+			if (isStylesheetReady(link)) {
+				finish();
+				return;
+			}
+			window.requestAnimationFrame(() => {
+				if (isStylesheetReady(link)) finish();
+			});
+		};
+		timeoutId = window.setTimeout(finish, CLONE_RESOURCE_TIMEOUT_MS);
+		link.addEventListener("load", handleReady, { once: true });
+		link.addEventListener("error", finish, { once: true });
+		handleReady();
+	});
+}
+async function waitForClonedDocumentStyles(doc) {
+	const stylesheetLinks = Array.from(doc.querySelectorAll("link[rel=\"stylesheet\"][href]"));
+	await Promise.all(stylesheetLinks.map(waitForStylesheetLink));
+	if (doc.fonts?.ready) await doc.fonts.ready;
+	await waitForNextPaint(doc);
+}
+function getHtml2CanvasOptions(captureMetrics) {
+	return {
+		scale: 1,
+		useCORS: true,
+		logging: false,
+		width: captureMetrics.viewportWidth,
+		height: captureMetrics.viewportHeight,
+		windowWidth: captureMetrics.viewportWidth,
+		windowHeight: captureMetrics.viewportHeight,
+		x: window.scrollX,
+		y: window.scrollY,
+		scrollX: window.scrollX,
+		scrollY: window.scrollY,
+		onclone: async (doc) => {
+			await waitForClonedDocumentStyles(doc);
+		}
+	};
+}
+/**
+* Create a fallback canvas when screenshot capture fails.
+* Returns a simple gray canvas with an error message.
+*/
+function createFallbackCanvas() {
+	const canvas = document.createElement("canvas");
+	canvas.width = window.innerWidth;
+	canvas.height = window.innerHeight;
+	const ctx = canvas.getContext("2d");
+	if (ctx) {
+		ctx.fillStyle = "#f0f0f0";
+		ctx.fillRect(0, 0, canvas.width, canvas.height);
+		ctx.fillStyle = "#666";
+		ctx.font = "16px sans-serif";
+		ctx.textAlign = "center";
+		ctx.fillText("Screenshot unavailable", canvas.width / 2, canvas.height / 2);
+	}
+	return canvas;
+}
+/**
+* Capture a screenshot of the current viewport.
+* Uses html2canvas to render the DOM to a canvas, then compresses to JPEG.
+* Falls back to a placeholder if capture fails (e.g., due to unsupported CSS).
+*/
+async function captureViewport() {
+	const captureMetrics = getCaptureMetrics();
+	let canvas;
+	try {
+		canvas = await html2canvas(document.body, getHtml2CanvasOptions(captureMetrics));
+	} catch {
+		canvas = createFallbackCanvas();
+	}
+	let compressed;
+	try {
+		compressed = compressImage(canvas);
+	} catch {
+		compressed = {
+			imageData: canvas.toDataURL("image/png"),
+			width: canvas.width,
+			height: canvas.height
+		};
+	}
+	return {
+		imageData: compressed.imageData,
+		width: compressed.width,
+		height: compressed.height,
+		viewportWidth: captureMetrics.viewportWidth,
+		viewportHeight: captureMetrics.viewportHeight
+	};
+}
+/**
+* Capture an annotated screenshot of the current viewport.
+* Interactive elements are marked with numbered labels.
+* Returns both the annotated image and a marker map for resolving IDs.
+*/
+async function captureAnnotatedViewport() {
+	const captureMetrics = getCaptureMetrics();
+	const markerMap = createMarkerMap();
+	let sourceCanvas;
+	try {
+		sourceCanvas = await html2canvas(document.body, getHtml2CanvasOptions(captureMetrics));
+	} catch {
+		sourceCanvas = createFallbackCanvas();
+	}
+	const canvas = markerMap.size > 0 ? createAnnotatedCanvas(sourceCanvas, markerMap) : sourceCanvas;
+	const markerContext = generateMarkerContext(markerMap);
+	let compressed;
+	try {
+		compressed = compressImage(canvas);
+	} catch {
+		compressed = {
+			imageData: canvas.toDataURL("image/png"),
+			width: canvas.width,
+			height: canvas.height
+		};
+	}
+	return {
+		imageData: compressed.imageData,
+		width: compressed.width,
+		height: compressed.height,
+		viewportWidth: captureMetrics.viewportWidth,
+		viewportHeight: captureMetrics.viewportHeight,
+		markerMap,
+		markerContext
+	};
+}
+//#endregion
+//#region src/core/services/screen-capture.ts
+/**
+* Framework-agnostic service for capturing viewport screenshots.
+*/
+var ScreenCaptureService = class {
+	/**
+	* Capture a screenshot of the current viewport.
+	* @returns Screenshot result with image data and dimensions
+	*/
+	async capture() {
+		return captureViewport();
+	}
+	/**
+	* Capture an annotated screenshot with marker overlays.
+	* Interactive elements are marked with numbered labels.
+	* @returns Annotated screenshot result with marker map
+	*/
+	async captureAnnotated() {
+		return captureAnnotatedViewport();
+	}
+};
+//#endregion
+//#region src/core/services/tts-playback-queue.ts
+/**
+* Queues sentence-level speech preparation immediately while keeping playback
+* strictly ordered.
+*
+* Preparation is allowed to run ahead of playback so server synthesis can
+* overlap with the currently playing segment, but the returned playback tasks
+* still execute one-by-one in enqueue order.
+*/
+var TTSPlaybackQueue = class {
+	error = null;
+	hasStartedPlayback = false;
+	onError;
+	onPlaybackStart;
+	playbackChain = Promise.resolve();
+	prepare;
+	signal;
+	constructor(options) {
+		this.onError = options.onError;
+		this.onPlaybackStart = options.onPlaybackStart;
+		this.prepare = options.prepare;
+		this.signal = options.signal;
+	}
+	/**
+	* Queue a speakable text segment.
+	*/
+	enqueue(text) {
+		const normalizedText = text.trim();
+		if (!normalizedText || this.error || this.signal?.aborted) return;
+		const preparedPlaybackTask = this.prepare(normalizedText, this.signal);
+		preparedPlaybackTask.catch((error) => {
+			this.fail(toError(error));
+		});
+		this.playbackChain = this.playbackChain.then(async () => {
+			if (this.signal?.aborted) return;
+			const play = await preparedPlaybackTask;
+			if (this.signal?.aborted) return;
+			if (!this.hasStartedPlayback) {
+				this.hasStartedPlayback = true;
+				this.onPlaybackStart?.();
+			}
+			await play();
+		}).catch((error) => {
+			this.fail(toError(error));
+		});
+	}
+	/**
+	* Wait until every queued segment has either played or the queue failed.
+	*/
+	async waitForCompletion() {
+		await this.playbackChain;
+		if (this.error) throw this.error;
+	}
+	fail(error) {
+		if (this.error) return;
+		this.error = error;
+		this.onError?.(error);
+	}
+};
+//#endregion
+//#region src/core/utils/audio.ts
+/**
+* Audio conversion utilities for voice capture.
+* Converts Float32 audio data to WAV format for server transcription.
+*/
+/**
+* Merge multiple Float32Array chunks into a single array
+*/
+function mergeAudioChunks(chunks) {
+	const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+	const result = new Float32Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+/**
+* Convert Float32 audio data to 16-bit PCM
+*/
+function floatTo16BitPCM(output, offset, input) {
+	for (let i = 0; i < input.length; i++, offset += 2) {
+		const sample = Math.max(-1, Math.min(1, input[i]));
+		output.setInt16(offset, sample < 0 ? sample * 32768 : sample * 32767, true);
+	}
+}
+/**
+* Write a string to a DataView
+*/
+function writeString(view, offset, string) {
+	for (let i = 0; i < string.length; i++) view.setUint8(offset + i, string.charCodeAt(i));
+}
+/**
+* Encode Float32 audio data as a WAV file
+*/
+function encodeWAV(samples, sampleRate) {
+	const numChannels = 1;
+	const bitsPerSample = 16;
+	const bytesPerSample = bitsPerSample / 8;
+	const blockAlign = numChannels * bytesPerSample;
+	const dataLength = samples.length * bytesPerSample;
+	const buffer = new ArrayBuffer(44 + dataLength);
+	const view = new DataView(buffer);
+	writeString(view, 0, "RIFF");
+	view.setUint32(4, 36 + dataLength, true);
+	writeString(view, 8, "WAVE");
+	writeString(view, 12, "fmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, numChannels, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, sampleRate * blockAlign, true);
+	view.setUint16(32, blockAlign, true);
+	view.setUint16(34, bitsPerSample, true);
+	writeString(view, 36, "data");
+	view.setUint32(40, dataLength, true);
+	floatTo16BitPCM(view, 44, samples);
+	return new Blob([buffer], { type: "audio/wav" });
+}
+//#endregion
+//#region src/core/utils/audio-worklet.ts
+/**
+* AudioWorklet processor code for voice capture.
+* Inlined as a blob URL to avoid separate file serving requirements.
+*/
+const workletCode = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super()
+    this.isRecording = true
+    this.audioChunkSize = 2048
+    this.audioBuffer = new Float32Array(this.audioChunkSize)
+    this.audioBufferIndex = 0
+    this.levelFramesPerUpdate = 4
+    this.levelFrameCount = 0
+    this.levelRmsSum = 0
+    this.levelPeak = 0
+
+    this.port.onmessage = (event) => {
+      if (event.data?.type === "flush") {
+        this.flushAudio()
+        this.flushLevel()
+        this.port.postMessage({ type: "flush-complete" })
+      }
+    }
+  }
+
+  flushAudio() {
+    if (this.audioBufferIndex === 0) return
+
+    const chunk = this.audioBuffer.slice(0, this.audioBufferIndex)
+    this.port.postMessage({
+      type: "audio",
+      data: chunk
+    })
+    this.audioBufferIndex = 0
+  }
+
+  flushLevel() {
+    if (this.levelFrameCount === 0) return
+
+    this.port.postMessage({
+      type: "level",
+      rms: this.levelRmsSum / this.levelFrameCount,
+      peak: this.levelPeak
+    })
+
+    this.levelFrameCount = 0
+    this.levelRmsSum = 0
+    this.levelPeak = 0
+  }
+
+  process(inputs) {
+    if (!this.isRecording) return false
+
+    const input = inputs[0]
+    if (input && input.length > 0) {
+      const channelData = input[0]
+      let sum = 0
+      let peak = 0
+      for (let i = 0; i < channelData.length; i++) {
+        const sample = channelData[i]
+        sum += sample * sample
+        const absolute = Math.abs(sample)
+        if (absolute > peak) peak = absolute
+      }
+
+      this.levelRmsSum += Math.sqrt(sum / channelData.length)
+      this.levelPeak = Math.max(this.levelPeak, peak)
+      this.levelFrameCount += 1
+
+      if (this.levelFrameCount >= this.levelFramesPerUpdate) {
+        this.flushLevel()
+      }
+
+      let readOffset = 0
+      while (readOffset < channelData.length) {
+        const remaining = this.audioBuffer.length - this.audioBufferIndex
+        const copyLength = Math.min(remaining, channelData.length - readOffset)
+
+        this.audioBuffer.set(
+          channelData.subarray(readOffset, readOffset + copyLength),
+          this.audioBufferIndex
+        )
+
+        this.audioBufferIndex += copyLength
+        readOffset += copyLength
+
+        if (this.audioBufferIndex >= this.audioBuffer.length) {
+          this.flushAudio()
+        }
+      }
+    }
+
+    return true
+  }
+}
+
+registerProcessor("audio-capture-processor", AudioCaptureProcessor)
+`;
+let cachedBlobURL = null;
+/**
+* Create a blob URL for the audio worklet processor.
+* Caches the URL to avoid creating multiple blobs.
+*/
+function createWorkletBlobURL() {
+	if (!cachedBlobURL) {
+		const blob = new Blob([workletCode], { type: "application/javascript" });
+		cachedBlobURL = URL.createObjectURL(blob);
+	}
+	return cachedBlobURL;
+}
+//#endregion
+//#region src/core/services/voice-capture.ts
+const SAMPLE_RATE = 16e3;
+const AUDIO_LEVEL_NOISE_GATE = 5e-4;
+const AUDIO_LEVEL_INPUT_GAIN = 600;
+const AUDIO_LEVEL_ATTACK = .7;
+const AUDIO_LEVEL_RELEASE = .25;
+function clamp$1(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function normalizeAudioLevel(rms) {
+	const gatedRms = Math.max(0, rms - AUDIO_LEVEL_NOISE_GATE);
+	return clamp$1(Math.log1p(gatedRms * AUDIO_LEVEL_INPUT_GAIN) / Math.log1p(AUDIO_LEVEL_INPUT_GAIN), 0, 1);
+}
+function smoothAudioLevel(current, target) {
+	const smoothing = target > current ? AUDIO_LEVEL_ATTACK : AUDIO_LEVEL_RELEASE;
+	return current + (target - current) * smoothing;
+}
+/**
+* Framework-agnostic service for voice capture using AudioWorkletNode.
+*/
+var VoiceCaptureService = class {
+	audioContext = null;
+	workletNode = null;
+	sourceNode = null;
+	silentGainNode = null;
+	stream = null;
+	chunks = [];
+	levelCallback = null;
+	visualLevel = 0;
+	flushResolve = null;
+	/**
+	* Register a callback to receive audio level updates (0-1).
+	* Called at ~60fps during recording for waveform visualization.
+	*/
+	onLevel(callback) {
+		this.levelCallback = callback;
+	}
+	/**
+	* Start recording audio from the microphone.
+	* @throws Error if microphone access is denied
+	*/
+	async start() {
+		this.chunks = [];
+		this.visualLevel = 0;
+		const stream = await navigator.mediaDevices.getUserMedia({ audio: {
+			sampleRate: SAMPLE_RATE,
+			channelCount: 1,
+			echoCancellation: true,
+			noiseSuppression: true
+		} });
+		this.stream = stream;
+		const audioContext = new AudioContext({ sampleRate: SAMPLE_RATE });
+		this.audioContext = audioContext;
+		await audioContext.resume();
+		const workletURL = createWorkletBlobURL();
+		await audioContext.audioWorklet.addModule(workletURL);
+		const source = audioContext.createMediaStreamSource(stream);
+		this.sourceNode = source;
+		const workletNode = new AudioWorkletNode(audioContext, "audio-capture-processor");
+		this.workletNode = workletNode;
+		const silentGainNode = audioContext.createGain();
+		silentGainNode.gain.value = 0;
+		this.silentGainNode = silentGainNode;
+		workletNode.port.onmessage = (event) => {
+			const { type, data, rms, peak } = event.data;
+			if (type === "audio") this.chunks.push(data);
+			else if (type === "level" && this.levelCallback) {
+				const targetLevel = normalizeAudioLevel(Math.max(rms ?? 0, (peak ?? 0) * .6));
+				this.visualLevel = smoothAudioLevel(this.visualLevel, targetLevel);
+				this.levelCallback(this.visualLevel);
+			} else if (type === "flush-complete") {
+				this.flushResolve?.();
+				this.flushResolve = null;
+			}
+		};
+		source.connect(workletNode);
+		workletNode.connect(silentGainNode);
+		silentGainNode.connect(audioContext.destination);
+	}
+	/**
+	* Stop recording and return the captured audio as a WAV blob.
+	*/
+	async stop() {
+		await this.flushPendingAudio();
+		if (this.stream) {
+			this.stream.getTracks().forEach((track) => track.stop());
+			this.stream = null;
+		}
+		if (this.sourceNode) {
+			this.sourceNode.disconnect();
+			this.sourceNode = null;
+		}
+		if (this.workletNode) {
+			this.workletNode.disconnect();
+			this.workletNode = null;
+		}
+		if (this.silentGainNode) {
+			this.silentGainNode.disconnect();
+			this.silentGainNode = null;
+		}
+		if (this.audioContext) {
+			await this.audioContext.close();
+			this.audioContext = null;
+		}
+		this.visualLevel = 0;
+		this.levelCallback?.(0);
+		const wavBlob = encodeWAV(mergeAudioChunks(this.chunks), SAMPLE_RATE);
+		this.chunks = [];
+		return wavBlob;
+	}
+	/**
+	* Clean up all resources.
+	*
+	* The level callback is intentionally preserved so the same service instance
+	* can be reused across multiple push-to-talk turns without re-registering
+	* the waveform subscription from the client.
+	*/
+	dispose() {
+		if (this.stream) {
+			this.stream.getTracks().forEach((track) => track.stop());
+			this.stream = null;
+		}
+		if (this.sourceNode) {
+			this.sourceNode.disconnect();
+			this.sourceNode = null;
+		}
+		if (this.workletNode) {
+			this.workletNode.disconnect();
+			this.workletNode = null;
+		}
+		if (this.silentGainNode) {
+			this.silentGainNode.disconnect();
+			this.silentGainNode = null;
+		}
+		if (this.audioContext) {
+			this.audioContext.close();
+			this.audioContext = null;
+		}
+		this.chunks = [];
+		this.visualLevel = 0;
+		this.levelCallback?.(0);
+		this.flushResolve = null;
+	}
+	async flushPendingAudio() {
+		if (!this.workletNode) return;
+		await new Promise((resolve) => {
+			const timeoutId = setTimeout(() => {
+				this.flushResolve = null;
+				resolve();
+			}, 50);
+			this.flushResolve = () => {
+				clearTimeout(timeoutId);
+				resolve();
+			};
+			this.workletNode?.port.postMessage({ type: "flush" });
+		});
+	}
+};
+//#endregion
+//#region src/core/state-machine.ts
+/**
+* State transition table for the voice interaction flow.
+* Maps current state + event type to next state.
+*/
+const transitions = {
+	idle: { HOTKEY_PRESSED: "listening" },
+	listening: {
+		HOTKEY_RELEASED: "processing",
+		ERROR: "idle"
+	},
+	processing: {
+		RESPONSE_STARTED: "responding",
+		TTS_COMPLETE: "idle",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	},
+	responding: {
+		TTS_COMPLETE: "idle",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	}
+};
+/**
+* Create a simple typed state machine for the voice interaction flow.
+*
+* States: idle -> listening -> processing -> responding -> idle
+*
+* Supports interruption: pressing hotkey during processing or responding
+* immediately transitions back to listening.
+*/
+function createStateMachine(initial = "idle") {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		listeners.forEach((listener) => listener());
+	}
+	return {
+		getState: () => state,
+		transition: (event) => {
+			const nextState = transitions[state][event.type];
+			if (!nextState) return false;
+			state = nextState;
+			notify();
+			return true;
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		reset: () => {
+			state = "idle";
+			notify();
+		}
+	};
+}
+//#endregion
+//#region src/core/utils/ui-stream-parser.ts
+/**
+* Parse a single line from the UI message stream.
+* The stream format is SSE with "data: " prefix followed by JSON.
+*/
+function parseUIStreamLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+	let jsonStr = trimmed;
+	if (trimmed.startsWith("data: ")) jsonStr = trimmed.slice(6);
+	if (jsonStr === "[DONE]") return null;
+	try {
+		const chunk = JSON.parse(jsonStr);
+		switch (chunk.type) {
+			case "text-delta": return {
+				type: "text-delta",
+				delta: chunk.delta ?? ""
+			};
+			case "tool-input-available": return {
+				type: "tool-input-available",
+				toolName: chunk.toolName ?? "",
+				input: chunk.input
+			};
+			case "finish": return { type: "finish" };
+			case "error": return {
+				type: "error",
+				errorText: chunk.errorText ?? "Unknown error"
+			};
+			default: return { type: "unknown" };
+		}
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if a tool call is a point tool call with valid input.
+*/
+function isPointToolCall(chunk) {
+	return chunk.type === "tool-input-available" && chunk.toolName === "point" && chunk.input != null && typeof chunk.input === "object" && "type" in chunk.input && "label" in chunk.input;
+}
+//#endregion
+//#region src/core/utils/response-processor.ts
+const COMMON_ABBREVIATIONS = [
+	"mr.",
+	"mrs.",
+	"ms.",
+	"dr.",
+	"prof.",
+	"sr.",
+	"jr.",
+	"e.g.",
+	"i.e."
+];
+const CLOSING_PUNCTUATION = new Set([
+	"\"",
+	"'",
+	"”",
+	"’",
+	")",
+	"]",
+	"}"
+]);
+const SHORT_SEGMENT_THRESHOLD = 24;
+function isLikelySentenceBoundary(text, index) {
+	const char = text[index];
+	if (char === "!" || char === "?" || char === "…" || char === "\n") return true;
+	if (char !== ".") return false;
+	const previousChar = text[index - 1] ?? "";
+	const nextChar = text[index + 1] ?? "";
+	if (/\d/.test(previousChar) && /\d/.test(nextChar)) return false;
+	const lookback = text.slice(Math.max(0, index - 10), index + 1).toLowerCase();
+	if (COMMON_ABBREVIATIONS.some((abbreviation) => lookback.endsWith(abbreviation))) return false;
+	return true;
+}
+function findBoundaryEnd(text, start) {
+	for (let index = start; index < text.length; index++) {
+		if (text[index] === "\n") {
+			let end = index + 1;
+			while (end < text.length && /\s/.test(text[end] ?? "")) end++;
+			return end;
+		}
+		if (!isLikelySentenceBoundary(text, index)) continue;
+		let end = index + 1;
+		while (end < text.length && CLOSING_PUNCTUATION.has(text[end] ?? "")) end++;
+		if (end < text.length) {
+			const nextChar = text[end] ?? "";
+			if (!/\s/.test(nextChar) && !/[A-Z0-9]/.test(nextChar)) continue;
+		}
+		while (end < text.length && /\s/.test(text[end] ?? "")) end++;
+		return end;
+	}
+	return null;
+}
+function extractCompletedSegments(text) {
+	const segments = [];
+	let consumedLength = 0;
+	while (consumedLength < text.length) {
+		const boundaryEnd = findBoundaryEnd(text, consumedLength);
+		if (boundaryEnd === null) break;
+		const segment = text.slice(consumedLength, boundaryEnd).trim();
+		if (segment) segments.push(segment);
+		consumedLength = boundaryEnd;
+	}
+	return {
+		consumedLength,
+		segments
+	};
+}
+/**
+* Processes a streaming AI SDK UI message stream response.
+* Extracts text for display/TTS and captures point tool calls.
+*/
+var ProgressiveResponseProcessor = class {
+	consumedTextLength = 0;
+	pendingShortSegment = "";
+	rawText = "";
+	buffer = "";
+	pointToolCall = null;
+	/**
+	* Push raw stream data and extract text chunks and tool calls.
+	* The UI message stream format is newline-delimited JSON.
+	*/
+	push(chunk) {
+		this.buffer += chunk;
+		const lines = this.buffer.split("\n");
+		this.buffer = lines.pop() ?? "";
+		const newTextParts = [];
+		for (const line of lines) {
+			const parsed = parseUIStreamLine(line);
+			if (!parsed) continue;
+			if (parsed.type === "text-delta") newTextParts.push(parsed.delta);
+			else if (isPointToolCall(parsed)) {
+				if (!this.pointToolCall) this.pointToolCall = parsed.input;
+			}
+		}
+		if (newTextParts.length > 0) this.rawText += newTextParts.join("");
+		const { consumedLength, segments } = extractCompletedSegments(this.rawText.slice(this.consumedTextLength));
+		this.consumedTextLength += consumedLength;
+		return {
+			visibleText: this.rawText,
+			speechSegments: this.coalesceSegments(segments),
+			pointToolCall: this.pointToolCall
+		};
+	}
+	/**
+	* Finalize processing and return any remaining text/tool call.
+	*/
+	finish() {
+		if (this.buffer) {
+			const parsed = parseUIStreamLine(this.buffer);
+			if (parsed?.type === "text-delta") this.rawText += parsed.delta;
+			else if (parsed && isPointToolCall(parsed) && !this.pointToolCall) this.pointToolCall = parsed.input;
+			this.buffer = "";
+		}
+		const trailingText = this.rawText.slice(this.consumedTextLength).trim();
+		const finalSegmentParts = [this.pendingShortSegment, trailingText].filter(Boolean);
+		this.pendingShortSegment = "";
+		return {
+			finalResponseText: this.rawText.trim(),
+			speechSegments: finalSegmentParts.length ? [finalSegmentParts.join(" ").trim()] : [],
+			pointToolCall: this.pointToolCall
+		};
+	}
+	coalesceSegments(segments) {
+		const speechSegments = [];
+		for (const segment of segments) {
+			const normalizedSegment = segment.trim();
+			if (!normalizedSegment) continue;
+			const candidate = this.pendingShortSegment ? `${this.pendingShortSegment} ${normalizedSegment}` : normalizedSegment;
+			if (candidate.length < SHORT_SEGMENT_THRESHOLD) {
+				this.pendingShortSegment = candidate;
+				continue;
+			}
+			this.pendingShortSegment = "";
+			speechSegments.push(candidate);
+		}
+		return speechSegments;
+	}
+};
+//#endregion
+//#region src/core/client.ts
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+async function readErrorMessage(response, fallbackMessage) {
+	try {
+		if ((response.headers.get("Content-Type") ?? "").includes("application/json")) {
+			const body = await response.json();
+			if (body?.error) return body.error;
+		}
+		const text = await response.text();
+		if (text) return text;
+	} catch {}
+	return fallbackMessage;
+}
+/**
+* Map coordinate-based pointing from screenshot space to viewport space.
+*/
+function mapCoordinatesToViewport(x, y, screenshot) {
+	if (screenshot.width <= 0 || screenshot.height <= 0) return {
+		x,
+		y
+	};
+	const scaleX = screenshot.viewportWidth / screenshot.width;
+	const scaleY = screenshot.viewportHeight / screenshot.height;
+	return {
+		x: clamp(Math.round(x * scaleX), 0, Math.max(screenshot.viewportWidth - 1, 0)),
+		y: clamp(Math.round(y * scaleY), 0, Math.max(screenshot.viewportHeight - 1, 0))
+	};
+}
+/**
+* Framework-agnostic client for cursor buddy voice interactions.
+*
+* Manages the complete voice interaction flow:
+* idle -> listening -> processing -> responding -> idle
+*
+* Supports interruption: pressing hotkey during any state aborts
+* in-flight work and immediately transitions to listening.
+*/
+var CursorBuddyClient = class {
+	endpoint;
+	options;
+	voiceCapture;
+	audioPlayback;
+	browserSpeech;
+	liveTranscription;
+	screenCapture;
+	pointerController;
+	stateMachine;
+	liveTranscript = "";
+	transcript = "";
+	response = "";
+	error = null;
+	abortController = null;
+	historyCommittedForTurn = false;
+	speechProviderForTurn = null;
+	screenshotPromise = null;
+	cachedSnapshot;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(endpoint, options = {}, services = {}) {
+		this.endpoint = endpoint;
+		this.options = options;
+		this.voiceCapture = services.voiceCapture ?? new VoiceCaptureService();
+		this.audioPlayback = services.audioPlayback ?? new AudioPlaybackService();
+		this.browserSpeech = services.browserSpeech ?? new BrowserSpeechService();
+		this.liveTranscription = services.liveTranscription ?? new LiveTranscriptionService();
+		this.screenCapture = services.screenCapture ?? new ScreenCaptureService();
+		this.pointerController = services.pointerController ?? new PointerController();
+		this.stateMachine = createStateMachine();
+		this.cachedSnapshot = this.buildSnapshot();
+		this.voiceCapture.onLevel((level) => $audioLevel.set(level));
+		this.liveTranscription.onPartial((text) => {
+			if (this.liveTranscript === text) return;
+			this.liveTranscript = text;
+			this.notify();
+		});
+		this.stateMachine.subscribe(() => {
+			this.options.onStateChange?.(this.stateMachine.getState());
+			this.notify();
+		});
+		this.pointerController.subscribe(() => this.notify());
+	}
+	/**
+	* Start listening for voice input.
+	* Aborts any in-flight work from previous session.
+	*/
+	startListening() {
+		this.abort();
+		this.liveTranscript = "";
+		this.transcript = "";
+		this.response = "";
+		this.error = null;
+		this.historyCommittedForTurn = false;
+		this.speechProviderForTurn = null;
+		this.pointerController.release();
+		this.stateMachine.transition({ type: "HOTKEY_PRESSED" });
+		this.notify();
+		this.abortController = new AbortController();
+		const signal = this.abortController.signal;
+		this.screenshotPromise = this.screenCapture.captureAnnotated();
+		this.beginListeningSession(signal).catch((error) => {
+			if (signal.aborted) return;
+			this.voiceCapture.dispose();
+			this.liveTranscription.dispose();
+			this.handleError(toError(error, "Failed to start listening"));
+		});
+	}
+	/**
+	* Stop listening and process the voice input.
+	*/
+	async stopListening() {
+		if (this.stateMachine.getState() !== "listening") return;
+		this.stateMachine.transition({ type: "HOTKEY_RELEASED" });
+		const signal = this.abortController?.signal;
+		let turnFailure = null;
+		const failTurn = (error) => {
+			if (turnFailure || signal?.aborted) return;
+			turnFailure = error;
+			this.audioPlayback.stop();
+			this.browserSpeech.stop();
+			this.abortController?.abort();
+		};
+		try {
+			const [audioBlob, browserTranscript] = await Promise.all([this.voiceCapture.stop(), this.stopLiveTranscription()]);
+			let screenshot;
+			try {
+				if (!this.screenshotPromise) throw new Error("Screenshot was not started");
+				screenshot = await this.screenshotPromise;
+			} catch (screenshotError) {
+				const errorMessage = screenshotError instanceof Error ? `Failed to capture screenshot: ${screenshotError.message}` : "Failed to capture screenshot";
+				throw new Error(errorMessage);
+			}
+			if (turnFailure) throw turnFailure;
+			if (signal?.aborted) return;
+			const transcript = await this.resolveTranscript(browserTranscript, audioBlob, signal);
+			if (turnFailure) throw turnFailure;
+			if (signal?.aborted) return;
+			this.liveTranscript = "";
+			this.transcript = transcript;
+			this.options.onTranscript?.(transcript);
+			this.notify();
+			this.prepareSpeechMode();
+			const { cleanResponse, pointToolCall, playbackQueue } = await this.chatAndSpeak(transcript, screenshot, signal, {
+				onFailure: failTurn,
+				onPlaybackStart: () => {
+					this.stateMachine.transition({ type: "RESPONSE_STARTED" });
+				}
+			});
+			if (turnFailure) throw turnFailure;
+			if (signal?.aborted) return;
+			this.options.onResponse?.(cleanResponse);
+			let pointTarget = null;
+			if (pointToolCall) if (pointToolCall.type === "marker") {
+				const coords = resolveMarkerToCoordinates(screenshot.markerMap, pointToolCall.markerId);
+				if (coords) pointTarget = {
+					...coords,
+					label: pointToolCall.label
+				};
+			} else pointTarget = {
+				...mapCoordinatesToViewport(pointToolCall.x, pointToolCall.y, screenshot),
+				label: pointToolCall.label
+			};
+			if (pointTarget) {
+				this.options.onPoint?.(pointTarget);
+				this.pointerController.pointAt(pointTarget);
+			}
+			await playbackQueue.waitForCompletion();
+			if (turnFailure) throw turnFailure;
+			if (signal?.aborted) return;
+			const newHistory = [
+				...$conversationHistory.get(),
+				{
+					role: "user",
+					content: transcript
+				},
+				{
+					role: "assistant",
+					content: cleanResponse
+				}
+			];
+			$conversationHistory.set(newHistory);
+			this.historyCommittedForTurn = true;
+			this.stateMachine.transition({ type: "TTS_COMPLETE" });
+		} catch (err) {
+			if (turnFailure) {
+				this.handleError(turnFailure);
+				return;
+			}
+			if (signal?.aborted) return;
+			this.handleError(toError(err));
+		}
+	}
+	/**
+	* Enable or disable the buddy.
+	*/
+	setEnabled(enabled) {
+		$isEnabled.set(enabled);
+		this.notify();
+	}
+	/**
+	* Manually point at coordinates.
+	*/
+	pointAt(x, y, label) {
+		this.pointerController.pointAt({
+			x,
+			y,
+			label
+		});
+	}
+	/**
+	* Dismiss the current pointing target.
+	*/
+	dismissPointing() {
+		this.pointerController.release();
+	}
+	/**
+	* Reset to idle state and stop any in-progress work.
+	*/
+	reset() {
+		this.abort();
+		this.liveTranscript = "";
+		this.transcript = "";
+		this.response = "";
+		this.error = null;
+		this.historyCommittedForTurn = false;
+		this.pointerController.release();
+		this.stateMachine.reset();
+		this.notify();
+	}
+	/**
+	* Update buddy position to follow cursor.
+	* Call this on cursor position changes.
+	*/
+	updateCursorPosition() {
+		this.pointerController.updateFollowPosition();
+	}
+	/**
+	* Subscribe to state changes.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Get current state snapshot for React's useSyncExternalStore.
+	* Returns a cached object to ensure referential stability.
+	*/
+	getSnapshot() {
+		return this.cachedSnapshot;
+	}
+	/**
+	* Build a new snapshot object.
+	*/
+	buildSnapshot() {
+		return {
+			state: this.stateMachine.getState(),
+			liveTranscript: this.liveTranscript,
+			transcript: this.transcript,
+			response: this.response,
+			error: this.error,
+			isPointing: this.pointerController.isPointing(),
+			isEnabled: $isEnabled.get()
+		};
+	}
+	abort() {
+		this.commitPartialHistory();
+		this.abortController?.abort();
+		this.abortController = null;
+		this.screenshotPromise = null;
+		this.voiceCapture.dispose();
+		this.liveTranscription.dispose();
+		this.audioPlayback.stop();
+		this.browserSpeech.stop();
+		this.speechProviderForTurn = null;
+		$audioLevel.set(0);
+	}
+	/**
+	* Commit partial turn to history when interrupted.
+	* Only commits if we have both transcript and response,
+	* and haven't already committed for this turn.
+	*/
+	commitPartialHistory() {
+		if (this.historyCommittedForTurn) return;
+		if (!this.transcript || !this.response) return;
+		const newHistory = [
+			...$conversationHistory.get(),
+			{
+				role: "user",
+				content: this.transcript
+			},
+			{
+				role: "assistant",
+				content: this.response
+			}
+		];
+		$conversationHistory.set(newHistory);
+		this.historyCommittedForTurn = true;
+	}
+	async transcribe(blob, signal) {
+		const formData = new FormData();
+		formData.append("audio", blob, "recording.wav");
+		const response = await fetch(`${this.endpoint}/transcribe`, {
+			method: "POST",
+			body: formData,
+			signal
+		});
+		if (!response.ok) throw new Error(await readErrorMessage(response, "Transcription failed"));
+		const { text } = await response.json();
+		return text;
+	}
+	/**
+	* Stream the chat response, keep the visible text updated, and feed complete
+	* speech segments into the TTS queue as soon as they are ready.
+	*/
+	async chatAndSpeak(transcript, screenshot, signal, options) {
+		const history = $conversationHistory.get();
+		const response = await fetch(`${this.endpoint}/chat`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				screenshot: screenshot.imageData,
+				capture: {
+					width: screenshot.width,
+					height: screenshot.height
+				},
+				transcript,
+				history,
+				markerContext: screenshot.markerContext
+			}),
+			signal
+		});
+		if (!response.ok) throw new Error("Chat request failed");
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("No response body");
+		const decoder = new TextDecoder();
+		const responseProcessor = new ProgressiveResponseProcessor();
+		const playbackQueue = new TTSPlaybackQueue({
+			onError: options.onFailure,
+			onPlaybackStart: options.onPlaybackStart,
+			prepare: (text, currentSignal) => this.prepareSpeechSegment(text, currentSignal),
+			signal
+		});
+		const shouldStreamSpeech = this.isSpeechStreamingEnabled();
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const chunk = decoder.decode(value, { stream: true });
+			const { speechSegments, visibleText } = responseProcessor.push(chunk);
+			if (shouldStreamSpeech) for (const speechSegment of speechSegments) playbackQueue.enqueue(speechSegment);
+			this.updateResponse(visibleText);
+		}
+		const trailingChunk = decoder.decode();
+		if (trailingChunk) {
+			const { speechSegments, visibleText } = responseProcessor.push(trailingChunk);
+			if (shouldStreamSpeech) for (const speechSegment of speechSegments) playbackQueue.enqueue(speechSegment);
+			this.updateResponse(visibleText);
+		}
+		const finalizedResponse = responseProcessor.finish();
+		if (shouldStreamSpeech) for (const speechSegment of finalizedResponse.speechSegments) playbackQueue.enqueue(speechSegment);
+		else playbackQueue.enqueue(finalizedResponse.finalResponseText);
+		this.updateResponse(finalizedResponse.finalResponseText);
+		return {
+			cleanResponse: finalizedResponse.finalResponseText,
+			pointToolCall: finalizedResponse.pointToolCall,
+			playbackQueue
+		};
+	}
+	/**
+	* Request server-side TTS audio for one text segment.
+	*/
+	async synthesizeSpeech(text, signal) {
+		const response = await fetch(`${this.endpoint}/tts`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ text }),
+			signal
+		});
+		if (!response.ok) throw new Error(await readErrorMessage(response, "TTS request failed"));
+		return response.blob();
+	}
+	/**
+	* Resolve the initial speech provider for this turn.
+	*
+	* Decision tree:
+	* 1. In `server` mode, always synthesize on the server.
+	* 2. In `browser` mode, require browser speech support up front.
+	* 3. In `auto` mode, prefer browser speech when available and keep that
+	*    choice cached so later segments stay on the same provider unless a
+	*    browser failure forces a one-way fallback to the server.
+	*/
+	prepareSpeechMode() {
+		const speechMode = this.getSpeechMode();
+		if (speechMode === "browser" && !this.browserSpeech.isAvailable()) throw new Error("Browser speech is not supported");
+		if (speechMode === "server") {
+			this.speechProviderForTurn = "server";
+			return;
+		}
+		if (speechMode === "browser") {
+			this.speechProviderForTurn = "browser";
+			return;
+		}
+		this.speechProviderForTurn = this.browserSpeech.isAvailable() ? "browser" : "server";
+	}
+	/**
+	* Prepare a playback task for one text segment.
+	*
+	* The queue calls this eagerly so server synthesis can overlap with the
+	* currently playing segment, but the returned task is still executed in the
+	* original enqueue order.
+	*/
+	async prepareSpeechSegment(text, signal) {
+		switch (this.getSpeechMode()) {
+			case "server": return this.prepareServerSpeechTask(text, signal);
+			case "browser": return this.prepareBrowserSpeechTask(text, signal);
+			default: return this.prepareAutoSpeechTask(text, signal);
+		}
+	}
+	/**
+	* Synthesize server audio immediately and return a playback task that reuses
+	* the prepared blob later.
+	*/
+	async prepareServerSpeechTask(text, signal) {
+		const blob = await this.synthesizeSpeech(text, signal);
+		return () => this.audioPlayback.play(blob, signal);
+	}
+	/**
+	* Return a browser playback task for one text segment.
+	*/
+	async prepareBrowserSpeechTask(text, signal) {
+		return () => this.browserSpeech.speak(text, signal);
+	}
+	/**
+	* Prepare a playback task for `auto` mode.
+	*
+	* We prefer the browser for low latency, but if browser speech fails for any
+	* segment we permanently switch the remainder of the turn to server TTS so
+	* later segments do not keep retrying the failing browser path.
+	*/
+	async prepareAutoSpeechTask(text, signal) {
+		if (this.getAutoSpeechProvider() === "server") return this.prepareServerSpeechTask(text, signal);
+		return async () => {
+			if (this.getAutoSpeechProvider() === "server") {
+				await (await this.prepareServerSpeechTask(text, signal))();
+				return;
+			}
+			try {
+				await this.browserSpeech.speak(text, signal);
+			} catch (error) {
+				if (signal?.aborted) return;
+				this.speechProviderForTurn = "server";
+				await (await this.prepareServerSpeechTask(text, signal))();
+			}
+		};
+	}
+	/**
+	* Read the current provider choice for `auto` mode, lazily defaulting to the
+	* browser when supported and the server otherwise.
+	*/
+	getAutoSpeechProvider() {
+		if (this.speechProviderForTurn) return this.speechProviderForTurn;
+		this.speechProviderForTurn = this.browserSpeech.isAvailable() ? "browser" : "server";
+		return this.speechProviderForTurn;
+	}
+	handleError(err) {
+		this.liveTranscript = "";
+		this.error = err;
+		this.stateMachine.transition({
+			type: "ERROR",
+			error: err
+		});
+		this.options.onError?.(err);
+		this.notify();
+	}
+	/**
+	* Resolve the effective transcription mode for the current client.
+	*/
+	getTranscriptionMode() {
+		return this.options.transcription?.mode ?? "auto";
+	}
+	/**
+	* Resolve the effective speech mode for the current client.
+	*/
+	getSpeechMode() {
+		return this.options.speech?.mode ?? "server";
+	}
+	/**
+	* Decide whether speech should start before the full chat response is ready.
+	*/
+	isSpeechStreamingEnabled() {
+		return this.options.speech?.allowStreaming ?? false;
+	}
+	/**
+	* Decide whether this turn should attempt browser speech recognition.
+	*/
+	shouldAttemptBrowserTranscription() {
+		return this.getTranscriptionMode() !== "server";
+	}
+	/**
+	* Decide whether browser speech recognition is mandatory for this turn.
+	*/
+	isBrowserTranscriptionRequired() {
+		return this.getTranscriptionMode() === "browser";
+	}
+	/**
+	* Start the recorder and browser speech recognition together.
+	*
+	* The recorder always runs so we keep waveform updates and preserve a raw
+	* audio backup for server fallback in `auto` mode.
+	*/
+	async beginListeningSession(signal) {
+		const shouldAttemptBrowser = this.shouldAttemptBrowserTranscription();
+		const isBrowserTranscriptionAvailable = shouldAttemptBrowser && this.liveTranscription.isAvailable();
+		if (shouldAttemptBrowser && !isBrowserTranscriptionAvailable) {
+			if (this.isBrowserTranscriptionRequired()) throw new Error("Browser transcription is not supported");
+		}
+		const [voiceCaptureResult, browserTranscriptionResult] = await Promise.allSettled([this.voiceCapture.start(), isBrowserTranscriptionAvailable ? this.liveTranscription.start() : Promise.resolve(void 0)]);
+		if (signal.aborted) return;
+		if (voiceCaptureResult.status === "rejected") throw toError(voiceCaptureResult.reason, "Failed to start microphone");
+		if (browserTranscriptionResult.status === "rejected" && this.isBrowserTranscriptionRequired()) throw toError(browserTranscriptionResult.reason, "Browser transcription failed to start");
+		if (browserTranscriptionResult.status === "rejected") this.liveTranscription.dispose();
+	}
+	/**
+	* Stop browser speech recognition and return the best final transcript it
+	* produced for this turn.
+	*/
+	async stopLiveTranscription() {
+		if (!this.shouldAttemptBrowserTranscription() || !this.liveTranscription.isAvailable()) return "";
+		try {
+			return await this.liveTranscription.stop();
+		} catch (error) {
+			if (this.isBrowserTranscriptionRequired()) throw toError(error, "Browser transcription failed");
+			return "";
+		}
+	}
+	/**
+	* Choose the transcript that should drive the turn.
+	*
+	* Decision tree:
+	* 1. Use the browser transcript when it is available.
+	* 2. In browser-only mode, fail if the browser produced nothing usable.
+	* 3. In auto/server modes, fall back to the recorded audio upload.
+	*/
+	async resolveTranscript(browserTranscript, audioBlob, signal) {
+		const normalizedBrowserTranscript = browserTranscript.trim();
+		if (normalizedBrowserTranscript) return normalizedBrowserTranscript;
+		if (this.getTranscriptionMode() === "browser") throw new Error("Browser transcription did not produce a final transcript");
+		return this.transcribe(audioBlob, signal);
+	}
+	updateResponse(text) {
+		if (this.response === text) return;
+		this.response = text;
+		this.notify();
+	}
+	notify() {
+		this.cachedSnapshot = this.buildSnapshot();
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#endregion
+export { $buddyScale as a, $buddyRotation as i, $audioLevel as n, $cursorPosition as o, $buddyPosition as r, $pointingTarget as s, CursorBuddyClient as t };
+
+//# sourceMappingURL=client-D-LeEdoH.mjs.map