cursor-buddy 0.0.1 → 0.0.2

package/dist/client-Bd33JD8T.mjs

@@ -0,0 +1,890 @@
+import html2canvas from "html2canvas-pro";
+import { atom } from "nanostores";
+//#region src/core/state-machine.ts
+/**
+* State transition table for the voice interaction flow.
+* Maps current state + event type to next state.
+*/
+const transitions = {
+	idle: { HOTKEY_PRESSED: "listening" },
+	listening: {
+		HOTKEY_RELEASED: "processing",
+		ERROR: "idle"
+	},
+	processing: {
+		AI_RESPONSE_COMPLETE: "responding",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	},
+	responding: {
+		TTS_COMPLETE: "idle",
+		HOTKEY_PRESSED: "listening",
+		ERROR: "idle"
+	}
+};
+/**
+* Create a simple typed state machine for the voice interaction flow.
+*
+* States: idle -> listening -> processing -> responding -> idle
+*
+* Supports interruption: pressing hotkey during processing or responding
+* immediately transitions back to listening.
+*/
+function createStateMachine(initial = "idle") {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		listeners.forEach((listener) => listener());
+	}
+	return {
+		getState: () => state,
+		transition: (event) => {
+			const nextState = transitions[state][event.type];
+			if (!nextState) return false;
+			state = nextState;
+			notify();
+			return true;
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		reset: () => {
+			state = "idle";
+			notify();
+		}
+	};
+}
+//#endregion
+//#region src/core/utils/audio-worklet.ts
+/**
+* AudioWorklet processor code for voice capture.
+* Inlined as a blob URL to avoid separate file serving requirements.
+*/
+const workletCode = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super()
+    this.isRecording = true
+  }
+
+  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
+  }
+}
+
+registerProcessor("audio-capture-processor", AudioCaptureProcessor)
+`;
+let cachedBlobURL = null;
+/**
+* Create a blob URL for the audio worklet processor.
+* Caches the URL to avoid creating multiple blobs.
+*/
+function createWorkletBlobURL() {
+	if (!cachedBlobURL) {
+		const blob = new Blob([workletCode], { type: "application/javascript" });
+		cachedBlobURL = URL.createObjectURL(blob);
+	}
+	return cachedBlobURL;
+}
+//#endregion
+//#region src/core/utils/audio.ts
+/**
+* Audio conversion utilities for voice capture.
+* Converts Float32 audio data to WAV format for server transcription.
+*/
+/**
+* Merge multiple Float32Array chunks into a single array
+*/
+function mergeAudioChunks(chunks) {
+	const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+	const result = new Float32Array(totalLength);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+/**
+* Convert Float32 audio data to 16-bit PCM
+*/
+function floatTo16BitPCM(output, offset, input) {
+	for (let i = 0; i < input.length; i++, offset += 2) {
+		const sample = Math.max(-1, Math.min(1, input[i]));
+		output.setInt16(offset, sample < 0 ? sample * 32768 : sample * 32767, true);
+	}
+}
+/**
+* Write a string to a DataView
+*/
+function writeString(view, offset, string) {
+	for (let i = 0; i < string.length; i++) view.setUint8(offset + i, string.charCodeAt(i));
+}
+/**
+* Encode Float32 audio data as a WAV file
+*/
+function encodeWAV(samples, sampleRate) {
+	const numChannels = 1;
+	const bitsPerSample = 16;
+	const bytesPerSample = bitsPerSample / 8;
+	const blockAlign = numChannels * bytesPerSample;
+	const dataLength = samples.length * bytesPerSample;
+	const buffer = new ArrayBuffer(44 + dataLength);
+	const view = new DataView(buffer);
+	writeString(view, 0, "RIFF");
+	view.setUint32(4, 36 + dataLength, true);
+	writeString(view, 8, "WAVE");
+	writeString(view, 12, "fmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, numChannels, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, sampleRate * blockAlign, true);
+	view.setUint16(32, blockAlign, true);
+	view.setUint16(34, bitsPerSample, true);
+	writeString(view, 36, "data");
+	view.setUint32(40, dataLength, true);
+	floatTo16BitPCM(view, 44, samples);
+	return new Blob([buffer], { type: "audio/wav" });
+}
+//#endregion
+//#region src/core/services/voice-capture.ts
+const SAMPLE_RATE = 16e3;
+const AUDIO_LEVEL_BOOST = 10.2;
+/**
+* Framework-agnostic service for voice capture using AudioWorkletNode.
+*/
+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;
+	}
+	/**
+	* Start recording audio from the microphone.
+	* @throws Error if microphone access is denied
+	*/
+	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);
+			}
+		};
+		source.connect(workletNode);
+	}
+	/**
+	* Stop recording and return the captured audio as a WAV blob.
+	*/
+	async stop() {
+		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) {
+			await this.audioContext.close();
+			this.audioContext = null;
+		}
+		this.levelCallback?.(0);
+		const wavBlob = encodeWAV(mergeAudioChunks(this.chunks), SAMPLE_RATE);
+		this.chunks = [];
+		return wavBlob;
+	}
+	/**
+	* Clean up all resources.
+	*/
+	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;
+	}
+};
+//#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
+	*/
+	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);
+			});
+		});
+	}
+	/**
+	* Stop any currently playing audio.
+	*/
+	stop() {
+		if (this.audio) {
+			this.audio.pause();
+			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/screenshot.ts
+const MAX_WIDTH = 1280;
+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;
+}
+/**
+* Create a fallback canvas when screenshot capture fails.
+* Returns a simple gray canvas with an error message.
+*/
+function createFallbackCanvas() {
+	const canvas = document.createElement("canvas");
+	canvas.width = Math.min(window.innerWidth, MAX_WIDTH);
+	canvas.height = Math.round(window.innerHeight / window.innerWidth * canvas.width);
+	const ctx = canvas.getContext("2d");
+	if (ctx) {
+		ctx.fillStyle = "#f0f0f0";
+		ctx.fillRect(0, 0, canvas.width, canvas.height);
+		ctx.fillStyle = "#666";
+		ctx.font = "16px sans-serif";
+		ctx.textAlign = "center";
+		ctx.fillText("Screenshot unavailable", canvas.width / 2, canvas.height / 2);
+	}
+	return canvas;
+}
+/**
+* Capture a screenshot of the current viewport.
+* Uses html2canvas to render the DOM to a canvas, then exports as JPEG.
+* Falls back to a placeholder if capture fails (e.g., due to unsupported CSS).
+*/
+async function captureViewport() {
+	const captureMetrics = getCaptureMetrics();
+	let canvas;
+	try {
+		canvas = await html2canvas(document.body, {
+			scale: 1,
+			useCORS: true,
+			logging: false,
+			width: captureMetrics.viewportWidth,
+			height: captureMetrics.viewportHeight,
+			x: window.scrollX,
+			y: window.scrollY
+		});
+	} catch {
+		canvas = createFallbackCanvas();
+	}
+	const resized = resizeCanvas(canvas, MAX_WIDTH);
+	return {
+		imageData: resized.toDataURL("image/jpeg", .8),
+		width: resized.width,
+		height: resized.height,
+		viewportWidth: captureMetrics.viewportWidth,
+		viewportHeight: captureMetrics.viewportHeight
+	};
+}
+//#endregion
+//#region src/core/services/screen-capture.ts
+/**
+* Framework-agnostic service for capturing viewport screenshots.
+*/
+var ScreenCaptureService = class {
+	/**
+	* Capture a screenshot of the current viewport.
+	* @returns Screenshot result with image data and dimensions
+	*/
+	async capture() {
+		return captureViewport();
+	}
+};
+//#endregion
+//#region src/core/atoms.ts
+/**
+* Nanostores atoms for reactive values that don't need state machine semantics.
+* These update frequently (e.g., 60fps audio levels) and are framework-agnostic.
+*/
+const $audioLevel = atom(0);
+const $cursorPosition = atom({
+	x: 0,
+	y: 0
+});
+const $buddyPosition = atom({
+	x: 0,
+	y: 0
+});
+const $buddyRotation = atom(0);
+const $buddyScale = atom(1);
+const $pointingTarget = atom(null);
+const $isEnabled = atom(true);
+atom(false);
+const $conversationHistory = atom([]);
+//#endregion
+//#region src/core/bezier.ts
+/**
+* Bezier flight animation for cursor pointing.
+*/
+/**
+* Quadratic bezier curve: B(t) = (1-t)²P₀ + 2(1-t)t·P₁ + t²P₂
+*/
+function quadraticBezier(p0, p1, p2, t) {
+	const oneMinusT = 1 - t;
+	return {
+		x: oneMinusT * oneMinusT * p0.x + 2 * oneMinusT * t * p1.x + t * t * p2.x,
+		y: oneMinusT * oneMinusT * p0.y + 2 * oneMinusT * t * p1.y + t * t * p2.y
+	};
+}
+/**
+* Bezier tangent (derivative): B'(t) = 2(1-t)(P₁-P₀) + 2t(P₂-P₁)
+*/
+function bezierTangent(p0, p1, p2, t) {
+	const oneMinusT = 1 - t;
+	return {
+		x: 2 * oneMinusT * (p1.x - p0.x) + 2 * t * (p2.x - p1.x),
+		y: 2 * oneMinusT * (p1.y - p0.y) + 2 * t * (p2.y - p1.y)
+	};
+}
+/**
+* Ease-in-out cubic for smooth acceleration/deceleration
+*/
+function easeInOutCubic(t) {
+	return t < .5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+}
+/**
+* Animate cursor along a parabolic bezier arc from start to end.
+* Used when the AI points at a UI element.
+*
+* @param from - Starting position
+* @param to - Target position
+* @param durationMs - Flight duration in milliseconds
+* @param callbacks - Frame and completion callbacks
+* @returns Cancel function to stop the animation
+*/
+function animateBezierFlight(from, to, durationMs, callbacks) {
+	const startTime = performance.now();
+	const distance = Math.hypot(to.x - from.x, to.y - from.y);
+	const controlPoint = {
+		x: (from.x + to.x) / 2,
+		y: Math.min(from.y, to.y) - distance * .2
+	};
+	let animationFrameId;
+	function animate(now) {
+		const elapsed = now - startTime;
+		const linearProgress = Math.min(elapsed / durationMs, 1);
+		const easedProgress = easeInOutCubic(linearProgress);
+		const position = quadraticBezier(from, controlPoint, to, easedProgress);
+		const tangent = bezierTangent(from, controlPoint, to, easedProgress);
+		const rotation = Math.atan2(tangent.y, tangent.x);
+		const scale = 1 + Math.sin(linearProgress * Math.PI) * .3;
+		callbacks.onFrame(position, rotation, scale);
+		if (linearProgress < 1) animationFrameId = requestAnimationFrame(animate);
+		else callbacks.onComplete();
+	}
+	animationFrameId = requestAnimationFrame(animate);
+	return () => cancelAnimationFrame(animationFrameId);
+}
+//#endregion
+//#region src/core/services/pointer-controller.ts
+const POINTING_LOCK_TIMEOUT_MS = 1e4;
+/**
+* Controller for cursor pointing behavior.
+* Manages the pointer state machine (follow -> flying -> anchored -> follow)
+* and cursor animation.
+*/
+var PointerController = class {
+	mode = "follow";
+	cancelAnimation = null;
+	releaseTimeout = null;
+	listeners = /* @__PURE__ */ new Set();
+	/**
+	* Animate cursor to point at a target.
+	*/
+	pointAt(target) {
+		this.release();
+		this.mode = "flying";
+		$pointingTarget.set(target);
+		const startPos = $buddyPosition.get();
+		const endPos = {
+			x: target.x,
+			y: target.y
+		};
+		this.cancelAnimation = animateBezierFlight(startPos, endPos, 800, {
+			onFrame: (position, rotation, scale) => {
+				$buddyPosition.set(position);
+				$buddyRotation.set(rotation);
+				$buddyScale.set(scale);
+			},
+			onComplete: () => {
+				this.cancelAnimation = null;
+				this.mode = "anchored";
+				$buddyPosition.set(endPos);
+				$buddyRotation.set(0);
+				$buddyScale.set(1);
+				this.scheduleRelease();
+				this.notify();
+			}
+		});
+		this.notify();
+	}
+	/**
+	* Release the cursor from pointing mode back to follow mode.
+	*/
+	release() {
+		if (this.cancelAnimation) {
+			this.cancelAnimation();
+			this.cancelAnimation = null;
+		}
+		if (this.releaseTimeout) {
+			clearTimeout(this.releaseTimeout);
+			this.releaseTimeout = null;
+		}
+		this.mode = "follow";
+		$pointingTarget.set(null);
+		$buddyPosition.set($cursorPosition.get());
+		$buddyRotation.set(0);
+		$buddyScale.set(1);
+		this.notify();
+	}
+	/**
+	* Check if cursor is currently pointing (flying or anchored).
+	*/
+	isPointing() {
+		return this.mode !== "follow";
+	}
+	/**
+	* Get current pointer mode.
+	*/
+	getMode() {
+		return this.mode;
+	}
+	/**
+	* Subscribe to pointer state changes.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Update buddy position to follow cursor when in follow mode.
+	* Call this on cursor position changes.
+	*/
+	updateFollowPosition() {
+		if (this.mode === "follow") {
+			$buddyPosition.set($cursorPosition.get());
+			$buddyRotation.set(0);
+			$buddyScale.set(1);
+		}
+	}
+	scheduleRelease() {
+		this.releaseTimeout = setTimeout(() => {
+			this.releaseTimeout = null;
+			this.release();
+		}, POINTING_LOCK_TIMEOUT_MS);
+	}
+	notify() {
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#endregion
+//#region src/core/pointing.ts
+/**
+* Parses [POINT:x,y:label] tags from AI responses.
+* Format matches the Swift Clicky app for consistency.
+*/
+const POINTING_TAG_REGEX = /\[POINT:(\d+),(\d+):([^\]]+)\]\s*$/;
+/**
+* Extract pointing target from response text.
+* Returns null if no valid POINT tag is found at the end.
+*/
+function parsePointingTag(response) {
+	const match = response.match(POINTING_TAG_REGEX);
+	if (!match) return null;
+	return {
+		x: parseInt(match[1], 10),
+		y: parseInt(match[2], 10),
+		label: match[3].trim()
+	};
+}
+/**
+* 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;
+	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))
+	};
+}
+/**
+* Framework-agnostic client for cursor buddy voice interactions.
+*
+* Manages the complete voice interaction flow:
+* idle -> listening -> processing -> responding -> idle
+*
+* Supports interruption: pressing hotkey during any state aborts
+* in-flight work and immediately transitions to listening.
+*/
+var CursorBuddyClient = class {
+	endpoint;
+	options;
+	voiceCapture;
+	audioPlayback;
+	screenCapture;
+	pointerController;
+	stateMachine;
+	transcript = "";
+	response = "";
+	error = null;
+	abortController = null;
+	cachedSnapshot;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(endpoint, options = {}, services = {}) {
+		this.endpoint = endpoint;
+		this.options = options;
+		this.voiceCapture = services.voiceCapture ?? new VoiceCaptureService();
+		this.audioPlayback = services.audioPlayback ?? new AudioPlaybackService();
+		this.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.stateMachine.subscribe(() => {
+			this.options.onStateChange?.(this.stateMachine.getState());
+			this.notify();
+		});
+		this.pointerController.subscribe(() => this.notify());
+	}
+	/**
+	* Start listening for voice input.
+	* Aborts any in-flight work from previous session.
+	*/
+	startListening() {
+		this.abort();
+		this.transcript = "";
+		this.response = "";
+		this.error = null;
+		this.pointerController.release();
+		this.stateMachine.transition({ type: "HOTKEY_PRESSED" });
+		this.notify();
+		this.abortController = new AbortController();
+		this.voiceCapture.start().catch((err) => this.handleError(err));
+	}
+	/**
+	* Stop listening and process the voice input.
+	*/
+	async stopListening() {
+		if (this.stateMachine.getState() !== "listening") return;
+		this.stateMachine.transition({ type: "HOTKEY_RELEASED" });
+		const signal = this.abortController?.signal;
+		try {
+			const [audioBlob, screenshot] = await Promise.all([this.voiceCapture.stop(), this.screenCapture.capture()]);
+			if (signal?.aborted) return;
+			const transcript = await this.transcribe(audioBlob, signal);
+			if (signal?.aborted) return;
+			this.transcript = transcript;
+			this.options.onTranscript?.(transcript);
+			this.notify();
+			const response = await this.chat(transcript, screenshot, signal);
+			if (signal?.aborted) return;
+			const pointTarget = parsePointingTag(response);
+			const cleanResponse = stripPointingTag(response);
+			this.response = cleanResponse;
+			this.stateMachine.transition({
+				type: "AI_RESPONSE_COMPLETE",
+				response: cleanResponse
+			});
+			this.options.onResponse?.(cleanResponse);
+			const newHistory = [
+				...$conversationHistory.get(),
+				{
+					role: "user",
+					content: transcript
+				},
+				{
+					role: "assistant",
+					content: cleanResponse
+				}
+			];
+			$conversationHistory.set(newHistory);
+			if (pointTarget) {
+				const mappedTarget = mapPointToViewport(pointTarget, screenshot);
+				this.options.onPoint?.(mappedTarget);
+				this.pointerController.pointAt(mappedTarget);
+			}
+			if (cleanResponse) await this.speak(cleanResponse, signal);
+			if (signal?.aborted) return;
+			this.stateMachine.transition({ type: "TTS_COMPLETE" });
+		} catch (err) {
+			if (signal?.aborted) return;
+			this.handleError(err instanceof Error ? err : /* @__PURE__ */ new Error("Unknown error"));
+		}
+	}
+	/**
+	* Enable or disable the buddy.
+	*/
+	setEnabled(enabled) {
+		$isEnabled.set(enabled);
+		this.notify();
+	}
+	/**
+	* Manually point at coordinates.
+	*/
+	pointAt(x, y, label) {
+		this.pointerController.pointAt({
+			x,
+			y,
+			label
+		});
+	}
+	/**
+	* Dismiss the current pointing target.
+	*/
+	dismissPointing() {
+		this.pointerController.release();
+	}
+	/**
+	* Reset to idle state and stop any in-progress work.
+	*/
+	reset() {
+		this.abort();
+		this.transcript = "";
+		this.response = "";
+		this.error = null;
+		this.pointerController.release();
+		this.stateMachine.reset();
+		this.notify();
+	}
+	/**
+	* Update buddy position to follow cursor.
+	* Call this on cursor position changes.
+	*/
+	updateCursorPosition() {
+		this.pointerController.updateFollowPosition();
+	}
+	/**
+	* Subscribe to state changes.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	}
+	/**
+	* Get current state snapshot for React's useSyncExternalStore.
+	* Returns a cached object to ensure referential stability.
+	*/
+	getSnapshot() {
+		return this.cachedSnapshot;
+	}
+	/**
+	* Build a new snapshot object.
+	*/
+	buildSnapshot() {
+		return {
+			state: this.stateMachine.getState(),
+			transcript: this.transcript,
+			response: this.response,
+			error: this.error,
+			isPointing: this.pointerController.isPointing(),
+			isEnabled: $isEnabled.get()
+		};
+	}
+	abort() {
+		this.abortController?.abort();
+		this.abortController = null;
+		this.audioPlayback.stop();
+		$audioLevel.set(0);
+	}
+	async transcribe(blob, signal) {
+		const formData = new FormData();
+		formData.append("audio", blob, "recording.wav");
+		const response = await fetch(`${this.endpoint}/transcribe`, {
+			method: "POST",
+			body: formData,
+			signal
+		});
+		if (!response.ok) throw new Error("Transcription failed");
+		const { text } = await response.json();
+		return text;
+	}
+	async chat(transcript, screenshot, signal) {
+		const history = $conversationHistory.get();
+		const response = await fetch(`${this.endpoint}/chat`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				screenshot: screenshot.imageData,
+				capture: {
+					width: screenshot.width,
+					height: screenshot.height
+				},
+				transcript,
+				history
+			}),
+			signal
+		});
+		if (!response.ok) throw new Error("Chat request failed");
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("No response body");
+		const decoder = new TextDecoder();
+		let fullResponse = "";
+		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();
+		}
+		return fullResponse;
+	}
+	async speak(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);
+	}
+	handleError(err) {
+		this.error = err;
+		this.stateMachine.transition({
+			type: "ERROR",
+			error: err
+		});
+		this.options.onError?.(err);
+		this.notify();
+	}
+	notify() {
+		this.cachedSnapshot = this.buildSnapshot();
+		this.listeners.forEach((listener) => listener());
+	}
+};
+//#endregion
+export { $buddyScale as a, $buddyRotation as i, $audioLevel as n, $cursorPosition as o, $buddyPosition as r, $pointingTarget as s, CursorBuddyClient as t };
+
+//# sourceMappingURL=client-Bd33JD8T.mjs.map