@polytts/browser-adapters 0.1.0 → 0.1.1

package/dist/kokoro.worker.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/kokoro.worker.js

@@ -0,0 +1,145 @@
+//#region src/adapters/kokoro.worker.ts
+const KOKORO_ERROR_LOG_LEVEL = 40;
+const abortedRequestIds = /* @__PURE__ */ new Set();
+let tts = null;
+let currentModuleUrl;
+const DEFAULT_MODULE_KEY = "kokoro-js";
+const kokoroModuleCache = /* @__PURE__ */ new Map();
+async function loadKokoroBrowserModule(moduleUrl) {
+	const key = moduleUrl ?? DEFAULT_MODULE_KEY;
+	const cached = kokoroModuleCache.get(key);
+	if (cached) return cached;
+	const loadPromise = moduleUrl ? import(
+		/* @vite-ignore */
+		moduleUrl
+) : import("kokoro-js");
+	kokoroModuleCache.set(key, loadPromise);
+	try {
+		return await loadPromise;
+	} catch (error) {
+		kokoroModuleCache.delete(key);
+		throw error;
+	}
+}
+function ensureNotAborted(requestId) {
+	if (abortedRequestIds.has(requestId)) throw new DOMException("Aborted", "AbortError");
+}
+function configureKokoroEnvironment(env) {
+	if (!env) return;
+	if (!("caches" in globalThis) || globalThis.caches == null) {
+		env.useBrowserCache = false;
+		env.useWasmCache = false;
+	}
+	env.logLevel = Math.max(env.logLevel ?? KOKORO_ERROR_LOG_LEVEL, KOKORO_ERROR_LOG_LEVEL);
+}
+async function loadTTS(KokoroTTS, modelRef, preferredDevice, requestId) {
+	const progress_callback = (progress) => {
+		if (progress.status === "progress" && progress.loaded != null && progress.total) self.postMessage({
+			type: "progress",
+			requestId,
+			progress: progress.loaded / progress.total
+		});
+	};
+	const tryLoad = (device) => KokoroTTS.from_pretrained(modelRef, {
+		dtype: device === "webgpu" ? "fp32" : "q8",
+		device,
+		progress_callback
+	});
+	if (preferredDevice === "wasm") return {
+		tts: await tryLoad("wasm"),
+		device: "wasm"
+	};
+	try {
+		return {
+			tts: await tryLoad("webgpu"),
+			device: "webgpu"
+		};
+	} catch {
+		return {
+			tts: await tryLoad("wasm"),
+			device: "wasm"
+		};
+	}
+}
+self.onmessage = async (event) => {
+	const message = event.data;
+	if (message.type === "abort") {
+		abortedRequestIds.add(message.requestId);
+		return;
+	}
+	const { requestId } = message;
+	try {
+		switch (message.type) {
+			case "load": {
+				currentModuleUrl = message.moduleUrl;
+				const kokoroModule = await loadKokoroBrowserModule(currentModuleUrl);
+				configureKokoroEnvironment(kokoroModule.env);
+				const loaded = await loadTTS(kokoroModule.KokoroTTS, message.modelRef, message.device, requestId);
+				tts = loaded.tts;
+				ensureNotAborted(requestId);
+				const voices = Object.entries(tts.voices ?? {}).map(([id, info]) => ({
+					id,
+					name: info?.name ?? id,
+					language: info?.language ?? (id.startsWith("b") ? "en-GB" : "en-US"),
+					gender: info?.gender
+				}));
+				self.postMessage({
+					type: "done",
+					requestId,
+					voices,
+					device: loaded.device
+				});
+				break;
+			}
+			case "generate": {
+				if (!tts) throw new Error("Kokoro model not loaded");
+				ensureNotAborted(requestId);
+				const result = await tts.generate(message.text, { voice: message.voiceId });
+				ensureNotAborted(requestId);
+				const audio = result.audio;
+				const buffer = audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength);
+				self.postMessage({
+					type: "done",
+					requestId,
+					audio: buffer,
+					sampleRate: result.sampling_rate ?? 24e3
+				}, [buffer]);
+				break;
+			}
+			case "stream": {
+				if (!tts) throw new Error("Kokoro model not loaded");
+				const { TextSplitterStream } = await loadKokoroBrowserModule(currentModuleUrl);
+				const splitter = new TextSplitterStream();
+				const stream = tts.stream(splitter, { voice: message.voiceId });
+				splitter.push(message.text);
+				splitter.close();
+				for await (const { audio } of stream) {
+					ensureNotAborted(requestId);
+					const samples = audio.audio;
+					const buffer = samples.buffer.slice(samples.byteOffset, samples.byteOffset + samples.byteLength);
+					self.postMessage({
+						type: "chunk",
+						requestId,
+						audio: buffer,
+						sampleRate: audio.sampling_rate ?? 24e3
+					}, [buffer]);
+				}
+				ensureNotAborted(requestId);
+				self.postMessage({
+					type: "done",
+					requestId
+				});
+				break;
+			}
+		}
+	} catch (error) {
+		if (error.name !== "AbortError") self.postMessage({
+			type: "error",
+			requestId,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	} finally {
+		abortedRequestIds.delete(requestId);
+	}
+};
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polytts/browser-adapters",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Official browser adapter implementations for polytts.",
   "keywords": [
     "adapters",
@@ -39,7 +39,7 @@
     "kokoro-js": "latest",
     "onnxruntime-web": "latest",
     "phonemizer": "latest",
-    "@polytts/core": "0.1.0"
+    "@polytts/core": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",