cursor-buddy 0.0.2 → 0.0.3

package/dist/{client-Bd33JD8T.mjs → client-DAa4L2fE.mjs}

@@ -1,350 +1,624 @@
-import html2canvas from "html2canvas-pro";
 import { atom } from "nanostores";
-//#region src/core/state-machine.ts
+import html2canvas from "html2canvas-pro";
+//#region src/core/atoms.ts
 /**
-* State transition table for the voice interaction flow.
-* Maps current state + event type to next state.
+* 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 transitions = {
-	idle: { HOTKEY_PRESSED: "listening" },
-	listening: {
-		HOTKEY_RELEASED: "processing",
-		ERROR: "idle"
-	},
-	processing: {
-		AI_RESPONSE_COMPLETE: "responding",
-		HOTKEY_PRESSED: "listening",
-		ERROR: "idle"
-	},
-	responding: {
-		TTS_COMPLETE: "idle",
-		HOTKEY_PRESSED: "listening",
-		ERROR: "idle"
-	}
-};
+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/pointing.ts
 /**
-* Create a simple typed state machine for the voice interaction flow.
-*
-* States: idle -> listening -> processing -> responding -> idle
+* Parses POINT tags from AI responses.
 *
-* Supports interruption: pressing hotkey during processing or responding
-* immediately transitions back to listening.
+* Supports two formats:
+* - Marker-based: [POINT:5:label] - 3 parts, references a numbered marker
+* - Coordinate-based: [POINT:640,360:label] - 4 parts, raw pixel coordinates
 */
-function createStateMachine(initial = "idle") {
-	let state = initial;
-	const listeners = /* @__PURE__ */ new Set();
-	function notify() {
-		listeners.forEach((listener) => listener());
-	}
+const POINTING_TAG_REGEX = /\[POINT:(\d+)(?:,(\d+))?:([^\]]+)\]\s*$/;
+/**
+* Parse pointing tag into structured result.
+* Returns null if no valid POINT tag is found at the end.
+*/
+function parsePointingTagRaw(response) {
+	const match = response.match(POINTING_TAG_REGEX);
+	if (!match) return null;
+	const first = Number.parseInt(match[1], 10);
+	const second = match[2] ? Number.parseInt(match[2], 10) : null;
+	const label = match[3].trim();
+	if (second !== null) return {
+		type: "coordinates",
+		x: first,
+		y: second,
+		label
+	};
 	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();
-		}
+		type: "marker",
+		markerId: first,
+		label
 	};
 }
-//#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.
+* Remove POINT tag from response text for display/TTS.
 */
-const workletCode = `
-class AudioCaptureProcessor extends AudioWorkletProcessor {
-  constructor() {
-    super()
-    this.isRecording = true
-  }
-
-  process(inputs) {
-    if (!this.isRecording) return false
-
-    const input = inputs[0]
-    if (input && input.length > 0) {
-      const channelData = input[0]
-
-      // Send audio data to main thread
-      this.port.postMessage({
-        type: "audio",
-        data: new Float32Array(channelData)
-      })
-
-      // Calculate RMS for audio level visualization
-      let sum = 0
-      for (let i = 0; i < channelData.length; i++) {
-        sum += channelData[i] * channelData[i]
-      }
-      const rms = Math.sqrt(sum / channelData.length)
-      this.port.postMessage({ type: "level", rms })
-    }
-
-    return true
-  }
+function stripPointingTag(response) {
+	return response.replace(POINTING_TAG_REGEX, "").trim();
 }
-
-registerProcessor("audio-capture-processor", AudioCaptureProcessor)
-`;
-let cachedBlobURL = null;
+//#endregion
+//#region src/core/services/audio-playback.ts
 /**
-* Create a blob URL for the audio worklet processor.
-* Caches the URL to avoid creating multiple blobs.
+* Framework-agnostic service for audio playback with abort support.
 */
