@voiceinput/elevenlabs 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hirad Arshadiyarahmadi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# `@voiceinput/elevenlabs`
+
+ElevenLabs Realtime Scribe adapter for VoiceInput. The root export runs in the
+browser; `@voiceinput/elevenlabs/server` mints single-use tokens with a
+long-lived API key.
+
+## Install
+
+```bash
+npm install @voiceinput/react@next @voiceinput/elevenlabs@next
+```
+
+## Browser adapter
+
+```ts
+import { elevenlabs } from "@voiceinput/elevenlabs";
+
+const provider = elevenlabs({
+  tokenEndpoint: "/api/voice-token",
+  vadThreshold: 0.35,
+  filterBackgroundAudio: true,
+});
+```
+
+### Defaults and shared-option mapping
+
+- Model: `scribe_v2_realtime` (`ELEVENLABS_DEFAULT_MODEL`)
+- Audio: mono PCM16 at 16 kHz
+- Omitted language: provider automatic detection
+- `language`: normalized to an ISO 639-1 or ISO 639-3 primary code
+- `vocabulary`: ElevenLabs key terms
+- `endpointing`: VAD with a 650 ms silence threshold when omitted, manual commit
+  when `false`, or VAD with a supplied 300–3000 ms silence threshold
+
+Vocabulary accepts at most 50 trimmed terms, each at most 20 characters and
+without line breaks. Invalid or unsupported settings fail before microphone
+permission with distinct error codes.
+
+### `ElevenLabsVoiceInputProviderOptions`
+
+| Option                              | Purpose                                                       |
+| ----------------------------------- | ------------------------------------------------------------- |
+| `tokenEndpoint`                     | Required same-origin endpoint that returns a single-use token |
+| `model`                             | Model ID; default `scribe_v2_realtime`                        |
+| `finishTimeoutMs`                   | Graceful final-commit deadline; default 4 seconds             |
+| `vadThreshold`                      | VAD threshold from 0.1 to 0.9                                 |
+| `minSpeechDurationMs`               | Integer from 50 to 2000                                       |
+| `minSilenceDurationMs`              | Integer from 50 to 2000                                       |
+| `noVerbatim`                        | Provider no-verbatim behavior                                 |
+| `filterBackgroundAudio`             | Provider background-audio filtering                           |
+| `fetch`, `webSocket`, `realtimeUrl` | Transport/endpoint overrides                                  |
+
+Provider-only VAD settings customize the VAD behavior used by the portable 650
+ms default.
+
+## Server token handler
+
+```ts
+import { createElevenLabsTokenHandler } from "@voiceinput/elevenlabs/server";
+
+export const POST = createElevenLabsTokenHandler({
+  apiKey: process.env.ELEVENLABS_API_KEY!,
+  authorize: async (request) => {
+    const user = await authenticate(request);
+    return user ? { subject: user.id } : null;
+  },
+});
+```
+
+The handler accepts only `POST`, requires authorization, sets
+`Cache-Control: no-store`, and returns a single-use token rather than the
+long-lived API key. Requests must be JSON and are limited to 16 KiB.
+Authorization and rate-limit callbacks receive independent request bodies. If
+`onTokenIssued` throws, token delivery fails closed.
+
+### `CreateElevenLabsTokenHandlerOptions`
+
+| Option                    | Purpose                                                  |
+| ------------------------- | -------------------------------------------------------- |
+| `apiKey`                  | Required server-only ElevenLabs key                      |
+| `authorize(request)`      | Required application authorization                       |
+| `model`                   | Default model; default `scribe_v2_realtime`              |
+| `allowedModels`           | Browser-selectable models; defaults to only `model`      |
+| `rateLimit(context)`      | Optional application quota check                         |
+| `onTokenIssued(metadata)` | Metadata-only callback with provider, subject, and model |
+| `fetch`, `tokenUrl`       | Transport/endpoint overrides                             |
+
+`ElevenLabsTokenHandlerContext` contains `request`, `subject`, and `model`.
+
+## Public API
+
+Browser root:
+
+- `elevenlabs(options)`
+- `ELEVENLABS_DEFAULT_MODEL`
+- `ElevenLabsVoiceInputProviderOptions`
+
+Server-only entry point:
+
+- `createElevenLabsTokenHandler(options)`
+- `CreateElevenLabsTokenHandlerOptions`
+- `ElevenLabsAuthorization`
+- `ElevenLabsRateLimitResult`
+- `ElevenLabsTokenHandlerContext`
+- `ElevenLabsTokenIssuedMetadata`
+
+## Security
+
+Import `/server` only from server code; the export is disabled under the browser
+condition. Never expose `ELEVENLABS_API_KEY` to the client. The browser uses the
+single-use token to stream audio directly to ElevenLabs.
+
+See the
+[secure integration guides](https://github.com/VoiceInput/voiceinput/blob/main/docs/nextjs.md).

package/dist/index.cjs

@@ -0,0 +1,527 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_session_config = require("./session-config-D2GQf8TE.cjs");
+let _voiceinput_provider_transport = require("@voiceinput/provider/transport");
+let _voiceinput_provider = require("@voiceinput/provider");
+//#region src/index.ts
+const DEFAULT_REALTIME_URL = "wss://api.elevenlabs.io/v1/speech-to-text/realtime";
+const DEFAULT_FINISH_TIMEOUT_MS = 4e3;
+const FINISH_DRAIN_MS = 250;
+function elevenlabs(options) {
+	const model = factoryString(options.model ?? "scribe_v2_realtime", "model");
+	const tokenEndpoint = factoryString(String(options.tokenEndpoint), "tokenEndpoint");
+	const realtimeUrl = factoryString(options.realtimeUrl ?? DEFAULT_REALTIME_URL, "realtimeUrl");
+	const finishTimeoutMs = positiveInteger(options.finishTimeoutMs ?? DEFAULT_FINISH_TIMEOUT_MS, "finishTimeoutMs");
+	const providerSettings = {
+		...options.vadThreshold === void 0 ? {} : { vadThreshold: options.vadThreshold },
+		...options.minSpeechDurationMs === void 0 ? {} : { minSpeechDurationMs: options.minSpeechDurationMs },
+		...options.minSilenceDurationMs === void 0 ? {} : { minSilenceDurationMs: options.minSilenceDurationMs },
+		...options.noVerbatim === void 0 ? {} : { noVerbatim: options.noVerbatim },
+		...options.filterBackgroundAudio === void 0 ? {} : { filterBackgroundAudio: options.filterBackgroundAudio }
+	};
+	const validateProviderOptions = (transcriptionOptions) => {
+		try {
+			require_session_config.validateElevenLabsConfiguration({
+				model,
+				...providerSettings,
+				...transcriptionOptions
+			});
+		} catch (cause) {
+			if (_voiceinput_provider.VoiceInputError.isInstance(cause)) throw cause;
+			throw invalidConfiguration(cause);
+		}
+	};
+	validateProviderOptions({});
+	return Object.freeze({
+		specificationVersion: "v1",
+		provider: "elevenlabs",
+		modelId: model,
+		sampleRate: require_session_config.ELEVENLABS_SAMPLE_RATE,
+		validateOptions: validateProviderOptions,
+		async doOpen(callOptions) {
+			validateProviderOptions(callOptions);
+			const configuration = require_session_config.validateElevenLabsConfiguration({
+				model,
+				...providerSettings,
+				...callOptions
+			});
+			return await openSession({
+				abortSignal: callOptions.abortSignal,
+				configuration,
+				fetchImplementation: options.fetch ?? globalThis.fetch,
+				finishTimeoutMs,
+				realtimeUrl,
+				tokenEndpoint,
+				WebSocketImplementation: options.webSocket ?? globalThis.WebSocket
+			});
+		}
+	});
+}
+async function openSession(options) {
+	throwIfAborted(options.abortSignal);
+	requireBrowserFunction(options.fetchImplementation, "fetch");
+	requireBrowserFunction(options.WebSocketImplementation, "WebSocket");
+	const token = await requestToken(options.fetchImplementation, options.tokenEndpoint, options.configuration.model, options.abortSignal);
+	throwIfAborted(options.abortSignal);
+	return await createSession(new options.WebSocketImplementation(require_session_config.createElevenLabsRealtimeUrl(options.realtimeUrl, token, options.configuration)), options.abortSignal, options.finishTimeoutMs);
+}
+async function requestToken(fetchImplementation, tokenEndpoint, model, abortSignal) {
+	let response;
+	try {
+		response = await fetchImplementation(tokenEndpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ model }),
+			credentials: "same-origin",
+			signal: abortSignal
+		});
+	} catch (cause) {
+		throwIfAborted(abortSignal);
+		throw new _voiceinput_provider.VoiceInputError({
+			code: "network-error",
+			message: "Unable to reach the ElevenLabs token endpoint.",
+			provider: "elevenlabs",
+			retryable: true,
+			cause
+		});
+	}
+	if (!response.ok) throw await tokenResponseError(response);
+	let value;
+	try {
+		value = await response.json();
+	} catch (cause) {
+		throw new _voiceinput_provider.VoiceInputError({
+			code: "token-error",
+			message: "The ElevenLabs token endpoint returned invalid JSON.",
+			provider: "elevenlabs",
+			cause
+		});
+	}
+	if (!isRecord(value) || !nonEmpty(value["token"])) throw new _voiceinput_provider.VoiceInputError({
+		code: "token-error",
+		message: "The ElevenLabs token endpoint returned an invalid token.",
+		provider: "elevenlabs"
+	});
+	return value["token"];
+}
+async function createSession(socket, abortSignal, finishTimeoutMs) {
+	let controller;
+	const stream = new ReadableStream({ start(value) {
+		controller = value;
+	} });
+	if (controller === void 0) throw new _voiceinput_provider.VoiceInputError({
+		code: "provider-error",
+		message: "Unable to initialize the ElevenLabs transcript stream.",
+		provider: "elevenlabs"
+	});
+	let hasAudio = false;
+	let closed = false;
+	let failed = false;
+	let finishing = false;
+	let finishDeferred;
+	let finishSettled = false;
+	let finishTimer;
+	let finishDrainTimer;
+	let lastInterim = "";
+	let segmentSequence = 0;
+	const segmentId = () => `commit:${segmentSequence}`;
+	let speechActive = false;
+	const closeSocket = (reason) => {
+		if (socket.readyState === 0 || socket.readyState === 1) socket.close(1e3, reason);
+	};
+	const closeStream = () => {
+		if (closed) return;
+		closed = true;
+		abortSignal.removeEventListener("abort", abort);
+		controller?.close();
+	};
+	const settleFinish = (error) => {
+		if (finishDeferred === void 0 || finishSettled) return;
+		finishSettled = true;
+		if (finishTimer !== void 0) {
+			clearTimeout(finishTimer);
+			finishTimer = void 0;
+		}
+		if (finishDrainTimer !== void 0) {
+			clearTimeout(finishDrainTimer);
+			finishDrainTimer = void 0;
+		}
+		if (error === void 0) finishDeferred.resolve(void 0);
+		else finishDeferred.reject(error);
+	};
+	const finishCleanly = () => {
+		if (lastInterim.length > 0) {
+			lastInterim = "";
+			controller?.enqueue({
+				type: "interim",
+				text: "",
+				segmentId: segmentId()
+			});
+		}
+		endSpeech();
+		settleFinish();
+		closeStream();
+		closeSocket("finished");
+	};
+	const scheduleFinishDrain = () => {
+		if (!finishing || finishSettled) return;
+		if (finishDrainTimer !== void 0) clearTimeout(finishDrainTimer);
+		finishDrainTimer = setTimeout(finishCleanly, FINISH_DRAIN_MS);
+	};
+	const fail = (error) => {
+		if (closed || failed) return;
+		failed = true;
+		settleFinish(error);
+		controller?.enqueue({
+			type: "error",
+			error
+		});
+		closeStream();
+		closeSocket("aborted");
+	};
+	const startSpeech = () => {
+		if (!speechActive) {
+			speechActive = true;
+			controller?.enqueue({ type: "speech-start" });
+		}
+	};
+	const endSpeech = () => {
+		if (speechActive) {
+			speechActive = false;
+			controller?.enqueue({ type: "speech-end" });
+		}
+	};
+	const emitInterim = (text) => {
+		if (text.length === 0 || text === lastInterim) return;
+		startSpeech();
+		lastInterim = text;
+		controller?.enqueue({
+			type: "interim",
+			text,
+			segmentId: segmentId()
+		});
+	};
+	const commitTranscript = (text) => {
+		if (text.length > 0) startSpeech();
+		controller?.enqueue({
+			type: "final",
+			text,
+			segmentId: segmentId()
+		});
+		segmentSequence += 1;
+		lastInterim = "";
+		if (!finishing) endSpeech();
+	};
+	const handleMessage = (event) => {
+		if (closed) return;
+		try {
+			const value = JSON.parse(String(event.data));
+			if (!isRecord(value) || !nonEmpty(value["message_type"])) throw new TypeError("ElevenLabs sent an invalid Realtime event.");
+			const type = value["message_type"];
+			if (type === "partial_transcript") {
+				emitInterim(readText(value));
+				if (finishDrainTimer !== void 0) scheduleFinishDrain();
+			} else if (type === "final_transcript") {
+				if (finishDrainTimer !== void 0) scheduleFinishDrain();
+			} else if (type === "committed_transcript") {
+				commitTranscript(readText(value));
+				if (finishing) scheduleFinishDrain();
+			} else if (elevenLabsErrorTypes.has(type)) fail(normalizeRealtimeError(value));
+		} catch (cause) {
+			fail(new _voiceinput_provider.VoiceInputError({
+				code: "provider-error",
+				message: "ElevenLabs sent an invalid Realtime event.",
+				provider: "elevenlabs",
+				cause
+			}));
+		}
+	};
+	const handleClose = (event) => {
+		if (closed) return;
+		if (event.code === 1e3) {
+			if (finishing) {
+				finishCleanly();
+				return;
+			}
+			closeStream();
+		} else fail(new _voiceinput_provider.VoiceInputError({
+			code: "network-error",
+			message: "The ElevenLabs Realtime connection closed unexpectedly.",
+			provider: "elevenlabs",
+			retryable: true,
+			cause: event
+		}));
+	};
+	function abort() {
+		if (closed) return;
+		settleFinish(abortSignal.reason ?? new _voiceinput_provider.VoiceInputError({
+			code: "provider-error",
+			message: "The ElevenLabs Realtime session was aborted.",
+			provider: "elevenlabs"
+		}));
+		closeStream();
+		closeSocket("aborted");
+	}
+	socket.addEventListener("message", handleMessage);
+	socket.addEventListener("close", handleClose);
+	socket.addEventListener("error", () => {
+		fail(new _voiceinput_provider.VoiceInputError({
+			code: "network-error",
+			message: "The ElevenLabs Realtime connection failed.",
+			provider: "elevenlabs",
+			retryable: true
+		}));
+	});
+	abortSignal.addEventListener("abort", abort, { once: true });
+	await waitForOpen(socket, abortSignal);
+	return {
+		stream,
+		sendAudio(chunk) {
+			if (closed || finishing || chunk.length === 0) return;
+			hasAudio = true;
+			return (0, _voiceinput_provider_transport.sendWithBackpressure)(socket, Math.ceil(chunk.byteLength * 4 / 3) + 160, abortSignal, "elevenlabs", () => sendJson(socket, {
+				message_type: "input_audio_chunk",
+				audio_base_64: encodePcm16(chunk),
+				commit: false,
+				sample_rate: require_session_config.ELEVENLABS_SAMPLE_RATE
+			}));
+		},
+		finish() {
+			if (finishDeferred !== void 0) return finishDeferred.promise;
+			if (closed) return;
+			finishing = true;
+			finishDeferred = createDeferred();
+			if (!hasAudio) {
+				finishCleanly();
+				return finishDeferred.promise;
+			}
+			try {
+				sendJson(socket, {
+					message_type: "input_audio_chunk",
+					audio_base_64: "",
+					commit: true,
+					sample_rate: require_session_config.ELEVENLABS_SAMPLE_RATE
+				});
+			} catch (cause) {
+				fail(_voiceinput_provider.VoiceInputError.isInstance(cause) ? cause : new _voiceinput_provider.VoiceInputError({
+					code: "network-error",
+					message: "Unable to commit the ElevenLabs transcript.",
+					provider: "elevenlabs",
+					retryable: true,
+					cause
+				}));
+				return finishDeferred.promise;
+			}
+			finishTimer = setTimeout(() => {
+				fail(new _voiceinput_provider.VoiceInputError({
+					code: "network-error",
+					message: `ElevenLabs did not commit the final transcript within ${finishTimeoutMs}ms.`,
+					provider: "elevenlabs",
+					retryable: true
+				}));
+			}, finishTimeoutMs);
+			return finishDeferred.promise;
+		},
+		abort
+	};
+}
+const elevenLabsErrorTypes = /* @__PURE__ */ new Set([
+	"auth_error",
+	"quota_exceeded",
+	"transcriber_error",
+	"input_error",
+	"invalid_request",
+	"error",
+	"commit_throttled",
+	"unaccepted_terms",
+	"rate_limited",
+	"queue_overflow",
+	"resource_exhausted",
+	"session_time_limit_exceeded",
+	"chunk_size_exceeded",
+	"insufficient_audio_activity"
+]);
+function normalizeRealtimeError(value) {
+	const type = String(value["message_type"]);
+	const rateLimited = type === "rate_limited" || type === "quota_exceeded" || type === "commit_throttled";
+	const retryable = rateLimited || type === "queue_overflow" || type === "resource_exhausted";
+	return new _voiceinput_provider.VoiceInputError({
+		code: type === "auth_error" ? "unauthorized" : rateLimited ? "rate-limited" : type === "input_error" || type === "chunk_size_exceeded" ? "audio-error" : "provider-error",
+		message: typeof value["error"] === "string" ? value["error"] : `ElevenLabs Realtime reported ${type}.`,
+		provider: "elevenlabs",
+		retryable,
+		cause: value
+	});
+}
+function invalidConfiguration(cause) {
+	return new _voiceinput_provider.VoiceInputError({
+		code: "invalid-configuration",
+		message: cause instanceof Error ? cause.message : "Invalid ElevenLabs transcription options.",
+		provider: "elevenlabs",
+		cause
+	});
+}
+function readText(value) {
+	if (typeof value["text"] !== "string") throw new TypeError("text must be a string.");
+	return value["text"];
+}
+function requireBrowserFunction(value, feature) {
+	if (typeof value !== "function") throw new _voiceinput_provider.VoiceInputError({
+		code: "unsupported-browser",
+		message: `ElevenLabs voice input requires browser ${feature} support.`,
+		provider: "elevenlabs"
+	});
+}
+function factoryString(value, name) {
+	if (value.trim().length === 0) throw invalidConfiguration(/* @__PURE__ */ new TypeError(`${name} must be non-empty.`));
+	return value;
+}
+function positiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value <= 0) throw invalidConfiguration(/* @__PURE__ */ new TypeError(`${name} must be a positive safe integer.`));
+	return value;
+}
+function createDeferred() {
+	let resolve = () => {};
+	let reject = () => {};
+	return {
+		promise: new Promise((resolve_, reject_) => {
+			resolve = resolve_;
+			reject = reject_;
+		}),
+		resolve,
+		reject
+	};
+}
+async function tokenResponseError(response) {
+	const retryAfterMs = parseRetryAfter(response.headers.get("Retry-After"));
+	if (response.status === 401 || response.status === 403) return new _voiceinput_provider.VoiceInputError({
+		code: "unauthorized",
+		message: "The ElevenLabs token endpoint rejected this request.",
+		provider: "elevenlabs"
+	});
+	if (response.status === 429) return new _voiceinput_provider.VoiceInputError({
+		code: "rate-limited",
+		message: "The ElevenLabs token endpoint rate limit was exceeded.",
+		provider: "elevenlabs",
+		retryable: true,
+		...retryAfterMs === void 0 ? {} : { retryAfterMs }
+	});
+	const safeError = await readSafeTokenError(response);
+	if (safeError !== void 0) return new _voiceinput_provider.VoiceInputError({
+		...safeError,
+		provider: "elevenlabs"
+	});
+	return new _voiceinput_provider.VoiceInputError({
+		code: "token-error",
+		message: "The ElevenLabs token endpoint did not issue a token.",
+		provider: "elevenlabs",
+		retryable: response.status >= 500
+	});
+}
+async function readSafeTokenError(response) {
+	if (response.status !== 400 || response.headers.get("X-VoiceInput-Error") !== "1" || response.headers.get("Content-Type")?.split(";", 1)[0]?.trim() !== "application/json") return;
+	const text = await readBoundedErrorText(response);
+	if (text === void 0) return void 0;
+	try {
+		const value = JSON.parse(text);
+		const error = isRecord(value) ? value["error"] : void 0;
+		if (!isRecord(error) || error["code"] !== "invalid-configuration" && error["code"] !== "unsupported-feature" || typeof error["message"] !== "string" || error["message"].length === 0 || error["message"].length > 1e3) return;
+		return {
+			code: error["code"],
+			message: error["message"]
+		};
+	} catch {
+		return;
+	}
+}
+async function readBoundedErrorText(response) {
+	const reader = response.body?.getReader();
+	if (reader === void 0) return void 0;
+	const decoder = new TextDecoder();
+	let bytesRead = 0;
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) return text + decoder.decode();
+			bytesRead += value.byteLength;
+			if (bytesRead > 4096) {
+				await reader.cancel().catch(() => {});
+				return;
+			}
+			text += decoder.decode(value, { stream: true });
+		}
+	} catch {
+		return;
+	}
+}
+function waitForOpen(socket, abortSignal) {
+	if (socket.readyState === 1) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			socket.removeEventListener("open", handleOpen);
+			socket.removeEventListener("error", handleError);
+			abortSignal.removeEventListener("abort", handleAbort);
+		};
+		const handleOpen = () => {
+			cleanup();
+			resolve();
+		};
+		const handleError = (event) => {
+			cleanup();
+			reject(new _voiceinput_provider.VoiceInputError({
+				code: "network-error",
+				message: "Unable to open the ElevenLabs Realtime connection.",
+				provider: "elevenlabs",
+				retryable: true,
+				cause: event
+			}));
+		};
+		const handleAbort = () => {
+			cleanup();
+			reject(abortSignal.reason);
+		};
+		socket.addEventListener("open", handleOpen, { once: true });
+		socket.addEventListener("error", handleError, { once: true });
+		abortSignal.addEventListener("abort", handleAbort, { once: true });
+	});
+}
+function sendJson(socket, value) {
+	try {
+		socket.send(JSON.stringify(value));
+	} catch (cause) {
+		throw new _voiceinput_provider.VoiceInputError({
+			code: "network-error",
+			message: "Unable to send data to ElevenLabs Realtime.",
+			provider: "elevenlabs",
+			retryable: true,
+			cause
+		});
+	}
+}
+function encodePcm16(chunk) {
+	const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 8192) binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+	return btoa(binary);
+}
+function parseRetryAfter(value) {
+	if (value === null) return;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.ceil(seconds * 1e3);
+	const date = Date.parse(value);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw signal.reason;
+}
+function nonEmpty(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+exports.ELEVENLABS_DEFAULT_MODEL = require_session_config.ELEVENLABS_DEFAULT_MODEL;
+exports.elevenlabs = elevenlabs;
+
+//# sourceMappingURL=index.cjs.map