@tryhamster/gerbil 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/tts-C2FzKuSx.js

@@ -0,0 +1,725 @@
+//#region src/core/tts.ts
+const SENTENCE_SPLIT_REGEX = /(?<=[.!?])\s+/;
+/**
+* Kokoro voice definitions
+* Voice IDs follow pattern: {language}{gender}_{name}
+* - a = American English
+* - b = British English
+* - f = female, m = male
+*/
+const KOKORO_VOICES = [
+	{
+		id: "af_heart",
+		name: "Heart",
+		gender: "female",
+		language: "en-us",
+		description: "American female, highest quality voice (Grade A)",
+		embeddingFile: "voices/af_heart.bin"
+	},
+	{
+		id: "af_bella",
+		name: "Bella",
+		gender: "female",
+		language: "en-us",
+		description: "American female, warm and friendly (Grade A-)",
+		embeddingFile: "voices/af_bella.bin"
+	},
+	{
+		id: "af_nicole",
+		name: "Nicole",
+		gender: "female",
+		language: "en-us",
+		description: "American female, soft and gentle (Grade B-)",
+		embeddingFile: "voices/af_nicole.bin"
+	},
+	{
+		id: "af_sarah",
+		name: "Sarah",
+		gender: "female",
+		language: "en-us",
+		description: "American female, clear and professional (Grade C+)",
+		embeddingFile: "voices/af_sarah.bin"
+	},
+	{
+		id: "af_sky",
+		name: "Sky",
+		gender: "female",
+		language: "en-us",
+		description: "American female, young and energetic (Grade C-)",
+		embeddingFile: "voices/af_sky.bin"
+	},
+	{
+		id: "af_alloy",
+		name: "Alloy",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade C)",
+		embeddingFile: "voices/af_alloy.bin"
+	},
+	{
+		id: "af_aoede",
+		name: "Aoede",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade C+)",
+		embeddingFile: "voices/af_aoede.bin"
+	},
+	{
+		id: "af_kore",
+		name: "Kore",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade C+)",
+		embeddingFile: "voices/af_kore.bin"
+	},
+	{
+		id: "af_nova",
+		name: "Nova",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade C)",
+		embeddingFile: "voices/af_nova.bin"
+	},
+	{
+		id: "af_river",
+		name: "River",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade D)",
+		embeddingFile: "voices/af_river.bin"
+	},
+	{
+		id: "af_jessica",
+		name: "Jessica",
+		gender: "female",
+		language: "en-us",
+		description: "American female (Grade D)",
+		embeddingFile: "voices/af_jessica.bin"
+	},
+	{
+		id: "am_fenrir",
+		name: "Fenrir",
+		gender: "male",
+		language: "en-us",
+		description: "American male, best quality (Grade C+)",
+		embeddingFile: "voices/am_fenrir.bin"
+	},
+	{
+		id: "am_michael",
+		name: "Michael",
+		gender: "male",
+		language: "en-us",
+		description: "American male, warm and friendly (Grade C+)",
+		embeddingFile: "voices/am_michael.bin"
+	},
+	{
+		id: "am_puck",
+		name: "Puck",
+		gender: "male",
+		language: "en-us",
+		description: "American male (Grade C+)",
+		embeddingFile: "voices/am_puck.bin"
+	},
+	{
+		id: "am_adam",
+		name: "Adam",
+		gender: "male",
+		language: "en-us",
+		description: "American male, deep voice (Grade F+)",
+		embeddingFile: "voices/am_adam.bin"
+	},
+	{
+		id: "am_echo",
+		name: "Echo",
+		gender: "male",
+		language: "en-us",
+		description: "American male (Grade D)",
+		embeddingFile: "voices/am_echo.bin"
+	},
+	{
+		id: "am_eric",
+		name: "Eric",
+		gender: "male",
+		language: "en-us",
+		description: "American male (Grade D)",
+		embeddingFile: "voices/am_eric.bin"
+	},
+	{
+		id: "am_liam",
+		name: "Liam",
+		gender: "male",
+		language: "en-us",
+		description: "American male (Grade D)",
+		embeddingFile: "voices/am_liam.bin"
+	},
+	{
+		id: "am_onyx",
+		name: "Onyx",
+		gender: "male",
+		language: "en-us",
+		description: "American male (Grade D)",
+		embeddingFile: "voices/am_onyx.bin"
+	},
+	{
+		id: "am_santa",
+		name: "Santa",
+		gender: "male",
+		language: "en-us",
+		description: "American male, festive (Grade D-)",
+		embeddingFile: "voices/am_santa.bin"
+	},
+	{
+		id: "bf_emma",
+		name: "Emma",
+		gender: "female",
+		language: "en-gb",
+		description: "British female, elegant and clear (Grade B-)",
+		embeddingFile: "voices/bf_emma.bin"
+	},
+	{
+		id: "bf_isabella",
+		name: "Isabella",
+		gender: "female",
+		language: "en-gb",
+		description: "British female, sophisticated (Grade C)",
+		embeddingFile: "voices/bf_isabella.bin"
+	},
+	{
+		id: "bf_alice",
+		name: "Alice",
+		gender: "female",
+		language: "en-gb",
+		description: "British female (Grade D)",
+		embeddingFile: "voices/bf_alice.bin"
+	},
+	{
+		id: "bf_lily",
+		name: "Lily",
+		gender: "female",
+		language: "en-gb",
+		description: "British female (Grade D)",
+		embeddingFile: "voices/bf_lily.bin"
+	},
+	{
+		id: "bm_george",
+		name: "George",
+		gender: "male",
+		language: "en-gb",
+		description: "British male, distinguished (Grade C)",
+		embeddingFile: "voices/bm_george.bin"
+	},
+	{
+		id: "bm_fable",
+		name: "Fable",
+		gender: "male",
+		language: "en-gb",
+		description: "British male (Grade C)",
+		embeddingFile: "voices/bm_fable.bin"
+	},
+	{
+		id: "bm_lewis",
+		name: "Lewis",
+		gender: "male",
+		language: "en-gb",
+		description: "British male, friendly (Grade D+)",
+		embeddingFile: "voices/bm_lewis.bin"
+	},
+	{
+		id: "bm_daniel",
+		name: "Daniel",
+		gender: "male",
+		language: "en-gb",
+		description: "British male (Grade D)",
+		embeddingFile: "voices/bm_daniel.bin"
+	}
+];
+/**
+* Supertonic voice definitions
+* 4 built-in voices: F1, F2 (female), M1, M2 (male)
+*/
+const SUPERTONIC_VOICES = [
+	{
+		id: "F1",
+		name: "Female 1",
+		gender: "female",
+		language: "en",
+		description: "Female voice 1 - Clear and natural",
+		embeddingFile: "voices/F1.bin"
+	},
+	{
+		id: "F2",
+		name: "Female 2",
+		gender: "female",
+		language: "en",
+		description: "Female voice 2 - Warm and expressive",
+		embeddingFile: "voices/F2.bin"
+	},
+	{
+		id: "M1",
+		name: "Male 1",
+		gender: "male",
+		language: "en",
+		description: "Male voice 1 - Deep and confident",
+		embeddingFile: "voices/M1.bin"
+	},
+	{
+		id: "M2",
+		name: "Male 2",
+		gender: "male",
+		language: "en",
+		description: "Male voice 2 - Friendly and casual",
+		embeddingFile: "voices/M2.bin"
+	}
+];
+const TTS_MODELS = {
+	"kokoro-82m": {
+		id: "kokoro-82m",
+		repo: "onnx-community/Kokoro-82M-v1.0-ONNX",
+		description: "Kokoro 82M - High-quality multilingual TTS",
+		size: "~330MB",
+		sampleRate: 24e3,
+		voices: KOKORO_VOICES,
+		defaultVoice: "af_heart",
+		languages: ["en-us", "en-gb"]
+	},
+	"supertonic-66m": {
+		id: "supertonic-66m",
+		repo: "onnx-community/Supertonic-TTS-ONNX",
+		description: "Supertonic 66M - Fast on-device TTS (167x realtime)",
+		size: "~250MB",
+		sampleRate: 44100,
+		voices: SUPERTONIC_VOICES,
+		defaultVoice: "F1",
+		languages: ["en"]
+	}
+};
+/**
+* Get TTS model config by ID
+*/
+function getTTSModelConfig(modelId) {
+	return TTS_MODELS[modelId] || null;
+}
+/**
+* Kokoro TTS - Local text-to-speech with voice selection
+*
+* Uses kokoro-js (official Kokoro library by xenova) for high-quality speech synthesis.
+* Includes proper G2P (grapheme-to-phoneme) conversion for accurate pronunciation.
+*/
+var KokoroTTS = class {
+	kokoroInstance = null;
+	modelConfig;
+	loadPromise = null;
+	_isLoaded = false;
+	_deviceMode = "cpu";
+	constructor(modelId = "kokoro-82m") {
+		const config = getTTSModelConfig(modelId);
+		if (!config) throw new Error(`Unknown TTS model: ${modelId}. Available: ${Object.keys(TTS_MODELS).join(", ")}`);
+		this.modelConfig = config;
+	}
+	/**
+	* Load the TTS model
+	*
+	* @example
+	* ```ts
+	* const tts = new KokoroTTS();
+	* await tts.load({
+	*   onProgress: (p) => console.log(p.status, p.progress),
+	*   device: "webgpu",
+	* });
+	* ```
+	*/
+	async load(options = {}) {
+		if (this._isLoaded) return;
+		if (this.loadPromise) return this.loadPromise;
+		this.loadPromise = this._load(options);
+		await this.loadPromise;
+	}
+	async _load(options = {}) {
+		const { onProgress, device = "auto" } = options;
+		onProgress?.({ status: `Loading TTS model (${this.modelConfig.id})...` });
+		try {
+			const { KokoroTTS: KokoroJS } = await import("./kokoro-CMOGDSgT.js");
+			const isBrowser = typeof window !== "undefined";
+			let dtype = "fp32";
+			if (device === "webgpu" || device === "auto" && isBrowser && "gpu" in navigator) {
+				dtype = "fp16";
+				this._deviceMode = "webgpu";
+			} else {
+				dtype = "fp32";
+				this._deviceMode = "cpu";
+			}
+			onProgress?.({ status: `Loading model with ${dtype} precision...` });
+			this.kokoroInstance = await KokoroJS.from_pretrained(this.modelConfig.repo, {
+				dtype,
+				progress_callback: (progress) => {
+					if (progress.status === "progress" && progress.file) onProgress?.({
+						status: `Downloading ${progress.file}`,
+						progress: Math.round(progress.progress || 0),
+						file: progress.file
+					});
+					else if (progress.status === "ready") onProgress?.({ status: "Model ready" });
+				}
+			});
+			this._isLoaded = true;
+			onProgress?.({ status: `Ready (${this._deviceMode.toUpperCase()})!` });
+		} catch (error) {
+			this.loadPromise = null;
+			throw error;
+		}
+	}
+	/**
+	* Ensure model is loaded (lazy loading)
+	*/
+	async ensureLoaded(options) {
+		if (!this._isLoaded) await this.load(options);
+	}
+	/**
+	* Get list of available voices
+	*
+	* @example
+	* ```ts
+	* const voices = tts.listVoices();
+	* // [{ id: "af_heart", name: "Heart", gender: "female", ... }, ...]
+	* ```
+	*/
+	listVoices() {
+		return [...this.modelConfig.voices];
+	}
+	/**
+	* Get a specific voice by ID
+	*/
+	getVoice(voiceId) {
+		return this.modelConfig.voices.find((v) => v.id === voiceId) || null;
+	}
+	/**
+	* Get voices by gender
+	*/
+	getVoicesByGender(gender) {
+		return this.modelConfig.voices.filter((v) => v.gender === gender);
+	}
+	/**
+	* Get voices by language
+	*/
+	getVoicesByLanguage(language) {
+		return this.modelConfig.voices.filter((v) => v.language === language || v.language.startsWith(language));
+	}
+	/**
+	* Generate speech from text
+	*
+	* @example
+	* ```ts
+	* const result = await tts.speak("Hello world", {
+	*   voice: "af_heart",
+	*   speed: 1.0,
+	* });
+	*
+	* // Play in browser
+	* const audioContext = new AudioContext();
+	* const buffer = audioContext.createBuffer(1, result.audio.length, result.sampleRate);
+	* buffer.copyToChannel(result.audio, 0);
+	* const source = audioContext.createBufferSource();
+	* source.buffer = buffer;
+	* source.connect(audioContext.destination);
+	* source.start();
+	* ```
+	*/
+	async speak(text, options = {}) {
+		await this.ensureLoaded({ onProgress: options.onProgress });
+		const { voice = this.modelConfig.defaultVoice, speed = 1 } = options;
+		if (!this.getVoice(voice)) throw new Error(`Unknown voice: ${voice}. Use listVoices() to see available options.`);
+		if (!this.kokoroInstance) throw new Error("Model not loaded");
+		const startTime = performance.now();
+		const result = await this.kokoroInstance.generate(text, {
+			voice,
+			speed
+		});
+		const totalTime = performance.now() - startTime;
+		return {
+			audio: result.audio,
+			sampleRate: result.sampling_rate,
+			duration: result.audio.length / result.sampling_rate,
+			voice,
+			totalTime
+		};
+	}
+	/**
+	* Stream speech generation (yields audio chunks as they're generated)
+	*
+	* @example
+	* ```ts
+	* for await (const chunk of tts.speakStream("Long text...")) {
+	*   // chunk.samples = Float32Array
+	*   // chunk.sampleRate = 24000
+	*   // chunk.isFinal = boolean
+	*   playChunk(chunk);
+	* }
+	* ```
+	*/
+	async *speakStream(text, options = {}) {
+		await this.ensureLoaded({ onProgress: options.onProgress });
+		const { voice = this.modelConfig.defaultVoice, speed = 1 } = options;
+		if (!this.getVoice(voice)) throw new Error(`Unknown voice: ${voice}. Use listVoices() to see available options.`);
+		if (!this.kokoroInstance) throw new Error("Model not loaded");
+		const startTime = performance.now();
+		const sentences = this.splitIntoSentences(text);
+		const allAudio = [];
+		let chunkIndex = 0;
+		let sampleRate = this.modelConfig.sampleRate;
+		for (let i = 0; i < sentences.length; i++) {
+			const sentence = sentences[i];
+			if (!sentence.trim()) continue;
+			const result = await this.kokoroInstance.generate(sentence, {
+				voice,
+				speed
+			});
+			sampleRate = result.sampling_rate;
+			allAudio.push(result.audio);
+			const chunk = {
+				samples: result.audio,
+				sampleRate: result.sampling_rate,
+				index: chunkIndex++,
+				isFinal: i === sentences.length - 1
+			};
+			yield chunk;
+			options.onAudioChunk?.(chunk);
+		}
+		const totalLength = allAudio.reduce((sum, arr) => sum + arr.length, 0);
+		const fullAudio = new Float32Array(totalLength);
+		let offset = 0;
+		for (const chunk of allAudio) {
+			fullAudio.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const totalTime = performance.now() - startTime;
+		return {
+			audio: fullAudio,
+			sampleRate,
+			duration: fullAudio.length / sampleRate,
+			voice,
+			totalTime
+		};
+	}
+	/**
+	* Split text into sentences for streaming
+	*/
+	splitIntoSentences(text) {
+		return text.split(SENTENCE_SPLIT_REGEX).filter((s) => s.trim());
+	}
+	/**
+	* Check if model is loaded
+	*/
+	isLoaded() {
+		return this._isLoaded;
+	}
+	/**
+	* Get current device mode
+	*/
+	getDeviceMode() {
+		return this._deviceMode;
+	}
+	/**
+	* Get model configuration
+	*/
+	getModelInfo() {
+		return { ...this.modelConfig };
+	}
+	/**
+	* Get sample rate
+	*/
+	getSampleRate() {
+		return this.modelConfig.sampleRate;
+	}
+	/**
+	* Dispose of resources
+	*/
+	async dispose() {
+		this.kokoroInstance = null;
+		this._isLoaded = false;
+		this.loadPromise = null;
+	}
+};
+/**
+* Supertonic TTS - Fast on-device text-to-speech
+*
+* Uses transformers.js with the Supertonic-TTS-ONNX model.
+* Generates speech at 167x realtime with 66M parameters.
+* Outputs at 44100 Hz sample rate.
+*/
+var SupertonicTTS = class {
+	pipeline = null;
+	modelConfig;
+	loadPromise = null;
+	_isLoaded = false;
+	_deviceMode = "cpu";
+	voiceEmbeddings = /* @__PURE__ */ new Map();
+	constructor(modelId = "supertonic-66m") {
+		const config = getTTSModelConfig(modelId);
+		if (!config) throw new Error(`Unknown TTS model: ${modelId}. Available: ${Object.keys(TTS_MODELS).join(", ")}`);
+		this.modelConfig = config;
+	}
+	/**
+	* Load the TTS model
+	*/
+	async load(options = {}) {
+		if (this._isLoaded) return;
+		if (this.loadPromise) return this.loadPromise;
+		this.loadPromise = this._load(options);
+		await this.loadPromise;
+	}
+	async _load(options = {}) {
+		const { onProgress, device = "auto" } = options;
+		onProgress?.({ status: `Loading TTS model (${this.modelConfig.id})...` });
+		try {
+			const isBrowser = typeof window !== "undefined";
+			const { pipeline, env } = await import("./transformers.web-u34VxRFM.js");
+			if (isBrowser && env.backends?.onnx?.wasm) env.backends.onnx.wasm.wasmPaths = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.21.0/dist/";
+			if (device === "webgpu" || device === "auto" && isBrowser && "gpu" in navigator) this._deviceMode = "webgpu";
+			else this._deviceMode = "cpu";
+			onProgress?.({ status: `Loading Supertonic model...` });
+			this.pipeline = await pipeline("text-to-speech", this.modelConfig.repo, {
+				dtype: "fp32",
+				device: this._deviceMode,
+				progress_callback: (progress) => {
+					if (progress.status === "progress" && progress.file) onProgress?.({
+						status: `Downloading ${progress.file}`,
+						progress: Math.round(progress.progress || 0),
+						file: progress.file
+					});
+				}
+			});
+			onProgress?.({ status: "Loading voice embeddings..." });
+			await this.loadVoiceEmbeddings();
+			this._isLoaded = true;
+			onProgress?.({ status: `Ready (${this._deviceMode.toUpperCase()})!` });
+		} catch (error) {
+			this.loadPromise = null;
+			throw error;
+		}
+	}
+	/**
+	* Load speaker embeddings for all voices
+	* Supertonic uses 101x128 = 12,928 floats per voice
+	*/
+	async loadVoiceEmbeddings() {}
+	async ensureLoaded(options) {
+		if (!this._isLoaded) await this.load(options);
+	}
+	listVoices() {
+		return [...this.modelConfig.voices];
+	}
+	getVoice(voiceId) {
+		return this.modelConfig.voices.find((v) => v.id === voiceId) || null;
+	}
+	getVoicesByGender(gender) {
+		return this.modelConfig.voices.filter((v) => v.gender === gender);
+	}
+	/**
+	* Generate speech from text
+	*/
+	async speak(text, options = {}) {
+		await this.ensureLoaded({ onProgress: options.onProgress });
+		const { voice = this.modelConfig.defaultVoice } = options;
+		if (!this.getVoice(voice)) throw new Error(`Unknown voice: ${voice}. Use listVoices() to see available options.`);
+		if (!this.pipeline) throw new Error("Model not loaded");
+		const startTime = performance.now();
+		let speakerEmbedding = this.voiceEmbeddings.get(voice);
+		if (!speakerEmbedding) try {
+			const voiceUrl = `https://huggingface.co/${this.modelConfig.repo}/resolve/main/voices/${voice}.bin`;
+			const response = await fetch(voiceUrl);
+			if (response.ok) {
+				const buffer = await response.arrayBuffer();
+				speakerEmbedding = new Float32Array(buffer);
+				this.voiceEmbeddings.set(voice, speakerEmbedding);
+			} else throw new Error(`Failed to load voice: ${response.status}`);
+		} catch {
+			speakerEmbedding = new Float32Array(12928).fill(.1);
+			this.voiceEmbeddings.set(voice, speakerEmbedding);
+		}
+		const result = await this.pipeline(text, { speaker_embeddings: speakerEmbedding });
+		const totalTime = performance.now() - startTime;
+		const audio = result.audio;
+		const sampleRate = result.sampling_rate;
+		return {
+			audio,
+			sampleRate,
+			duration: audio.length / sampleRate,
+			voice,
+			totalTime
+		};
+	}
+	/**
+	* Stream speech generation
+	*/
+	async *speakStream(text, options = {}) {
+		await this.ensureLoaded({ onProgress: options.onProgress });
+		const { voice = this.modelConfig.defaultVoice, speed = 1 } = options;
+		if (!this.getVoice(voice)) throw new Error(`Unknown voice: ${voice}. Use listVoices() to see available options.`);
+		const startTime = performance.now();
+		const sentences = text.split(SENTENCE_SPLIT_REGEX).filter((s) => s.trim());
+		const allAudio = [];
+		let chunkIndex = 0;
+		let sampleRate = this.modelConfig.sampleRate;
+		for (let i = 0; i < sentences.length; i++) {
+			const sentence = sentences[i];
+			if (!sentence.trim()) continue;
+			const result = await this.speak(sentence, {
+				voice,
+				speed
+			});
+			sampleRate = result.sampleRate;
+			allAudio.push(result.audio);
+			const chunk = {
+				samples: result.audio,
+				sampleRate: result.sampleRate,
+				index: chunkIndex++,
+				isFinal: i === sentences.length - 1
+			};
+			yield chunk;
+			options.onAudioChunk?.(chunk);
+		}
+		const totalLength = allAudio.reduce((sum, arr) => sum + arr.length, 0);
+		const fullAudio = new Float32Array(totalLength);
+		let offset = 0;
+		for (const chunk of allAudio) {
+			fullAudio.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const totalTime = performance.now() - startTime;
+		return {
+			audio: fullAudio,
+			sampleRate,
+			duration: fullAudio.length / sampleRate,
+			voice,
+			totalTime
+		};
+	}
+	isLoaded() {
+		return this._isLoaded;
+	}
+	getDeviceMode() {
+		return this._deviceMode;
+	}
+	getModelInfo() {
+		return { ...this.modelConfig };
+	}
+	getSampleRate() {
+		return this.modelConfig.sampleRate;
+	}
+	async dispose() {
+		this.pipeline = null;
+		this.voiceEmbeddings.clear();
+		this._isLoaded = false;
+		this.loadPromise = null;
+	}
+};
+/**
+* Create a TTS instance based on model ID
+*/
+function createTTS(modelId = "kokoro-82m") {
+	if (modelId.startsWith("supertonic")) return new SupertonicTTS(modelId);
+	return new KokoroTTS(modelId);
+}
+
+//#endregion
+export { createTTS };
+//# sourceMappingURL=tts-C2FzKuSx.js.map