cursor-buddy 0.0.3 → 0.0.4

package/dist/{client-DAa4L2fE.mjs → client-UXGQt-7f.mjs}

@@ -30,6 +30,31 @@ const $conversationHistory = atom([]);
 * - Coordinate-based: [POINT:640,360:label] - 4 parts, raw pixel coordinates
 */
 const POINTING_TAG_REGEX = /\[POINT:(\d+)(?:,(\d+))?:([^\]]+)\]\s*$/;
+const PARTIAL_POINTING_PREFIXES = new Set([
+	"[",
+	"[P",
+	"[PO",
+	"[POI",
+	"[POIN",
+	"[POINT",
+	"[POINT:"
+]);
+function stripTrailingPointingTag(response, trimResult) {
+	const stripped = response.replace(POINTING_TAG_REGEX, "");
+	return trimResult ? stripped.trim() : stripped;
+}
+function getPartialPointingTagStart(response) {
+	const lastOpenBracket = response.lastIndexOf("[");
+	if (lastOpenBracket === -1) return -1;
+	const suffix = response.slice(lastOpenBracket).trimEnd();
+	if (suffix.includes("]")) return -1;
+	if (suffix.startsWith("[POINT:")) {
+		let start = lastOpenBracket;
+		while (start > 0 && /\s/.test(response[start - 1] ?? "")) start--;
+		return start;
+	}
+	return PARTIAL_POINTING_PREFIXES.has(suffix) ? lastOpenBracket : -1;
+}
 /**
 * Parse pointing tag into structured result.
 * Returns null if no valid POINT tag is found at the end.
@@ -56,7 +81,28 @@ function parsePointingTagRaw(response) {
 * Remove POINT tag from response text for display/TTS.
 */
 function stripPointingTag(response) {
-	return response.replace(POINTING_TAG_REGEX, "").trim();
+	return stripTrailingPointingTag(response, true);
+}
+/**
+* Strip complete or partial trailing POINT syntax while the response streams.
+* This keeps the visible text and TTS input stable even if the tag arrives
+* incrementally over multiple chunks.
+*/
+function stripTrailingPointingSyntax(response) {
+	const withoutCompleteTag = stripTrailingPointingTag(response, false);
+	const partialTagStart = getPartialPointingTagStart(withoutCompleteTag);
+	if (partialTagStart === -1) return withoutCompleteTag.trimEnd();
+	return withoutCompleteTag.slice(0, partialTagStart).trimEnd();
+}
+//#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
@@ -124,7 +170,7 @@ var AudioPlaybackService = class {
 				settle("reject", /* @__PURE__ */ new Error("Audio playback failed"));
 			};
 			this.audio.play().catch((err) => {
-				settle("reject", err instanceof Error ? err : new Error(String(err)));
+				settle("reject", toError(err, "Audio playback failed"));
 			});
 		});
 	}
@@ -156,6 +202,323 @@ var AudioPlaybackService = class {
 	}
 };
 //#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.
@@ -322,6 +685,84 @@ var PointerController = class {
 	}
 };
 //#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: 11,
+	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.
@@ -463,84 +904,6 @@ function resolveMarkerToCoordinates(markerMap, markerId) {
 	return getElementCenter(marker.element);
 }
 //#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: 11,
-	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/screenshot.ts
 const CLONE_RESOURCE_TIMEOUT_MS = 3e3;
 function getCaptureMetrics() {
@@ -709,6 +1072,66 @@ var ScreenCaptureService = class {
 	}
 };
 //#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.