-function createWorkletBlobURL() {
-	if (!cachedBlobURL) {
-		const blob = new Blob([workletCode], { type: "application/javascript" });
-		cachedBlobURL = URL.createObjectURL(blob);
+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", err instanceof Error ? err : new Error(String(err)));
+			});
+		});
 	}
-	return cachedBlobURL;
-}
+	/**
+	* 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/audio.ts
+//#region src/core/bezier.ts
 /**
-* Audio conversion utilities for voice capture.
-* Converts Float32 audio data to WAV format for server transcription.
+* Bezier flight animation for cursor pointing.
 */
 /**
-* Merge multiple Float32Array chunks into a single array
+* Quadratic bezier curve: B(t) = (1-t)²P₀ + 2(1-t)t·P₁ + t²P₂
 */
-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;
+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
+	};
 }
 /**
-* Convert Float32 audio data to 16-bit PCM
+* Bezier tangent (derivative): B'(t) = 2(1-t)(P₁-P₀) + 2t(P₂-P₁)
 */
-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);
-	}
+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)
+	};
 }
 /**
-* Write a string to a DataView
+* Ease-in-out cubic for smooth acceleration/deceleration
 */
-function writeString(view, offset, string) {
-	for (let i = 0; i < string.length; i++) view.setUint8(offset + i, string.charCodeAt(i));
+function easeInOutCubic(t) {
+	return t < .5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2;
 }
 /**
-* Encode Float32 audio data as a WAV file
+* 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 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" });
+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/voice-capture.ts
-const SAMPLE_RATE = 16e3;
-const AUDIO_LEVEL_BOOST = 10.2;
+//#region src/core/services/pointer-controller.ts
+const POINTING_LOCK_TIMEOUT_MS = 1e4;
 /**
-* Framework-agnostic service for voice capture using AudioWorkletNode.
+* Controller for cursor pointing behavior.
+* Manages the pointer state machine (follow -> flying -> anchored -> follow)
+* and cursor animation.
 */
-var VoiceCaptureService = class {
-	audioContext = null;
-	workletNode = null;
-	stream = null;
-	chunks = [];
-	levelCallback = null;
-	/**
-	* Register a callback to receive audio level updates (0-1).
-	* Called at ~60fps during recording for waveform visualization.
-	*/
-	onLevel(callback) {
-		this.levelCallback = callback;
-	}
+var PointerController = class {
+	mode = "follow";
+	cancelAnimation = null;
+	releaseTimeout = null;
+	listeners = /* @__PURE__ */ new Set();
 	/**
-	* Start recording audio from the microphone.
-	* @throws Error if microphone access is denied
+	* Animate cursor to point at a target.
 	*/
-	async start() {
-		this.chunks = [];
-		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;
-		const workletURL = createWorkletBlobURL();
-		await audioContext.audioWorklet.addModule(workletURL);
-		const source = audioContext.createMediaStreamSource(stream);
-		const workletNode = new AudioWorkletNode(audioContext, "audio-capture-processor");
-		this.workletNode = workletNode;
-		workletNode.port.onmessage = (event) => {
-			const { type, data, rms } = event.data;
-			if (type === "audio") this.chunks.push(data);
-			else if (type === "level" && this.levelCallback) {
-				const boostedLevel = Math.min(rms * AUDIO_LEVEL_BOOST, 1);
-				this.levelCallback(boostedLevel);
-			}
+	pointAt(target) {
+		this.release();
+		this.mode = "flying";
+		$pointingTarget.set(target);
+		const startPos = $buddyPosition.get();
+		const endPos = {
+			x: target.x,
+			y: target.y
 		};
-		source.connect(workletNode);
+		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();
 	}
 	/**
-	* Stop recording and return the captured audio as a WAV blob.
+	* Release the cursor from pointing mode back to follow mode.
 	*/
-	async stop() {
-		if (this.stream) {
-			this.stream.getTracks().forEach((track) => track.stop());
-			this.stream = null;
-		}
-		if (this.workletNode) {
-			this.workletNode.disconnect();
-			this.workletNode = null;
+	release() {
+		if (this.cancelAnimation) {
+			this.cancelAnimation();
+			this.cancelAnimation = null;
 		}
-		if (this.audioContext) {
-			await this.audioContext.close();
-			this.audioContext = null;
+		if (this.releaseTimeout) {
+			clearTimeout(this.releaseTimeout);
+			this.releaseTimeout = null;
 		}
-		this.levelCallback?.(0);
-		const wavBlob = encodeWAV(mergeAudioChunks(this.chunks), SAMPLE_RATE);
-		this.chunks = [];
-		return wavBlob;
+		this.mode = "follow";
+		$pointingTarget.set(null);
+		$buddyPosition.set($cursorPosition.get());
+		$buddyRotation.set(0);
+		$buddyScale.set(1);
+		this.notify();
 	}
 	/**
-	* Clean up all resources.
+	* Check if cursor is currently pointing (flying or anchored).
 	*/
-	dispose() {
-		if (this.stream) {
-			this.stream.getTracks().forEach((track) => track.stop());
-			this.stream = null;
-		}
-		if (this.workletNode) {
-			this.workletNode.disconnect();
-			this.workletNode = null;
-		}
-		if (this.audioContext) {
-			this.audioContext.close();
-			this.audioContext = null;
-		}
-		this.chunks = [];
-		this.levelCallback = null;
+	isPointing() {
+		return this.mode !== "follow";
 	}
-};
-//#endregion
-//#region src/core/services/audio-playback.ts
-/**
-* Framework-agnostic service for audio playback with abort support.
-*/
-var AudioPlaybackService = class {
-	audio = null;
-	currentUrl = 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
+	* Get current pointer mode.
 	*/
-	async play(blob, signal) {
-		this.stop();
-		if (signal?.aborted) return;
-		const url = URL.createObjectURL(blob);
-		this.currentUrl = url;
-		this.audio = new Audio(url);
-		const abortHandler = () => this.stop();
-		signal?.addEventListener("abort", abortHandler);
-		return new Promise((resolve, reject) => {
-			if (!this.audio) {
-				this.cleanup();
-				resolve();
-				return;
-			}
-			this.audio.onended = () => {
-				signal?.removeEventListener("abort", abortHandler);
-				this.cleanup();
-				resolve();
-			};
-			this.audio.onerror = () => {
-				signal?.removeEventListener("abort", abortHandler);
-				this.cleanup();
-				reject(/* @__PURE__ */ new Error("Audio playback failed"));
-			};
-			this.audio.play().catch((err) => {
-				signal?.removeEventListener("abort", abortHandler);
-				this.cleanup();
-				reject(err);
-			});
-		});
+	getMode() {
+		return this.mode;
+	}
+	/**
+	* Subscribe to pointer state changes.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
 	}
 	/**
-	* Stop any currently playing audio.
+	* Update buddy position to follow cursor when in follow mode.
+	* Call this on cursor position changes.
 	*/
-	stop() {
-		if (this.audio) {
-			this.audio.pause();
-			this.audio.onended = null;
-			this.audio.onerror = null;
-			this.audio = null;
+	updateFollowPosition() {
+		if (this.mode === "follow") {
+			$buddyPosition.set($cursorPosition.get());
+			$buddyRotation.set(0);
+			$buddyScale.set(1);
 		}
-		this.cleanup();
 	}
-	cleanup() {
-		if (this.currentUrl) {
-			URL.revokeObjectURL(this.currentUrl);
-			this.currentUrl = null;
-		}
+	scheduleRelease() {
+		this.releaseTimeout = setTimeout(() => {
+			this.releaseTimeout = null;
+			this.release();
+		}, POINTING_LOCK_TIMEOUT_MS);
+	}
+	notify() {
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#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/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 MAX_WIDTH = 1280;
+const CLONE_RESOURCE_TIMEOUT_MS = 3e3;
 function getCaptureMetrics() {
 	return {
 		viewportWidth: window.innerWidth,
 		viewportHeight: window.innerHeight
 	};
 }
-/**
-* Resize canvas to max width while maintaining aspect ratio
-*/
-function resizeCanvas(canvas, maxWidth) {
-	if (canvas.width <= maxWidth) return canvas;
-	const scale = maxWidth / canvas.width;
-	const resized = document.createElement("canvas");
-	resized.width = maxWidth;
-	resized.height = Math.round(canvas.height * scale);
-	const ctx = resized.getContext("2d");
-	if (ctx) ctx.drawImage(canvas, 0, 0, resized.width, resized.height);
-	return resized;
+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.
@@ -352,8 +626,8 @@ function resizeCanvas(canvas, maxWidth) {
 */
 function createFallbackCanvas() {
 	const canvas = document.createElement("canvas");
-	canvas.width = Math.min(window.innerWidth, MAX_WIDTH);
-	canvas.height = Math.round(window.innerHeight / window.innerWidth * canvas.width);
+	canvas.width = window.innerWidth;
+	canvas.height = window.innerHeight;
 	const ctx = canvas.getContext("2d");
 	if (ctx) {
 		ctx.fillStyle = "#f0f0f0";
@@ -374,27 +648,44 @@ async function captureViewport() {
 	const captureMetrics = getCaptureMetrics();
 	let canvas;
 	try {
-		canvas = await html2canvas(document.body, {
-			scale: 1,
-			useCORS: true,
-			logging: false,
-			width: captureMetrics.viewportWidth,
-			height: captureMetrics.viewportHeight,
-			x: window.scrollX,
-			y: window.scrollY
-		});
+		canvas = await html2canvas(document.body, getHtml2CanvasOptions(captureMetrics));
 	} catch {
 		canvas = createFallbackCanvas();
 	}
-	const resized = resizeCanvas(canvas, MAX_WIDTH);
 	return {
-		imageData: resized.toDataURL("image/jpeg", .8),
-		width: resized.width,
-		height: resized.height,
+		imageData: canvas.toDataURL("image/png"),
+		width: canvas.width,
+		height: canvas.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);
+	return {
+		imageData: canvas.toDataURL("image/png"),
+		width: canvas.width,
+		height: canvas.height,
+		viewportWidth: captureMetrics.viewportWidth,
+		viewportHeight: captureMetrics.viewportHeight,
+		markerMap,
+		markerContext
+	};
+}
 //#endregion
 //#region src/core/services/screen-capture.ts
 /**
@@ -408,233 +699,418 @@ var ScreenCaptureService = class {
 	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/atoms.ts
+//#region src/core/utils/audio.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.
+* Audio conversion utilities for voice capture.
+* Converts Float32 audio data to WAV format for server transcription.
 */
-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/bezier.ts
 /**
-* Bezier flight animation for cursor pointing.
+* 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;
+}
 /**
-* Quadratic bezier curve: B(t) = (1-t)²P₀ + 2(1-t)t·P₁ + t²P₂
+* Convert Float32 audio data to 16-bit PCM
 */
-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
-	};
+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);
+	}
 }
 /**
-* Bezier tangent (derivative): B'(t) = 2(1-t)(P₁-P₀) + 2t(P₂-P₁)
+* Write a string to a DataView
 */
-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)
-	};
+function writeString(view, offset, string) {
+	for (let i = 0; i < string.length; i++) view.setUint8(offset + i, string.charCodeAt(i));
 }
 /**
-* Ease-in-out cubic for smooth acceleration/deceleration
+* Encode Float32 audio data as a WAV file
 */
-function easeInOutCubic(t) {
-	return t < .5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+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
 /**
-* 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
+* AudioWorklet processor code for voice capture.
+* Inlined as a blob URL to avoid separate file serving requirements.
 */
-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();
+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);
 	}
-	animationFrameId = requestAnimationFrame(animate);
-	return () => cancelAnimationFrame(animationFrameId);
+	return cachedBlobURL;
 }
 //#endregion
-//#region src/core/services/pointer-controller.ts
-const POINTING_LOCK_TIMEOUT_MS = 1e4;
+//#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;
+}
 /**
-* Controller for cursor pointing behavior.
-* Manages the pointer state machine (follow -> flying -> anchored -> follow)
-* and cursor animation.
+* Framework-agnostic service for voice capture using AudioWorkletNode.
 */
-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();
-	}
+var VoiceCaptureService = class {
+	audioContext = null;
+	workletNode = null;
+	sourceNode = null;
+	silentGainNode = null;
+	stream = null;
+	chunks = [];
+	levelCallback = null;
+	visualLevel = 0;
+	flushResolve = null;
 	/**
-	* Check if cursor is currently pointing (flying or anchored).
+	* Register a callback to receive audio level updates (0-1).
+	* Called at ~60fps during recording for waveform visualization.
 	*/
-	isPointing() {
-		return this.mode !== "follow";
+	onLevel(callback) {
+		this.levelCallback = callback;
 	}
 	/**
-	* Get current pointer mode.
+	* Start recording audio from the microphone.
+	* @throws Error if microphone access is denied
 	*/
-	getMode() {
-		return this.mode;
+	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);
 	}
 	/**
-	* Subscribe to pointer state changes.
+	* Stop recording and return the captured audio as a WAV blob.
 	*/
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
+	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;
 	}
 	/**
-	* Update buddy position to follow cursor when in follow mode.
-	* Call this on cursor position changes.
+	* Clean up all resources.
 	*/
-	updateFollowPosition() {
-		if (this.mode === "follow") {
-			$buddyPosition.set($cursorPosition.get());
-			$buddyRotation.set(0);
-			$buddyScale.set(1);
+	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.flushResolve = null;
+		this.levelCallback = null;
 	}
-	scheduleRelease() {
-		this.releaseTimeout = setTimeout(() => {
-			this.releaseTimeout = null;
-			this.release();
-		}, POINTING_LOCK_TIMEOUT_MS);
-	}
-	notify() {
-		this.listeners.forEach((listener) => listener());
+	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/pointing.ts
+//#region src/core/state-machine.ts
 /**
-* Parses [POINT:x,y:label] tags from AI responses.
-* Format matches the Swift Clicky app for consistency.
+* State transition table for the voice interaction flow.
+* Maps current state + event type to next state.
 */
-const POINTING_TAG_REGEX = /\[POINT:(\d+),(\d+):([^\]]+)\]\s*$/;
+const transitions = {
+	idle: { HOTKEY_PRESSED: "listening" },
+	listening: {
+		HOTKEY_RELEASED: "processing",
+		ERROR: "idle"
+	},
+	processing: {
+		AI_RESPONSE_COMPLETE: "responding",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	},
+	responding: {
+		TTS_COMPLETE: "idle",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	}
+};
 /**
-* Extract pointing target from response text.
-* Returns null if no valid POINT tag is found at the end.
+* 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 parsePointingTag(response) {
-	const match = response.match(POINTING_TAG_REGEX);
-	if (!match) return null;
+function createStateMachine(initial = "idle") {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		listeners.forEach((listener) => listener());
+	}
 	return {
-		x: parseInt(match[1], 10),
-		y: parseInt(match[2], 10),
-		label: match[3].trim()
+		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();
+		}
 	};
 }
-/**
-* Remove POINT tag from response text for display/TTS.
-*/
-function stripPointingTag(response) {
-	return response.replace(POINTING_TAG_REGEX, "").trim();
-}
 //#endregion
 //#region src/core/client.ts
 function clamp(value, min, max) {
 	return Math.min(Math.max(value, min), max);
 }
-function mapPointToViewport(target, screenshot) {
-	if (screenshot.width <= 0 || screenshot.height <= 0) return target;
+/**
+* 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 {
-		...target,
-		x: clamp(Math.round(target.x * scaleX), 0, Math.max(screenshot.viewportWidth - 1, 0)),
-		y: clamp(Math.round(target.y * scaleY), 0, Math.max(screenshot.viewportHeight - 1, 0))
+		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))
 	};
 }
 /**
@@ -658,6 +1134,7 @@ var CursorBuddyClient = class {
 	response = "";
 	error = null;
 	abortController = null;
+	historyCommittedForTurn = false;
 	cachedSnapshot;
 	listeners = /* @__PURE__ */ new Set();
 	constructor(endpoint, options = {}, services = {}) {
@@ -685,6 +1162,7 @@ var CursorBuddyClient = class {
 		this.transcript = "";
 		this.response = "";
 		this.error = null;
+		this.historyCommittedForTurn = false;
 		this.pointerController.release();
 		this.stateMachine.transition({ type: "HOTKEY_PRESSED" });
 		this.notify();
@@ -699,7 +1177,7 @@ var CursorBuddyClient = class {
 		this.stateMachine.transition({ type: "HOTKEY_RELEASED" });
 		const signal = this.abortController?.signal;
 		try {
-			const [audioBlob, screenshot] = await Promise.all([this.voiceCapture.stop(), this.screenCapture.capture()]);
+			const [audioBlob, screenshot] = await Promise.all([this.voiceCapture.stop(), this.screenCapture.captureAnnotated()]);
 			if (signal?.aborted) return;
 			const transcript = await this.transcribe(audioBlob, signal);
 			if (signal?.aborted) return;
@@ -708,7 +1186,7 @@ var CursorBuddyClient = class {
 			this.notify();
 			const response = await this.chat(transcript, screenshot, signal);
 			if (signal?.aborted) return;
-			const pointTarget = parsePointingTag(response);
+			const parsed = parsePointingTagRaw(response);
 			const cleanResponse = stripPointingTag(response);
 			this.response = cleanResponse;
 			this.stateMachine.transition({
@@ -728,10 +1206,21 @@ var CursorBuddyClient = class {
 				}
 			];
 			$conversationHistory.set(newHistory);
+			this.historyCommittedForTurn = true;
+			let pointTarget = null;
+			if (parsed) if (parsed.type === "marker") {
+				const coords = resolveMarkerToCoordinates(screenshot.markerMap, parsed.markerId);
+				if (coords) pointTarget = {
+					...coords,
+					label: parsed.label
+				};
+			} else pointTarget = {
+				...mapCoordinatesToViewport(parsed.x, parsed.y, screenshot),
+				label: parsed.label
+			};
 			if (pointTarget) {
-				const mappedTarget = mapPointToViewport(pointTarget, screenshot);
-				this.options.onPoint?.(mappedTarget);
-				this.pointerController.pointAt(mappedTarget);
+				this.options.onPoint?.(pointTarget);
+				this.pointerController.pointAt(pointTarget);
 			}
 			if (cleanResponse) await this.speak(cleanResponse, signal);
 			if (signal?.aborted) return;
@@ -772,6 +1261,7 @@ var CursorBuddyClient = class {
 		this.transcript = "";
 		this.response = "";
 		this.error = null;
+		this.historyCommittedForTurn = false;
 		this.pointerController.release();
 		this.stateMachine.reset();
 		this.notify();
@@ -811,11 +1301,34 @@ var CursorBuddyClient = class {
 		};
 	}
 	abort() {
+		this.commitPartialHistory();
 		this.abortController?.abort();
 		this.abortController = null;
 		this.audioPlayback.stop();
 		$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");
@@ -840,7 +1353,8 @@ var CursorBuddyClient = class {
 					height: screenshot.height
 				},
 				transcript,
-				history
+				history,
+				markerContext: screenshot.markerContext
 			}),
 			signal
 		});
@@ -887,4 +1401,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-Bd33JD8T.mjs.map
+//# sourceMappingURL=client-DAa4L2fE.mjs.map