agents 0.22.0 → 0.23.0

package/dist/voice/client.js

@@ -0,0 +1,932 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { VOICE_PROTOCOL_VERSION } from "./types.js";
+import { toVoiceError } from "./errors.js";
+import { t as ClientDiagnostics } from "../diagnostics-C4jcz3VK.js";
+import { PartySocket } from "partysocket";
+//#region src/voice/client.ts
+function camelCaseToKebabCase(str) {
+	if (str === str.toUpperCase() && str !== str.toLowerCase()) return str.toLowerCase().replace(/_/g, "-");
+	let kebabified = str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+	kebabified = kebabified.startsWith("-") ? kebabified.slice(1) : kebabified;
+	return kebabified.replace(/_/g, "-").replace(/-$/, "");
+}
+const UNSUPPORTED_OUTPUT_DEVICE_ERROR = "Audio output device selection is not supported in this browser.";
+const OUTPUT_DEVICE_SWITCH_ERROR = "Could not switch audio output device.";
+const WORKLET_PROCESSOR = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.buffer = [];
+    this.sampleRate = sampleRate;
+    this.targetRate = 16000;
+    this.ratio = this.sampleRate / this.targetRate;
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || !input[0]) return true;
+
+    const channelData = input[0];
+
+    // Linear interpolation resampling (e.g. 48kHz → 16kHz).
+    // Nearest-neighbor (picking every Nth sample) introduces aliasing
+    // artifacts, especially on sibilants (s, f, th). Linear interpolation
+    // blends adjacent samples, acting as a basic low-pass filter.
+    for (let i = 0; i < channelData.length; i += this.ratio) {
+      const idx = Math.floor(i);
+      const frac = i - idx;
+      if (idx + 1 < channelData.length) {
+        this.buffer.push(channelData[idx] * (1 - frac) + channelData[idx + 1] * frac);
+      } else if (idx < channelData.length) {
+        this.buffer.push(channelData[idx]);
+      }
+    }
+
+    if (this.buffer.length >= 1600) {
+      const chunk = new Float32Array(this.buffer);
+      this.port.postMessage({ type: 'audio', samples: chunk }, [chunk.buffer]);
+      this.buffer = [];
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('audio-capture-processor', AudioCaptureProcessor);
+`;
+function floatTo16BitPCM(samples) {
+	const buffer = /* @__PURE__ */ new ArrayBuffer(samples.length * 2);
+	const view = new DataView(buffer);
+	for (let i = 0; i < samples.length; i++) {
+		const s = Math.max(-1, Math.min(1, samples[i]));
+		view.setInt16(i * 2, s < 0 ? s * 32768 : s * 32767, true);
+	}
+	return buffer;
+}
+function computeRMS(samples) {
+	let sum = 0;
+	for (let i = 0; i < samples.length; i++) sum += samples[i] * samples[i];
+	return Math.sqrt(sum / samples.length);
+}
+var _socket = /* @__PURE__ */ new WeakMap();
+var _options = /* @__PURE__ */ new WeakMap();
+/**
+* Default VoiceTransport backed by PartySocket (reconnecting WebSocket).
+* Created automatically when no custom transport is provided.
+*/
+var WebSocketVoiceTransport = class {
+	constructor(options) {
+		_classPrivateFieldInitSpec(this, _socket, null);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		this.onopen = null;
+		this.onclose = null;
+		this.onerror = null;
+		this.onmessage = null;
+		_classPrivateFieldSet2(_options, this, options);
+	}
+	get connected() {
+		return _classPrivateFieldGet2(_socket, this)?.readyState === WebSocket.OPEN;
+	}
+	sendJSON(data) {
+		if (_classPrivateFieldGet2(_socket, this)?.readyState === WebSocket.OPEN) _classPrivateFieldGet2(_socket, this).send(JSON.stringify(data));
+	}
+	sendBinary(data) {
+		if (_classPrivateFieldGet2(_socket, this)?.readyState === WebSocket.OPEN) _classPrivateFieldGet2(_socket, this).send(data);
+	}
+	connect() {
+		if (_classPrivateFieldGet2(_socket, this)) return;
+		const socket = new PartySocket({
+			party: camelCaseToKebabCase(_classPrivateFieldGet2(_options, this).agent),
+			room: _classPrivateFieldGet2(_options, this).name ?? "default",
+			host: _classPrivateFieldGet2(_options, this).host ?? window.location.host,
+			prefix: "agents",
+			query: _classPrivateFieldGet2(_options, this).query
+		});
+		socket.onopen = () => this.onopen?.();
+		socket.onclose = (event) => this.onclose?.(event ? {
+			code: event.code,
+			reason: event.reason,
+			wasClean: event.wasClean
+		} : void 0);
+		socket.onerror = (event) => this.onerror?.(event);
+		socket.onmessage = (event) => {
+			this.onmessage?.(event.data);
+		};
+		_classPrivateFieldSet2(_socket, this, socket);
+	}
+	disconnect() {
+		_classPrivateFieldGet2(_socket, this)?.close();
+		_classPrivateFieldSet2(_socket, this, null);
+	}
+};
+var _status = /* @__PURE__ */ new WeakMap();
+var _transcript = /* @__PURE__ */ new WeakMap();
+var _metrics = /* @__PURE__ */ new WeakMap();
+var _turnMetrics = /* @__PURE__ */ new WeakMap();
+var _audioLevel = /* @__PURE__ */ new WeakMap();
+var _isMuted = /* @__PURE__ */ new WeakMap();
+var _connected = /* @__PURE__ */ new WeakMap();
+var _error = /* @__PURE__ */ new WeakMap();
+var _outputDeviceError = /* @__PURE__ */ new WeakMap();
+var _lastCustomMessage = /* @__PURE__ */ new WeakMap();
+var _audioFormat = /* @__PURE__ */ new WeakMap();
+var _sampleRate = /* @__PURE__ */ new WeakMap();
+var _interimTranscript = /* @__PURE__ */ new WeakMap();
+var _serverProtocolVersion = /* @__PURE__ */ new WeakMap();
+var _inCall = /* @__PURE__ */ new WeakMap();
+var _callGeneration = /* @__PURE__ */ new WeakMap();
+var _serverCallAcknowledged = /* @__PURE__ */ new WeakMap();
+var _diagnostics = /* @__PURE__ */ new WeakMap();
+var _audioReceivedForCurrentTurn = /* @__PURE__ */ new WeakMap();
+var _diagnosticTurnId = /* @__PURE__ */ new WeakMap();
+var _silenceThreshold = /* @__PURE__ */ new WeakMap();
+var _silenceDurationMs = /* @__PURE__ */ new WeakMap();
+var _interruptThreshold = /* @__PURE__ */ new WeakMap();
+var _interruptChunks = /* @__PURE__ */ new WeakMap();
+var _maxTranscriptMessages = /* @__PURE__ */ new WeakMap();
+var _transport = /* @__PURE__ */ new WeakMap();
+var _options2 = /* @__PURE__ */ new WeakMap();
+var _audioContext = /* @__PURE__ */ new WeakMap();
+var _workletRegistered = /* @__PURE__ */ new WeakMap();
+var _workletNode = /* @__PURE__ */ new WeakMap();
+var _stream = /* @__PURE__ */ new WeakMap();
+var _silenceTimer = /* @__PURE__ */ new WeakMap();
+var _isSpeaking = /* @__PURE__ */ new WeakMap();
+var _playbackQueue = /* @__PURE__ */ new WeakMap();
+var _isPlaying = /* @__PURE__ */ new WeakMap();
+var _isScheduling = /* @__PURE__ */ new WeakMap();
+var _scheduledSources = /* @__PURE__ */ new WeakMap();
+var _playbackCursor = /* @__PURE__ */ new WeakMap();
+var _lastPlaybackEnd = /* @__PURE__ */ new WeakMap();
+var _playbackElement = /* @__PURE__ */ new WeakMap();
+var _playbackDestination = /* @__PURE__ */ new WeakMap();
+var _playbackDestinationPromise = /* @__PURE__ */ new WeakMap();
+var _useDefaultPlaybackDestination = /* @__PURE__ */ new WeakMap();
+var _outputDeviceId = /* @__PURE__ */ new WeakMap();
+var _outputDeviceSwitchGeneration = /* @__PURE__ */ new WeakMap();
+var _playbackOutputGeneration = /* @__PURE__ */ new WeakMap();
+var _playbackGeneration = /* @__PURE__ */ new WeakMap();
+var _interruptChunkCount = /* @__PURE__ */ new WeakMap();
+var _listeners = /* @__PURE__ */ new WeakMap();
+var _VoiceClient_brand = /* @__PURE__ */ new WeakSet();
+var VoiceClient = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _VoiceClient_brand);
+		_classPrivateFieldInitSpec(this, _status, "idle");
+		_classPrivateFieldInitSpec(this, _transcript, []);
+		_classPrivateFieldInitSpec(this, _metrics, null);
+		_classPrivateFieldInitSpec(this, _turnMetrics, null);
+		_classPrivateFieldInitSpec(this, _audioLevel, 0);
+		_classPrivateFieldInitSpec(this, _isMuted, false);
+		_classPrivateFieldInitSpec(this, _connected, false);
+		_classPrivateFieldInitSpec(this, _error, null);
+		_classPrivateFieldInitSpec(this, _outputDeviceError, null);
+		_classPrivateFieldInitSpec(this, _lastCustomMessage, null);
+		_classPrivateFieldInitSpec(this, _audioFormat, null);
+		_classPrivateFieldInitSpec(this, _sampleRate, 16e3);
+		_classPrivateFieldInitSpec(this, _interimTranscript, null);
+		_classPrivateFieldInitSpec(this, _serverProtocolVersion, null);
+		_classPrivateFieldInitSpec(this, _inCall, false);
+		_classPrivateFieldInitSpec(this, _callGeneration, 0);
+		_classPrivateFieldInitSpec(this, _serverCallAcknowledged, false);
+		_classPrivateFieldInitSpec(this, _diagnostics, new ClientDiagnostics());
+		_classPrivateFieldInitSpec(this, _audioReceivedForCurrentTurn, false);
+		_classPrivateFieldInitSpec(this, _diagnosticTurnId, null);
+		_classPrivateFieldInitSpec(this, _silenceThreshold, void 0);
+		_classPrivateFieldInitSpec(this, _silenceDurationMs, void 0);
+		_classPrivateFieldInitSpec(this, _interruptThreshold, void 0);
+		_classPrivateFieldInitSpec(this, _interruptChunks, void 0);
+		_classPrivateFieldInitSpec(this, _maxTranscriptMessages, void 0);
+		_classPrivateFieldInitSpec(this, _transport, null);
+		_classPrivateFieldInitSpec(this, _options2, void 0);
+		_classPrivateFieldInitSpec(this, _audioContext, null);
+		_classPrivateFieldInitSpec(this, _workletRegistered, false);
+		_classPrivateFieldInitSpec(this, _workletNode, null);
+		_classPrivateFieldInitSpec(this, _stream, null);
+		_classPrivateFieldInitSpec(this, _silenceTimer, null);
+		_classPrivateFieldInitSpec(this, _isSpeaking, false);
+		_classPrivateFieldInitSpec(this, _playbackQueue, []);
+		_classPrivateFieldInitSpec(this, _isPlaying, false);
+		_classPrivateFieldInitSpec(this, _isScheduling, false);
+		_classPrivateFieldInitSpec(this, _scheduledSources, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _playbackCursor, 0);
+		_classPrivateFieldInitSpec(this, _lastPlaybackEnd, null);
+		_classPrivateFieldInitSpec(this, _playbackElement, null);
+		_classPrivateFieldInitSpec(this, _playbackDestination, null);
+		_classPrivateFieldInitSpec(this, _playbackDestinationPromise, null);
+		_classPrivateFieldInitSpec(this, _useDefaultPlaybackDestination, false);
+		_classPrivateFieldInitSpec(this, _outputDeviceId, void 0);
+		_classPrivateFieldInitSpec(this, _outputDeviceSwitchGeneration, 0);
+		_classPrivateFieldInitSpec(this, _playbackOutputGeneration, 0);
+		_classPrivateFieldInitSpec(this, _playbackGeneration, 0);
+		_classPrivateFieldInitSpec(this, _interruptChunkCount, 0);
+		_classPrivateFieldInitSpec(this, _listeners, /* @__PURE__ */ new Map());
+		_classPrivateFieldSet2(_options2, this, options);
+		_classPrivateFieldSet2(_silenceThreshold, this, options.silenceThreshold ?? .04);
+		_classPrivateFieldSet2(_silenceDurationMs, this, options.silenceDurationMs ?? 500);
+		_classPrivateFieldSet2(_interruptThreshold, this, options.interruptThreshold ?? .05);
+		_classPrivateFieldSet2(_interruptChunks, this, options.interruptChunks ?? 2);
+		_classPrivateFieldSet2(_maxTranscriptMessages, this, options.maxTranscriptMessages ?? 200);
+		_classPrivateFieldSet2(_outputDeviceId, this, options.outputDeviceId ?? "default");
+	}
+	get status() {
+		return _classPrivateFieldGet2(_status, this);
+	}
+	get transcript() {
+		return _classPrivateFieldGet2(_transcript, this);
+	}
+	get metrics() {
+		return _classPrivateFieldGet2(_metrics, this);
+	}
+	/** Last stable terminal summary received for any speech or text turn. */
+	get turnMetrics() {
+		return _classPrivateFieldGet2(_turnMetrics, this);
+	}
+	get audioLevel() {
+		return _classPrivateFieldGet2(_audioLevel, this);
+	}
+	get isMuted() {
+		return _classPrivateFieldGet2(_isMuted, this);
+	}
+	get connected() {
+		return _classPrivateFieldGet2(_connected, this);
+	}
+	get error() {
+		return _classPrivateFieldGet2(_error, this);
+	}
+	get outputDeviceError() {
+		return _classPrivateFieldGet2(_outputDeviceError, this);
+	}
+	/**
+	* The current interim (partial) transcript from streaming STT.
+	* Updates in real time as the user speaks. Cleared when the final
+	* transcript is produced or the call reaches a terminal reset.
+	* null when no interim text is available.
+	*/
+	get interimTranscript() {
+		return _classPrivateFieldGet2(_interimTranscript, this);
+	}
+	/**
+	* The protocol version reported by the server.
+	* null until the server sends its welcome message.
+	*/
+	get serverProtocolVersion() {
+		return _classPrivateFieldGet2(_serverProtocolVersion, this);
+	}
+	addEventListener(event, listener) {
+		let set = _classPrivateFieldGet2(_listeners, this).get(event);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			_classPrivateFieldGet2(_listeners, this).set(event, set);
+		}
+		set.add(listener);
+	}
+	removeEventListener(event, listener) {
+		_classPrivateFieldGet2(_listeners, this).get(event)?.delete(listener);
+	}
+	connect() {
+		if (_classPrivateFieldGet2(_transport, this)) return;
+		const transport = _classPrivateFieldGet2(_options2, this).transport ?? new WebSocketVoiceTransport({
+			agent: _classPrivateFieldGet2(_options2, this).agent,
+			name: _classPrivateFieldGet2(_options2, this).name,
+			host: _classPrivateFieldGet2(_options2, this).host,
+			query: _classPrivateFieldGet2(_options2, this).query
+		});
+		transport.onopen = () => {
+			_classPrivateFieldSet2(_connected, this, true);
+			_classPrivateFieldSet2(_error, this, null);
+			transport.sendJSON({
+				type: "hello",
+				protocol_version: 1
+			});
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "connectionchange", true);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", null);
+			if (_classPrivateFieldGet2(_inCall, this)) {
+				_classPrivateFieldSet2(_serverCallAcknowledged, this, false);
+				transport.sendJSON({ type: "start_call" });
+			}
+		};
+		transport.onclose = (info) => {
+			_classPrivateFieldGet2(_diagnostics, this).emit("connection.closed", {
+				...info?.code === void 0 ? {} : { code: info.code },
+				clean: info?.wasClean ?? false
+			});
+			_classPrivateFieldSet2(_connected, this, false);
+			_assertClassBrand(_VoiceClient_brand, this, _clearInterimTranscript).call(this);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "connectionchange", false);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "connectiondiagnostic", {
+				type: "close",
+				...info
+			});
+		};
+		transport.onerror = (cause) => {
+			_classPrivateFieldGet2(_diagnostics, this).emit("connection.error", { error: toVoiceError(cause, "Connection failed") });
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "connectiondiagnostic", {
+				type: "error",
+				cause
+			});
+			_classPrivateFieldSet2(_error, this, "Connection lost. Reconnecting...");
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", _classPrivateFieldGet2(_error, this));
+		};
+		transport.onmessage = (data) => {
+			if (typeof data === "string") _assertClassBrand(_VoiceClient_brand, this, _handleJSONMessage).call(this, data);
+			else if (data instanceof Blob) data.arrayBuffer().then((buffer) => {
+				_assertClassBrand(_VoiceClient_brand, this, _recordAudioReceived).call(this, buffer.byteLength);
+				_classPrivateFieldGet2(_playbackQueue, this).push(buffer);
+				_assertClassBrand(_VoiceClient_brand, this, _processPlaybackQueue).call(this);
+			});
+			else if (data instanceof ArrayBuffer) {
+				_assertClassBrand(_VoiceClient_brand, this, _recordAudioReceived).call(this, data.byteLength);
+				_classPrivateFieldGet2(_playbackQueue, this).push(data);
+				_assertClassBrand(_VoiceClient_brand, this, _processPlaybackQueue).call(this);
+			}
+		};
+		_classPrivateFieldSet2(_transport, this, transport);
+		transport.connect();
+	}
+	disconnect() {
+		this.endCall();
+		_classPrivateFieldGet2(_diagnostics, this).emit("connection.disconnecting");
+		_classPrivateFieldGet2(_transport, this)?.disconnect();
+		_classPrivateFieldSet2(_transport, this, null);
+		_classPrivateFieldSet2(_connected, this, false);
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "connectionchange", false);
+	}
+	async startCall() {
+		var _this$callGeneration;
+		if (!_classPrivateFieldGet2(_transport, this)?.connected) {
+			_classPrivateFieldSet2(_error, this, "Cannot start call: not connected. Call connect() first.");
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", _classPrivateFieldGet2(_error, this));
+			return;
+		}
+		if (_classPrivateFieldGet2(_inCall, this)) return;
+		_assertClassBrand(_VoiceClient_brand, this, _clearInterimTranscript).call(this);
+		const callGeneration = _classPrivateFieldSet2(_callGeneration, this, (_this$callGeneration = _classPrivateFieldGet2(_callGeneration, this), ++_this$callGeneration));
+		_classPrivateFieldSet2(_inCall, this, true);
+		_classPrivateFieldSet2(_serverCallAcknowledged, this, false);
+		_classPrivateFieldSet2(_error, this, null);
+		_classPrivateFieldSet2(_metrics, this, null);
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", null);
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "metricschange", null);
+		const startMsg = { type: "start_call" };
+		if (_classPrivateFieldGet2(_options2, this).preferredFormat) startMsg.preferred_format = _classPrivateFieldGet2(_options2, this).preferredFormat;
+		_classPrivateFieldGet2(_diagnostics, this).emit("call.starting");
+		_classPrivateFieldGet2(_transport, this).sendJSON(startMsg);
+		const ctx = await _assertClassBrand(_VoiceClient_brand, this, _getAudioContext).call(this);
+		if (_assertClassBrand(_VoiceClient_brand, this, _abortStaleCallStartup).call(this, callGeneration)) return;
+		await _assertClassBrand(_VoiceClient_brand, this, _getPlaybackDestination).call(this, ctx);
+		if (_assertClassBrand(_VoiceClient_brand, this, _abortStaleCallStartup).call(this, callGeneration)) return;
+		if (_classPrivateFieldGet2(_options2, this).audioInput) {
+			_classPrivateFieldGet2(_diagnostics, this).emit("microphone.starting", { source: "custom" });
+			_classPrivateFieldGet2(_options2, this).audioInput.onAudioLevel = (rms) => _assertClassBrand(_VoiceClient_brand, this, _processAudioLevel).call(this, rms);
+			_classPrivateFieldGet2(_options2, this).audioInput.onAudioData = (pcm) => {
+				if (_classPrivateFieldGet2(_transport, this)?.connected && !_classPrivateFieldGet2(_isMuted, this)) _classPrivateFieldGet2(_transport, this).sendBinary(pcm);
+			};
+			await _classPrivateFieldGet2(_options2, this).audioInput.start();
+			_classPrivateFieldGet2(_diagnostics, this).emit("microphone.ready", { source: "custom" });
+		} else await _assertClassBrand(_VoiceClient_brand, this, _startMic).call(this);
+		if (!_assertClassBrand(_VoiceClient_brand, this, _abortStaleCallStartup).call(this, callGeneration)) _classPrivateFieldGet2(_diagnostics, this).emit("call.local_ready");
+	}
+	endCall() {
+		var _this$callGeneration2;
+		const wasInCall = _classPrivateFieldGet2(_inCall, this);
+		_classPrivateFieldSet2(_callGeneration, this, (_this$callGeneration2 = _classPrivateFieldGet2(_callGeneration, this), _this$callGeneration2++, _this$callGeneration2));
+		_classPrivateFieldSet2(_inCall, this, false);
+		_classPrivateFieldSet2(_serverCallAcknowledged, this, false);
+		if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({ type: "end_call" });
+		_assertClassBrand(_VoiceClient_brand, this, _stopLocalCall).call(this);
+		_assertClassBrand(_VoiceClient_brand, this, _clearInterimTranscript).call(this);
+		_classPrivateFieldSet2(_status, this, "idle");
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "statuschange", "idle");
+		if (wasInCall) _classPrivateFieldGet2(_diagnostics, this).emit("call.ended", { reason: "requested" });
+	}
+	toggleMute() {
+		_classPrivateFieldSet2(_isMuted, this, !_classPrivateFieldGet2(_isMuted, this));
+		if (_classPrivateFieldGet2(_isMuted, this)) {
+			_classPrivateFieldSet2(_audioLevel, this, 0);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "audiolevelchange", 0);
+		}
+		if (_classPrivateFieldGet2(_isMuted, this) && _classPrivateFieldGet2(_isSpeaking, this)) {
+			_classPrivateFieldSet2(_isSpeaking, this, false);
+			if (_classPrivateFieldGet2(_silenceTimer, this)) {
+				clearTimeout(_classPrivateFieldGet2(_silenceTimer, this));
+				_classPrivateFieldSet2(_silenceTimer, this, null);
+			}
+			if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({ type: "end_of_speech" });
+		}
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "mutechange", _classPrivateFieldGet2(_isMuted, this));
+	}
+	/**
+	* Send a text message to the agent. The agent processes it through
+	* `onTurn()` (bypassing STT) and responds with text transcript and
+	* TTS audio (if in a call) or text-only (if not).
+	*/
+	sendText(text) {
+		if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({
+			type: "text_message",
+			text
+		});
+	}
+	/**
+	* Send arbitrary JSON to the agent. Use this for app-level messages
+	* that are not part of the voice protocol (e.g. `{ type: "kick_speaker" }`).
+	* The server receives these in the consumer's `onMessage()` handler.
+	*/
+	sendJSON(data) {
+		if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON(data);
+	}
+	/**
+	* Set the preferred audio output device for assistant playback.
+	* Unsupported browsers continue playing through the default output.
+	*/
+	async setOutputDevice(outputDeviceId) {
+		var _this$outputDeviceSwi;
+		_classPrivateFieldSet2(_outputDeviceId, this, outputDeviceId ?? "default");
+		const generation = _classPrivateFieldSet2(_outputDeviceSwitchGeneration, this, (_this$outputDeviceSwi = _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this), ++_this$outputDeviceSwi));
+		if (_classPrivateFieldGet2(_playbackElement, this)) await _assertClassBrand(_VoiceClient_brand, this, _applyOutputDevice).call(this, _classPrivateFieldGet2(_playbackElement, this), generation);
+	}
+	/**
+	* The last custom (non-voice-protocol) message received from the server.
+	* Listen for the `"custommessage"` event to be notified when this changes.
+	*/
+	get lastCustomMessage() {
+		return _classPrivateFieldGet2(_lastCustomMessage, this);
+	}
+	/**
+	* The audio format the server declared for binary payloads.
+	* Set when the server sends `audio_config` at call start.
+	*/
+	get audioFormat() {
+		return _classPrivateFieldGet2(_audioFormat, this);
+	}
+	/**
+	* The sample rate (Hz) the server declared for raw pcm16 payloads.
+	* Set when the server sends `audio_config` at call start. Defaults to 16000.
+	*/
+	get sampleRate() {
+		return _classPrivateFieldGet2(_sampleRate, this);
+	}
+};
+function _emit(event, data) {
+	const set = _classPrivateFieldGet2(_listeners, this).get(event);
+	if (set) for (const listener of set) listener(data);
+}
+function _trimTranscript() {
+	if (_classPrivateFieldGet2(_transcript, this).length > _classPrivateFieldGet2(_maxTranscriptMessages, this)) _classPrivateFieldSet2(_transcript, this, _classPrivateFieldGet2(_transcript, this).slice(-_classPrivateFieldGet2(_maxTranscriptMessages, this)));
+}
+function _setOutputDeviceError(error) {
+	if (_classPrivateFieldGet2(_outputDeviceError, this) === error) return;
+	_classPrivateFieldSet2(_outputDeviceError, this, error);
+	_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "outputdeviceerror", error);
+}
+function _clearInterimTranscript() {
+	_classPrivateFieldSet2(_interimTranscript, this, null);
+	_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "interimtranscript", null);
+}
+function _isCurrentCallStartup(callGeneration) {
+	return _classPrivateFieldGet2(_inCall, this) && _classPrivateFieldGet2(_callGeneration, this) === callGeneration;
+}
+function _abortStaleCallStartup(callGeneration) {
+	if (_assertClassBrand(_VoiceClient_brand, this, _isCurrentCallStartup).call(this, callGeneration)) return false;
+	if (!_classPrivateFieldGet2(_inCall, this)) _assertClassBrand(_VoiceClient_brand, this, _stopLocalCall).call(this);
+	return true;
+}
+function _stopLocalCall() {
+	if (_classPrivateFieldGet2(_options2, this).audioInput) {
+		_classPrivateFieldGet2(_options2, this).audioInput.stop();
+		_classPrivateFieldGet2(_options2, this).audioInput.onAudioLevel = null;
+		_classPrivateFieldGet2(_options2, this).audioInput.onAudioData = null;
+	} else _assertClassBrand(_VoiceClient_brand, this, _stopMic).call(this);
+	_assertClassBrand(_VoiceClient_brand, this, _stopPlayback).call(this);
+	_assertClassBrand(_VoiceClient_brand, this, _closeAudioContext).call(this);
+	_assertClassBrand(_VoiceClient_brand, this, _resetDetection).call(this);
+}
+function _recordAudioReceived(bytes) {
+	if (_classPrivateFieldGet2(_audioReceivedForCurrentTurn, this)) return;
+	_classPrivateFieldSet2(_audioReceivedForCurrentTurn, this, true);
+	_classPrivateFieldGet2(_diagnostics, this).emit("audio.received", {
+		bytes,
+		..._classPrivateFieldGet2(_diagnosticTurnId, this) === null ? {} : { turn_id: _classPrivateFieldGet2(_diagnosticTurnId, this) }
+	});
+}
+function _handleJSONMessage(data) {
+	let msg;
+	try {
+		msg = JSON.parse(data);
+	} catch {
+		return;
+	}
+	switch (msg.type) {
+		case "welcome": {
+			const diagnosticsEnabled = (typeof msg.diagnostics === "object" && msg.diagnostics !== null ? msg.diagnostics : null)?.browser_console === true;
+			_classPrivateFieldGet2(_diagnostics, this).setEnabled(diagnosticsEnabled);
+			if (diagnosticsEnabled) _classPrivateFieldGet2(_diagnostics, this).emit("connection.ready", { protocol_version: msg.protocol_version });
+			_classPrivateFieldSet2(_serverProtocolVersion, this, msg.protocol_version);
+			if (msg.protocol_version !== 1) console.warn(`[VoiceClient] Protocol version mismatch: client=1, server=${msg.protocol_version}`);
+			break;
+		}
+		case "diagnostic":
+			if (typeof msg.event === "string" && typeof msg.timestamp === "number" && Number.isFinite(msg.timestamp)) {
+				const data = typeof msg.data === "object" && msg.data !== null ? msg.data : void 0;
+				if (msg.event === "audio.first_sent" && typeof data?.turn_id === "string") {
+					_classPrivateFieldSet2(_diagnosticTurnId, this, data.turn_id);
+					_classPrivateFieldSet2(_audioReceivedForCurrentTurn, this, false);
+				}
+				_classPrivateFieldGet2(_diagnostics, this).receive({
+					event: msg.event,
+					timestamp: msg.timestamp,
+					...data === void 0 ? {} : { data }
+				});
+			}
+			break;
+		case "audio_config":
+			_classPrivateFieldSet2(_serverCallAcknowledged, this, true);
+			_classPrivateFieldSet2(_audioFormat, this, msg.format);
+			_classPrivateFieldSet2(_sampleRate, this, typeof msg.sampleRate === "number" && msg.sampleRate > 0 ? msg.sampleRate : 16e3);
+			break;
+		case "status":
+			_classPrivateFieldSet2(_status, this, msg.status);
+			if (msg.status === "thinking" || msg.status === "speaking") {
+				_classPrivateFieldSet2(_audioReceivedForCurrentTurn, this, false);
+				if (msg.status === "thinking") _classPrivateFieldSet2(_diagnosticTurnId, this, null);
+			}
+			if (msg.status === "idle" && _classPrivateFieldGet2(_inCall, this)) {
+				var _this$callGeneration4;
+				if (!(_classPrivateFieldGet2(_serverCallAcknowledged, this) || _classPrivateFieldGet2(_error, this) !== null)) {
+					_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "statuschange", _classPrivateFieldGet2(_status, this));
+					break;
+				}
+				_classPrivateFieldSet2(_callGeneration, this, (_this$callGeneration4 = _classPrivateFieldGet2(_callGeneration, this), _this$callGeneration4++, _this$callGeneration4));
+				_classPrivateFieldSet2(_inCall, this, false);
+				_classPrivateFieldSet2(_serverCallAcknowledged, this, false);
+				_assertClassBrand(_VoiceClient_brand, this, _stopLocalCall).call(this);
+				_assertClassBrand(_VoiceClient_brand, this, _clearInterimTranscript).call(this);
+			}
+			if (msg.status === "listening") {
+				_classPrivateFieldSet2(_serverCallAcknowledged, this, true);
+				_classPrivateFieldSet2(_error, this, null);
+				_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", null);
+			} else if (msg.status === "thinking" || msg.status === "speaking") _classPrivateFieldSet2(_serverCallAcknowledged, this, true);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "statuschange", _classPrivateFieldGet2(_status, this));
+			break;
+		case "transcript_interim":
+			_classPrivateFieldSet2(_interimTranscript, this, msg.text);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "interimtranscript", _classPrivateFieldGet2(_interimTranscript, this));
+			break;
+		case "playback_interrupt":
+			_assertClassBrand(_VoiceClient_brand, this, _stopPlayback).call(this, "server_interrupt");
+			break;
+		case "transcript":
+			_classPrivateFieldSet2(_interimTranscript, this, null);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "interimtranscript", null);
+			if (msg.role === "user" && _classPrivateFieldGet2(_isPlaying, this)) _assertClassBrand(_VoiceClient_brand, this, _stopPlayback).call(this, "user_utterance");
+			_classPrivateFieldSet2(_transcript, this, [..._classPrivateFieldGet2(_transcript, this), {
+				role: msg.role,
+				text: msg.text,
+				timestamp: Date.now()
+			}]);
+			_assertClassBrand(_VoiceClient_brand, this, _trimTranscript).call(this);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "transcriptchange", _classPrivateFieldGet2(_transcript, this));
+			break;
+		case "transcript_start":
+			_classPrivateFieldSet2(_transcript, this, [..._classPrivateFieldGet2(_transcript, this), {
+				role: "assistant",
+				text: "",
+				timestamp: Date.now()
+			}]);
+			_assertClassBrand(_VoiceClient_brand, this, _trimTranscript).call(this);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "transcriptchange", _classPrivateFieldGet2(_transcript, this));
+			break;
+		case "transcript_delta": {
+			if (_classPrivateFieldGet2(_transcript, this).length === 0) break;
+			const updated = [..._classPrivateFieldGet2(_transcript, this)];
+			const last = updated[updated.length - 1];
+			if (last.role === "assistant") {
+				updated[updated.length - 1] = {
+					...last,
+					text: last.text + msg.text
+				};
+				_classPrivateFieldSet2(_transcript, this, updated);
+				_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "transcriptchange", _classPrivateFieldGet2(_transcript, this));
+			}
+			break;
+		}
+		case "transcript_end": {
+			if (_classPrivateFieldGet2(_transcript, this).length === 0) break;
+			const updated = [..._classPrivateFieldGet2(_transcript, this)];
+			const last = updated[updated.length - 1];
+			if (last.role === "assistant") {
+				updated[updated.length - 1] = {
+					...last,
+					text: msg.text
+				};
+				_classPrivateFieldSet2(_transcript, this, updated);
+				_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "transcriptchange", _classPrivateFieldGet2(_transcript, this));
+			}
+			break;
+		}
+		case "metrics":
+			_classPrivateFieldSet2(_metrics, this, {
+				llm_ms: msg.llm_ms,
+				tts_ms: msg.tts_ms,
+				first_audio_ms: msg.first_audio_ms,
+				total_ms: msg.total_ms
+			});
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "metricschange", _classPrivateFieldGet2(_metrics, this));
+			break;
+		case "turn_metrics": {
+			const { type: _type, ...payload } = msg;
+			const metrics = payload;
+			_classPrivateFieldSet2(_turnMetrics, this, metrics);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "turnmetrics", metrics);
+			break;
+		}
+		case "completion_outcome": {
+			const outcome = {
+				code: msg.code,
+				stage: "llm",
+				...msg.finishReason !== void 0 ? { finishReason: msg.finishReason } : {},
+				partialOutput: msg.partialOutput
+			};
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "completionoutcome", outcome);
+			break;
+		}
+		case "error": {
+			const voiceError = {
+				message: msg.message,
+				...msg.code !== void 0 ? { code: msg.code } : {},
+				...msg.stage !== void 0 ? { stage: msg.stage } : {},
+				...msg.retryable !== void 0 ? { retryable: msg.retryable } : {}
+			};
+			_classPrivateFieldSet2(_error, this, voiceError.message);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "voiceerror", voiceError);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", _classPrivateFieldGet2(_error, this));
+			break;
+		}
+		default:
+			_classPrivateFieldSet2(_lastCustomMessage, this, msg);
+			_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "custommessage", msg);
+			break;
+	}
+}
+/** Get or create the shared AudioContext. */
+async function _getAudioContext() {
+	if (!_classPrivateFieldGet2(_audioContext, this)) _classPrivateFieldSet2(_audioContext, this, new AudioContext({ sampleRate: 48e3 }));
+	if (_classPrivateFieldGet2(_audioContext, this).state === "suspended") await _classPrivateFieldGet2(_audioContext, this).resume();
+	return _classPrivateFieldGet2(_audioContext, this);
+}
+/** Close the AudioContext and release resources. */
+function _closeAudioContext() {
+	if (_classPrivateFieldGet2(_audioContext, this)) {
+		_assertClassBrand(_VoiceClient_brand, this, _closePlaybackOutput).call(this);
+		_classPrivateFieldGet2(_audioContext, this).close().catch(() => {});
+		_classPrivateFieldSet2(_audioContext, this, null);
+		_classPrivateFieldSet2(_workletRegistered, this, false);
+	}
+}
+async function _getPlaybackDestination(ctx) {
+	if (_classPrivateFieldGet2(_playbackDestinationPromise, this)) return _classPrivateFieldGet2(_playbackDestinationPromise, this);
+	if (_classPrivateFieldGet2(_playbackDestination, this)) return _classPrivateFieldGet2(_playbackDestination, this);
+	if (_classPrivateFieldGet2(_useDefaultPlaybackDestination, this)) return ctx.destination;
+	const outputGeneration = _classPrivateFieldGet2(_playbackOutputGeneration, this);
+	const promise = _assertClassBrand(_VoiceClient_brand, this, _initializePlaybackDestination).call(this, ctx, outputGeneration);
+	_classPrivateFieldSet2(_playbackDestinationPromise, this, promise);
+	try {
+		return await promise;
+	} finally {
+		if (_classPrivateFieldGet2(_playbackDestinationPromise, this) === promise) _classPrivateFieldSet2(_playbackDestinationPromise, this, null);
+	}
+}
+async function _initializePlaybackDestination(ctx, outputGeneration) {
+	try {
+		const destination = ctx.createMediaStreamDestination();
+		const audio = new Audio();
+		audio.autoplay = true;
+		audio.srcObject = destination.stream;
+		_classPrivateFieldSet2(_playbackElement, this, audio);
+		_classPrivateFieldSet2(_playbackDestination, this, destination);
+		await _assertClassBrand(_VoiceClient_brand, this, _applyOutputDevice).call(this, audio, _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this));
+		if (!_assertClassBrand(_VoiceClient_brand, this, _isCurrentPlaybackOutput).call(this, audio, outputGeneration)) {
+			_assertClassBrand(_VoiceClient_brand, this, _releasePlaybackElement).call(this, audio);
+			return ctx.destination;
+		}
+		await audio.play();
+		if (!_assertClassBrand(_VoiceClient_brand, this, _isCurrentPlaybackOutput).call(this, audio, outputGeneration)) {
+			_assertClassBrand(_VoiceClient_brand, this, _releasePlaybackElement).call(this, audio);
+			return ctx.destination;
+		}
+		return destination;
+	} catch (err) {
+		console.warn("[VoiceClient] HTMLAudioElement playback output unavailable; using default AudioContext destination.", err);
+		_assertClassBrand(_VoiceClient_brand, this, _closePlaybackOutput).call(this);
+		_classPrivateFieldSet2(_useDefaultPlaybackDestination, this, true);
+		return ctx.destination;
+	}
+}
+function _isCurrentPlaybackOutput(audio, outputGeneration) {
+	return _classPrivateFieldGet2(_playbackElement, this) === audio && _classPrivateFieldGet2(_playbackOutputGeneration, this) === outputGeneration;
+}
+async function _applyOutputDevice(audio, generation) {
+	const sinkId = _classPrivateFieldGet2(_outputDeviceId, this);
+	const setSinkId = audio.setSinkId;
+	if (!setSinkId) {
+		if (sinkId === "default") {
+			_assertClassBrand(_VoiceClient_brand, this, _setOutputDeviceError).call(this, null);
+			return;
+		}
+		_assertClassBrand(_VoiceClient_brand, this, _setOutputDeviceError).call(this, UNSUPPORTED_OUTPUT_DEVICE_ERROR);
+		return;
+	}
+	try {
+		await setSinkId.call(audio, sinkId);
+		if (generation !== _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this) || sinkId !== _classPrivateFieldGet2(_outputDeviceId, this)) {
+			if (_classPrivateFieldGet2(_playbackElement, this) === audio) await _assertClassBrand(_VoiceClient_brand, this, _applyOutputDevice).call(this, audio, _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this));
+			return;
+		}
+		if (_classPrivateFieldGet2(_outputDeviceError, this) === UNSUPPORTED_OUTPUT_DEVICE_ERROR || _classPrivateFieldGet2(_outputDeviceError, this) === OUTPUT_DEVICE_SWITCH_ERROR) _assertClassBrand(_VoiceClient_brand, this, _setOutputDeviceError).call(this, null);
+	} catch {
+		if (generation !== _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this) || sinkId !== _classPrivateFieldGet2(_outputDeviceId, this)) {
+			if (_classPrivateFieldGet2(_playbackElement, this) === audio) await _assertClassBrand(_VoiceClient_brand, this, _applyOutputDevice).call(this, audio, _classPrivateFieldGet2(_outputDeviceSwitchGeneration, this));
+			return;
+		}
+		_assertClassBrand(_VoiceClient_brand, this, _setOutputDeviceError).call(this, OUTPUT_DEVICE_SWITCH_ERROR);
+	}
+}
+function _closePlaybackOutput() {
+	var _this$playbackOutputG;
+	_classPrivateFieldSet2(_playbackOutputGeneration, this, (_this$playbackOutputG = _classPrivateFieldGet2(_playbackOutputGeneration, this), _this$playbackOutputG++, _this$playbackOutputG));
+	if (_classPrivateFieldGet2(_playbackElement, this)) {
+		_assertClassBrand(_VoiceClient_brand, this, _releasePlaybackElement).call(this, _classPrivateFieldGet2(_playbackElement, this));
+		_classPrivateFieldSet2(_playbackElement, this, null);
+	}
+	_classPrivateFieldSet2(_playbackDestination, this, null);
+	_classPrivateFieldSet2(_playbackDestinationPromise, this, null);
+	_classPrivateFieldSet2(_useDefaultPlaybackDestination, this, false);
+}
+function _releasePlaybackElement(audio) {
+	audio.pause();
+	audio.srcObject = null;
+}
+async function _playAudio(audioData, generation) {
+	try {
+		const ctx = await _assertClassBrand(_VoiceClient_brand, this, _getAudioContext).call(this);
+		let audioBuffer;
+		if (_classPrivateFieldGet2(_audioFormat, this) === "pcm16") {
+			const int16 = new Int16Array(audioData);
+			audioBuffer = ctx.createBuffer(1, int16.length, _classPrivateFieldGet2(_sampleRate, this));
+			const channel = audioBuffer.getChannelData(0);
+			for (let i = 0; i < int16.length; i++) channel[i] = int16[i] / 32768;
+		} else audioBuffer = await ctx.decodeAudioData(audioData.slice(0));
+		if (generation !== _classPrivateFieldGet2(_playbackGeneration, this)) return;
+		if (_classPrivateFieldGet2(_playbackElement, this) && _classPrivateFieldGet2(_scheduledSources, this).size === 0 && _classPrivateFieldGet2(_lastPlaybackEnd, this) !== null && ctx.currentTime - _classPrivateFieldGet2(_lastPlaybackEnd, this) > .3) _assertClassBrand(_VoiceClient_brand, this, _closePlaybackOutput).call(this);
+		const destination = await _assertClassBrand(_VoiceClient_brand, this, _getPlaybackDestination).call(this, ctx);
+		if (generation !== _classPrivateFieldGet2(_playbackGeneration, this)) return;
+		const source = ctx.createBufferSource();
+		source.buffer = audioBuffer;
+		source.connect(destination);
+		_classPrivateFieldGet2(_scheduledSources, this).add(source);
+		source.onended = () => {
+			_classPrivateFieldGet2(_scheduledSources, this).delete(source);
+			if (generation === _classPrivateFieldGet2(_playbackGeneration, this) && !_classPrivateFieldGet2(_isScheduling, this) && _classPrivateFieldGet2(_scheduledSources, this).size === 0 && _classPrivateFieldGet2(_playbackQueue, this).length === 0) {
+				_classPrivateFieldSet2(_isPlaying, this, false);
+				_classPrivateFieldGet2(_diagnostics, this).emit("playback.completed");
+			}
+		};
+		const startAt = Math.max(ctx.currentTime, _classPrivateFieldGet2(_playbackCursor, this));
+		_classPrivateFieldSet2(_playbackCursor, this, startAt + audioBuffer.duration);
+		_classPrivateFieldSet2(_lastPlaybackEnd, this, _classPrivateFieldGet2(_playbackCursor, this));
+		source.start(startAt);
+	} catch (err) {
+		_classPrivateFieldGet2(_diagnostics, this).emit("playback.error", { error: toVoiceError(err, "Playback failed") });
+		console.error("[VoiceClient] Audio playback error:", err);
+	}
+}
+async function _processPlaybackQueue() {
+	if (_classPrivateFieldGet2(_isScheduling, this) || _classPrivateFieldGet2(_playbackQueue, this).length === 0) return;
+	_classPrivateFieldSet2(_isScheduling, this, true);
+	_classPrivateFieldSet2(_isPlaying, this, true);
+	_classPrivateFieldGet2(_diagnostics, this).emit("playback.started", { chunks: _classPrivateFieldGet2(_playbackQueue, this).length });
+	const generation = _classPrivateFieldGet2(_playbackGeneration, this);
+	while (generation === _classPrivateFieldGet2(_playbackGeneration, this) && _classPrivateFieldGet2(_playbackQueue, this).length > 0) {
+		const audioData = _classPrivateFieldGet2(_playbackQueue, this).shift();
+		await _assertClassBrand(_VoiceClient_brand, this, _playAudio).call(this, audioData, generation);
+	}
+	if (generation === _classPrivateFieldGet2(_playbackGeneration, this)) {
+		_classPrivateFieldSet2(_isScheduling, this, false);
+		if (_classPrivateFieldGet2(_scheduledSources, this).size === 0) _classPrivateFieldSet2(_isPlaying, this, false);
+	}
+}
+function _stopPlayback(reason = "stopped") {
+	var _this$playbackGenerat;
+	const wasActive = _classPrivateFieldGet2(_isPlaying, this) || _classPrivateFieldGet2(_isScheduling, this) || _classPrivateFieldGet2(_playbackQueue, this).length > 0 || _classPrivateFieldGet2(_scheduledSources, this).size > 0;
+	_classPrivateFieldSet2(_playbackGeneration, this, (_this$playbackGenerat = _classPrivateFieldGet2(_playbackGeneration, this), _this$playbackGenerat++, _this$playbackGenerat));
+	const sources = [..._classPrivateFieldGet2(_scheduledSources, this)];
+	_classPrivateFieldGet2(_scheduledSources, this).clear();
+	for (const source of sources) try {
+		source.stop();
+	} catch {}
+	_classPrivateFieldSet2(_playbackQueue, this, []);
+	_classPrivateFieldSet2(_isPlaying, this, false);
+	_classPrivateFieldSet2(_isScheduling, this, false);
+	_classPrivateFieldSet2(_playbackCursor, this, 0);
+	_classPrivateFieldSet2(_lastPlaybackEnd, this, _classPrivateFieldGet2(_audioContext, this) ? _classPrivateFieldGet2(_audioContext, this).currentTime : null);
+	if (wasActive) _classPrivateFieldGet2(_diagnostics, this).emit("playback.stopped", { reason });
+}
+async function _startMic() {
+	_classPrivateFieldGet2(_diagnostics, this).emit("microphone.starting", { source: "browser" });
+	try {
+		const stream = await navigator.mediaDevices.getUserMedia({ audio: {
+			sampleRate: { ideal: 48e3 },
+			channelCount: 1,
+			echoCancellation: true,
+			noiseSuppression: true,
+			autoGainControl: true
+		} });
+		_classPrivateFieldSet2(_stream, this, stream);
+		const ctx = await _assertClassBrand(_VoiceClient_brand, this, _getAudioContext).call(this);
+		if (!_classPrivateFieldGet2(_workletRegistered, this)) {
+			const blob = new Blob([WORKLET_PROCESSOR], { type: "application/javascript" });
+			const workletUrl = URL.createObjectURL(blob);
+			await ctx.audioWorklet.addModule(workletUrl);
+			URL.revokeObjectURL(workletUrl);
+			_classPrivateFieldSet2(_workletRegistered, this, true);
+		}
+		const source = ctx.createMediaStreamSource(stream);
+		const workletNode = new AudioWorkletNode(ctx, "audio-capture-processor");
+		_classPrivateFieldSet2(_workletNode, this, workletNode);
+		workletNode.port.onmessage = (event) => {
+			if (event.data.type === "audio" && !_classPrivateFieldGet2(_isMuted, this)) {
+				const samples = event.data.samples;
+				const rms = computeRMS(samples);
+				const pcm = floatTo16BitPCM(samples);
+				if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendBinary(pcm);
+				_assertClassBrand(_VoiceClient_brand, this, _processAudioLevel).call(this, rms);
+			}
+		};
+		source.connect(workletNode);
+		workletNode.connect(ctx.destination);
+		_classPrivateFieldGet2(_diagnostics, this).emit("microphone.ready", { source: "browser" });
+	} catch (err) {
+		_classPrivateFieldGet2(_diagnostics, this).emit("microphone.error", { error: toVoiceError(err, "Microphone failed") });
+		console.error("[VoiceClient] Mic error:", err);
+		_classPrivateFieldSet2(_error, this, "Microphone access denied. Please allow microphone access and try again.");
+		_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "error", _classPrivateFieldGet2(_error, this));
+	}
+}
+function _stopMic() {
+	const wasActive = _classPrivateFieldGet2(_workletNode, this) !== null || _classPrivateFieldGet2(_stream, this) !== null;
+	_classPrivateFieldGet2(_workletNode, this)?.disconnect();
+	_classPrivateFieldSet2(_workletNode, this, null);
+	_classPrivateFieldGet2(_stream, this)?.getTracks().forEach((track) => track.stop());
+	_classPrivateFieldSet2(_stream, this, null);
+	if (wasActive) _classPrivateFieldGet2(_diagnostics, this).emit("microphone.stopped");
+	_assertClassBrand(_VoiceClient_brand, this, _resetDetection).call(this);
+}
+function _processAudioLevel(rms) {
+	if (_classPrivateFieldGet2(_isMuted, this)) return;
+	_classPrivateFieldSet2(_audioLevel, this, rms);
+	_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "audiolevelchange", rms);
+	if (_classPrivateFieldGet2(_isPlaying, this) && rms > _classPrivateFieldGet2(_interruptThreshold, this)) {
+		var _this$interruptChunkC;
+		_classPrivateFieldSet2(_interruptChunkCount, this, (_this$interruptChunkC = _classPrivateFieldGet2(_interruptChunkCount, this), _this$interruptChunkC++, _this$interruptChunkC));
+		if (_classPrivateFieldGet2(_interruptChunkCount, this) >= _classPrivateFieldGet2(_interruptChunks, this)) {
+			_classPrivateFieldGet2(_diagnostics, this).emit("speech.interrupt_detected");
+			_assertClassBrand(_VoiceClient_brand, this, _stopPlayback).call(this, "speech_interrupt");
+			_classPrivateFieldSet2(_interruptChunkCount, this, 0);
+			if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({ type: "interrupt" });
+		}
+	} else _classPrivateFieldSet2(_interruptChunkCount, this, 0);
+	if (rms > _classPrivateFieldGet2(_silenceThreshold, this)) {
+		if (!_classPrivateFieldGet2(_isSpeaking, this)) {
+			_classPrivateFieldSet2(_isSpeaking, this, true);
+			_classPrivateFieldGet2(_diagnostics, this).emit("speech.started");
+			if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({ type: "start_of_speech" });
+		}
+		if (_classPrivateFieldGet2(_silenceTimer, this)) {
+			clearTimeout(_classPrivateFieldGet2(_silenceTimer, this));
+			_classPrivateFieldSet2(_silenceTimer, this, null);
+		}
+	} else if (_classPrivateFieldGet2(_isSpeaking, this)) {
+		if (!_classPrivateFieldGet2(_silenceTimer, this)) _classPrivateFieldSet2(_silenceTimer, this, setTimeout(() => {
+			_classPrivateFieldSet2(_isSpeaking, this, false);
+			_classPrivateFieldSet2(_silenceTimer, this, null);
+			_classPrivateFieldGet2(_diagnostics, this).emit("speech.ended");
+			if (_classPrivateFieldGet2(_transport, this)?.connected) _classPrivateFieldGet2(_transport, this).sendJSON({ type: "end_of_speech" });
+		}, _classPrivateFieldGet2(_silenceDurationMs, this)));
+	}
+}
+function _resetDetection() {
+	if (_classPrivateFieldGet2(_silenceTimer, this)) {
+		clearTimeout(_classPrivateFieldGet2(_silenceTimer, this));
+		_classPrivateFieldSet2(_silenceTimer, this, null);
+	}
+	_classPrivateFieldSet2(_isSpeaking, this, false);
+	_classPrivateFieldSet2(_interruptChunkCount, this, 0);
+	_classPrivateFieldSet2(_audioLevel, this, 0);
+	_assertClassBrand(_VoiceClient_brand, this, _emit).call(this, "audiolevelchange", 0);
+}
+//#endregion
+export { VOICE_PROTOCOL_VERSION, VoiceClient, WebSocketVoiceTransport };
+
+//# sourceMappingURL=client.js.map