feat: Kokoro-js TTS support

src/lib/workers/KokoroWorker.ts

@@ -0,0 +1,70 @@
+import WorkerInstance from '$lib/workers/kokoro.worker?worker';
+
+export class KokoroWorker {
+	private worker: Worker | null = null;
+	private initialized: boolean = false;
+	private dtype: string;
+
+	constructor(dtype: string = 'fp32') {
+		this.dtype = dtype;
+	}
+
+	public async init() {
+		if (this.worker) {
+			console.warn('KokoroWorker is already initialized.');
+			return;
+		}
+
+		this.worker = new WorkerInstance();
+
+		return new Promise<void>((resolve, reject) => {
+			this.worker!.onmessage = (event) => {
+				const { status, error } = event.data;
+
+				if (status === 'init:complete') {
+					this.initialized = true;
+					resolve();
+				} else if (status === 'init:error') {
+					console.error(error);
+					this.initialized = false;
+					reject(new Error(error));
+				}
+			};
+
+			this.worker!.postMessage({
+				type: 'init',
+				payload: { dtype: this.dtype }
+			});
+		});
+	}
+
+	public async generate({ text, voice }: { text: string; voice: string }): Promise<string> {
+		if (!this.initialized || !this.worker) {
+			throw new Error('KokoroTTS Worker is not initialized yet.');
+		}
+
+		return new Promise<string>((resolve, reject) => {
+			this.worker.postMessage({ type: 'generate', payload: { text, voice } });
+
+			const handleMessage = (event: MessageEvent) => {
+				if (event.data.status === 'generate:complete') {
+					this.worker!.removeEventListener('message', handleMessage);
+					resolve(event.data.audioUrl);
+				} else if (event.data.status === 'generate:error') {
+					this.worker!.removeEventListener('message', handleMessage);
+					reject(new Error(event.data.error));
+				}
+			};
+
+			this.worker.addEventListener('message', handleMessage);
+		});
+	}
+
+	public terminate() {
+		if (this.worker) {
+			this.worker.terminate();
+			this.worker = null;
+			this.initialized = false;
+		}
+	}
+}

src/lib/workers/kokoro.worker.ts

@@ -0,0 +1,53 @@
+import { KokoroTTS } from 'kokoro-js';
+
+let tts;
+let isInitialized = false; // Flag to track initialization status
+const DEFAULT_MODEL_ID = 'onnx-community/Kokoro-82M-v1.0-ONNX'; // Default model
+
+self.onmessage = async (event) => {
+	const { type, payload } = event.data;
+
+	if (type === 'init') {
+		let { model_id, dtype } = payload;
+		model_id = model_id || DEFAULT_MODEL_ID; // Use default model if none provided
+
+		self.postMessage({ status: 'init:start' });
+
+		try {
+			tts = await KokoroTTS.from_pretrained(model_id, {
+				dtype,
+				device: !!navigator?.gpu ? 'webgpu' : 'wasm' // Detect WebGPU
+			});
+			isInitialized = true; // Mark as initialized after successful loading
+			self.postMessage({ status: 'init:complete' });
+		} catch (error) {
+			isInitialized = false; // Ensure it's marked as false on failure
+			self.postMessage({ status: 'init:error', error: error.message });
+		}
+	}
+
+	if (type === 'generate') {
+		if (!isInitialized || !tts) {
+			// Ensure model is initialized
+			self.postMessage({ status: 'generate:error', error: 'TTS model not initialized' });
+			return;
+		}
+
+		const { text, voice } = payload;
+		self.postMessage({ status: 'generate:start' });
+
+		try {
+			const rawAudio = await tts.generate(text, { voice });
+			const blob = await rawAudio.toBlob();
+			const blobUrl = URL.createObjectURL(blob);
+			self.postMessage({ status: 'generate:complete', audioUrl: blobUrl });
+		} catch (error) {
+			self.postMessage({ status: 'generate:error', error: error.message });
+		}
+	}
+
+	if (type === 'status') {
+		// Respond with the current initialization status
+		self.postMessage({ status: 'status:check', initialized: isInitialized });
+	}
+};