@@ -995,6 +1418,10 @@ var VoiceCaptureService = class {
 	}
 	/**
 	* 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) {
@@ -1019,8 +1446,8 @@ var VoiceCaptureService = class {
 		}
 		this.chunks = [];
 		this.visualLevel = 0;
+		this.levelCallback?.(0);
 		this.flushResolve = null;
-		this.levelCallback = null;
 	}
 	async flushPendingAudio() {
 		if (!this.workletNode) return;
@@ -1050,7 +1477,8 @@ const transitions = {
 		ERROR: "idle"
 	},
 	processing: {
-		AI_RESPONSE_COMPLETE: "responding",
+		RESPONSE_STARTED: "responding",
+		TTS_COMPLETE: "idle",
 		HOTKEY_PRESSED: "listening",
 		ERROR: "idle"
 	},
@@ -1094,10 +1522,134 @@ function createStateMachine(initial = "idle") {
 	};
 }
 //#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
+	};
+}
+/**
+* Tracks a streaming assistant response, exposes a tag-free visible version for
+* the UI, and emits speakable segments as sentence boundaries become stable.
+*/
+var ProgressiveResponseProcessor = class {
+	consumedVisibleTextLength = 0;
+	pendingShortSegment = "";
+	rawResponse = "";
+	push(chunk) {
+		this.rawResponse += chunk;
+		const visibleText = stripTrailingPointingSyntax(this.rawResponse);
+		const { consumedLength, segments } = extractCompletedSegments(visibleText.slice(this.consumedVisibleTextLength));
+		this.consumedVisibleTextLength += consumedLength;
+		return {
+			visibleText,
+			speechSegments: this.coalesceSegments(segments)
+		};
+	}
+	finish() {
+		const finalResponseText = stripPointingTag(this.rawResponse);
+		const trailingText = finalResponseText.slice(this.consumedVisibleTextLength).trim();
+		const finalSegmentParts = [this.pendingShortSegment, trailingText].filter(Boolean);
+		this.pendingShortSegment = "";
+		return {
+			fullResponse: this.rawResponse,
+			finalResponseText,
+			speechSegments: finalSegmentParts.length ? [finalSegmentParts.join(" ").trim()] : []
+		};
+	}
+	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.
 */
@@ -1127,14 +1679,18 @@ var CursorBuddyClient = class {
 	options;
 	voiceCapture;
 	audioPlayback;
+	browserSpeech;
+	liveTranscription;
 	screenCapture;
 	pointerController;
 	stateMachine;
+	liveTranscript = "";
 	transcript = "";
 	response = "";
 	error = null;
 	abortController = null;
 	historyCommittedForTurn = false;
+	speechProviderForTurn = null;
 	cachedSnapshot;
 	listeners = /* @__PURE__ */ new Set();
 	constructor(endpoint, options = {}, services = {}) {
@@ -1142,11 +1698,18 @@ var CursorBuddyClient = class {
 		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();
@@ -1159,15 +1722,23 @@ var CursorBuddyClient = class {
 	*/
 	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();
-		this.voiceCapture.start().catch((err) => this.handleError(err));
+		const signal = this.abortController.signal;
+		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.
@@ -1176,37 +1747,40 @@ var CursorBuddyClient = class {
 		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, screenshot] = await Promise.all([this.voiceCapture.stop(), this.screenCapture.captureAnnotated()]);
+			const [audioBlob, screenshot, browserTranscript] = await Promise.all([
+				this.voiceCapture.stop(),
+				this.screenCapture.captureAnnotated(),
+				this.stopLiveTranscription()
+			]);
+			if (turnFailure) throw turnFailure;
 			if (signal?.aborted) return;
-			const transcript = await this.transcribe(audioBlob, signal);
+			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();
-			const response = await this.chat(transcript, screenshot, signal);
-			if (signal?.aborted) return;
-			const parsed = parsePointingTagRaw(response);
-			const cleanResponse = stripPointingTag(response);
-			this.response = cleanResponse;
-			this.stateMachine.transition({
-				type: "AI_RESPONSE_COMPLETE",
-				response: cleanResponse
+			this.prepareSpeechMode();
+			const { cleanResponse, fullResponse, playbackQueue } = await this.chatAndSpeak(transcript, screenshot, signal, {
+				onFailure: failTurn,
+				onPlaybackStart: () => {
+					this.stateMachine.transition({ type: "RESPONSE_STARTED" });
+				}
 			});
+			if (turnFailure) throw turnFailure;
+			if (signal?.aborted) return;
+			const parsed = parsePointingTagRaw(fullResponse);
 			this.options.onResponse?.(cleanResponse);
-			const newHistory = [
-				...$conversationHistory.get(),
-				{
-					role: "user",
-					content: transcript
-				},
-				{
-					role: "assistant",
-					content: cleanResponse
-				}
-			];
-			$conversationHistory.set(newHistory);
-			this.historyCommittedForTurn = true;
 			let pointTarget = null;
 			if (parsed) if (parsed.type === "marker") {
 				const coords = resolveMarkerToCoordinates(screenshot.markerMap, parsed.markerId);
@@ -1222,12 +1796,30 @@ var CursorBuddyClient = class {
 				this.options.onPoint?.(pointTarget);
 				this.pointerController.pointAt(pointTarget);
 			}
-			if (cleanResponse) await this.speak(cleanResponse, signal);
+			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(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown error"));
+			this.handleError(toError(err));
 		}
 	}
 	/**
@@ -1258,6 +1850,7 @@ var CursorBuddyClient = class {
 	*/
 	reset() {
 		this.abort();
+		this.liveTranscript = "";
 		this.transcript = "";
 		this.response = "";
 		this.error = null;
@@ -1293,6 +1886,7 @@ var CursorBuddyClient = class {
 	buildSnapshot() {
 		return {
 			state: this.stateMachine.getState(),
+			liveTranscript: this.liveTranscript,
 			transcript: this.transcript,
 			response: this.response,
 			error: this.error,
@@ -1304,7 +1898,11 @@ var CursorBuddyClient = class {
 		this.commitPartialHistory();
 		this.abortController?.abort();
 		this.abortController = null;
+		this.voiceCapture.dispose();
+		this.liveTranscription.dispose();
 		this.audioPlayback.stop();
+		this.browserSpeech.stop();
+		this.speechProviderForTurn = null;
 		$audioLevel.set(0);
 	}
 	/**
@@ -1337,11 +1935,15 @@ var CursorBuddyClient = class {
 			body: formData,
 			signal
 		});
-		if (!response.ok) throw new Error("Transcription failed");
+		if (!response.ok) throw new Error(await readErrorMessage(response, "Transcription failed"));
 		const { text } = await response.json();
 		return text;
 	}
-	async chat(transcript, screenshot, signal) {
+	/**
+	* 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",
@@ -1362,29 +1964,136 @@ var CursorBuddyClient = class {
 		const reader = response.body?.getReader();
 		if (!reader) throw new Error("No response body");
 		const decoder = new TextDecoder();
-		let fullResponse = "";
+		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 });
-			fullResponse += chunk;
-			this.response = stripPointingTag(fullResponse);
-			this.notify();
+			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);
 		}
-		return fullResponse;
+		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,
+			fullResponse: finalizedResponse.fullResponse,
+			playbackQueue
+		};
 	}
-	async speak(text, signal) {
+	/**
+	* 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("TTS request failed");
-		const audioBlob = await response.blob();
-		await this.audioPlayback.play(audioBlob, 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",
@@ -1393,6 +2102,86 @@ var CursorBuddyClient = class {
 		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());
@@ -1401,4 +2190,4 @@ var CursorBuddyClient = class {
 //#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-DAa4L2fE.mjs.map
+//# sourceMappingURL=client-UXGQt-7f.mjs.map