@polytts/node-adapters 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DengQing dengqing0821@gmail.com
+
+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,31 @@
+# @polytts/node-adapters
+
+[![npm version](https://img.shields.io/npm/v/@polytts/node-adapters)](https://www.npmjs.com/package/@polytts/node-adapters)
+
+Official Node adapter implementations for [`polytts`](https://github.com/Dunqing/polytts).
+
+Use this package when you want Node-capable adapters without the higher-level Node controller.
+
+## Install
+
+```bash
+npm install @polytts/node-adapters
+```
+
+## Usage
+
+```ts
+import { officialNodeAdapters, piperNodeAdapter } from "@polytts/node-adapters";
+
+void officialNodeAdapters;
+void piperNodeAdapter;
+```
+
+## Included adapters
+
+- `kokoroNodeAdapter`
+- `piperNodeAdapter`
+- `kittenNodeAdapter`
+- `supertonicNodeAdapter`
+
+Catalog and model metadata live in `@polytts/presets`.

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { SynthesizingModelInstance, TTSAdapter } from "@polytts/core";
+
+//#region src/kitten.d.ts
+declare const kittenNodeAdapter: TTSAdapter<SynthesizingModelInstance>;
+//#endregion
+//#region src/supertonic.d.ts
+declare const supertonicNodeAdapter: TTSAdapter<SynthesizingModelInstance>;
+//#endregion
+//#region src/index.d.ts
+/** TTS adapter for Kokoro models on Node.js using kokoro-js. */
+declare const kokoroNodeAdapter: TTSAdapter<SynthesizingModelInstance>;
+/** TTS adapter for Piper models on Node.js using native ONNX Runtime. */
+declare const piperNodeAdapter: TTSAdapter<SynthesizingModelInstance>;
+/** All official Node.js TTS adapters bundled for convenience. */
+declare const officialNodeAdapters: TTSAdapter<SynthesizingModelInstance>[];
+//#endregion
+export { kittenNodeAdapter, kokoroNodeAdapter, officialNodeAdapters, piperNodeAdapter, supertonicNodeAdapter };

package/dist/index.mjs

@@ -0,0 +1,942 @@
+import { getModelAssets, pcmToAudioData } from "@polytts/core";
+import { inflateRawSync } from "node:zlib";
+//#region src/kitten-npz-reader.ts
+function parseNpyHeader(bytes) {
+	if (bytes[0] !== 147 || String.fromCharCode(bytes[1], bytes[2], bytes[3], bytes[4], bytes[5]) !== "NUMPY") throw new Error("Not a valid .npy file");
+	const majorVersion = bytes[6];
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const headerLength = majorVersion === 1 ? view.getUint16(8, true) : view.getUint32(8, true);
+	const headerOffset = majorVersion === 1 ? 10 : 12;
+	const header = new TextDecoder().decode(bytes.slice(headerOffset, headerOffset + headerLength));
+	const dtype = header.match(/'descr'\s*:\s*'([^']+)'/)?.[1];
+	const shape = header.match(/'shape'\s*:\s*\(([^)]*)\)/)?.[1]?.split(",").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isFinite(value)) ?? [];
+	if (!dtype) throw new Error(`Could not parse dtype from .npy header: ${header}`);
+	return {
+		dtype,
+		shape,
+		dataOffset: headerOffset + headerLength
+	};
+}
+function npyToFloat32(bytes) {
+	const { dtype, shape, dataOffset } = parseNpyHeader(bytes);
+	const raw = bytes.slice(dataOffset);
+	const aligned = new ArrayBuffer(raw.length);
+	new Uint8Array(aligned).set(raw);
+	if (dtype === "<f4" || dtype === "float32") return {
+		data: new Float32Array(aligned),
+		shape
+	};
+	if (dtype === "<f8" || dtype === "float64") {
+		const source = new Float64Array(aligned);
+		const target = new Float32Array(source.length);
+		for (let index = 0; index < source.length; index += 1) target[index] = source[index];
+		return {
+			data: target,
+			shape
+		};
+	}
+	throw new Error(`Unsupported npy dtype: ${dtype}`);
+}
+function extractZipEntries(buffer) {
+	const bytes = new Uint8Array(buffer);
+	const view = new DataView(buffer);
+	const entries = /* @__PURE__ */ new Map();
+	let eocdOffset = -1;
+	for (let index = bytes.length - 22; index >= 0; index -= 1) if (view.getUint32(index, true) === 101010256) {
+		eocdOffset = index;
+		break;
+	}
+	if (eocdOffset === -1) throw new Error("Could not find End of Central Directory");
+	const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
+	const centralDirectoryEntries = view.getUint16(eocdOffset + 10, true);
+	let offset = centralDirectoryOffset;
+	for (let index = 0; index < centralDirectoryEntries; index += 1) {
+		if (view.getUint32(offset, true) !== 33639248) break;
+		const compressionMethod = view.getUint16(offset + 10, true);
+		const compressedSize = view.getUint32(offset + 20, true);
+		const uncompressedSize = view.getUint32(offset + 24, true);
+		const fileNameLength = view.getUint16(offset + 28, true);
+		const extraLength = view.getUint16(offset + 30, true);
+		const commentLength = view.getUint16(offset + 32, true);
+		const localHeaderOffset = view.getUint32(offset + 42, true);
+		const fileName = new TextDecoder().decode(bytes.slice(offset + 46, offset + 46 + fileNameLength));
+		const localFileNameLength = view.getUint16(localHeaderOffset + 26, true);
+		const localExtraLength = view.getUint16(localHeaderOffset + 28, true);
+		const dataStart = localHeaderOffset + 30 + localFileNameLength + localExtraLength;
+		const compressed = bytes.slice(dataStart, dataStart + compressedSize);
+		let fileData;
+		if (compressionMethod === 0) fileData = compressed;
+		else if (compressionMethod === 8) fileData = inflateRawSync(compressed);
+		else {
+			offset += 46 + fileNameLength + extraLength + commentLength;
+			continue;
+		}
+		if (fileData.length !== uncompressedSize) throw new Error(`Unexpected size for archive entry "${fileName}"`);
+		entries.set(fileName, fileData);
+		offset += 46 + fileNameLength + extraLength + commentLength;
+	}
+	return entries;
+}
+function loadKittenVoicesFromArchive(archive) {
+	const entries = extractZipEntries(archive);
+	const voices = {};
+	for (const [fileName, fileData] of entries) {
+		if (!fileName.endsWith(".npy")) continue;
+		const voiceName = fileName.replace(/\.npy$/, "");
+		const { data, shape } = npyToFloat32(fileData);
+		voices[voiceName] = {
+			data,
+			shape: [shape[0] || 1, shape[1] || data.length]
+		};
+	}
+	return voices;
+}
+//#endregion
+//#region src/kitten-tokenizer.ts
+/**
+* Phoneme tokenizer for the KittenTTS ONNX model. Ported from the upstream Python TextCleaner
+* class: https://github.com/KittenML/KittenTTS/blob/main/kittentts/onnx_model.py
+*/
+const PAD = "$";
+const PUNCTUATION = ";:,.!?¡¿—…\"«»\"\" ";
+const LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const LETTERS_IPA = "ɑɐɒæɓʙβɔɕçɗɖðʤəɘɚɛɜɝɞɟʄɡɠɢʛɦɧħɥʜɨɪʝɭɬɫɮʟɱɯɰŋɳɲɴøɵɸθœɶʘɹɺɾɻʀʁɽʂʃʈʧʉʊʋⱱʌɣɤʍχʎʏʑʐʒʔʡʕʢǀǁǂǃˈˌːˑʼʴʰʱʲʷˠˤ˞↓↑→↗↘'̩'ᵻ";
+const symbols = [
+	PAD,
+	...PUNCTUATION,
+	...LETTERS,
+	...LETTERS_IPA
+];
+const charToIndex = {};
+for (let index = 0; index < symbols.length; index += 1) charToIndex[symbols[index]] = index;
+function cleanText(text) {
+	const indexes = [];
+	for (const char of text) {
+		const mapped = charToIndex[char];
+		if (mapped !== void 0) indexes.push(mapped);
+	}
+	return indexes;
+}
+function tokenizePhonemes(phonemes) {
+	const tokens = cleanText(phonemes);
+	tokens.unshift(0);
+	tokens.push(10);
+	tokens.push(0);
+	return tokens;
+}
+//#endregion
+//#region src/kitten.shared.ts
+const KITTEN_SAMPLE_RATE = 24e3;
+const HF_BASE = "https://huggingface.co";
+function resolveKittenUrl(repoId, fileName) {
+	return `${HF_BASE}/${repoId}/resolve/main/${fileName}`;
+}
+function resolveKittenModelFile(repoId, config) {
+	return repoId.startsWith("onnx-community/") ? "onnx/model.onnx" : config.model_file;
+}
+function resolveKittenVoiceId(config, voiceId) {
+	return config.voice_aliases?.[voiceId] ?? voiceId;
+}
+//#endregion
+//#region src/kitten.ts
+const KITTEN_CONFIG_ASSET_NAME = "kitten-config.json";
+const KITTEN_MODEL_ASSET_NAME = "model.onnx";
+const KITTEN_VOICES_ASSET_NAME = "voices.npz";
+function bundleFor(spec) {
+	return {
+		adapterId: spec.adapterId,
+		modelId: spec.id,
+		revision: spec.revision
+	};
+}
+function ensurePunctuation(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return trimmed;
+	return ".!?,;:".includes(trimmed[trimmed.length - 1]) ? trimmed : `${trimmed}.`;
+}
+function chunkText$1(text, maxLength = 400) {
+	const sentences = text.match(/[^.!?]*[.!?]+|[^.!?]+$/g) || [text];
+	const chunks = [];
+	for (let sentence of sentences) {
+		sentence = sentence.trim();
+		if (!sentence) continue;
+		if (sentence.length <= maxLength) {
+			chunks.push(ensurePunctuation(sentence));
+			continue;
+		}
+		const words = sentence.split(/\s+/);
+		let buffer = "";
+		for (const word of words) if (buffer.length + word.length + 1 <= maxLength) buffer += `${buffer ? " " : ""}${word}`;
+		else {
+			if (buffer) chunks.push(ensurePunctuation(buffer));
+			buffer = word;
+		}
+		if (buffer) chunks.push(ensurePunctuation(buffer));
+	}
+	return chunks;
+}
+function basicTokenize(text) {
+	return text.match(/[\p{L}\p{N}_]+|[^\p{L}\p{N}_\s]/gu) || [];
+}
+var KittenNodeModel = class {
+	kind = "synthesizing";
+	modelId;
+	adapterId;
+	session = null;
+	voices = {};
+	config = null;
+	phonemize = null;
+	constructor(spec, context) {
+		this.spec = spec;
+		this.context = context;
+		this.modelId = spec.id;
+		this.adapterId = spec.adapterId;
+	}
+	async load(signal, onProgress) {
+		const repoId = this.spec.config?.modelId ?? "onnx-community/KittenTTS-Mini-v0.8-ONNX";
+		const phonemizerModule = await import("phonemizer");
+		const ort = await import("onnxruntime-node");
+		const configBuffer = await this.loadConfigBuffer(repoId, signal);
+		this.config = JSON.parse(new TextDecoder().decode(configBuffer));
+		onProgress?.(.15);
+		const modelUrl = resolveKittenUrl(repoId, resolveKittenModelFile(repoId, this.config));
+		const voicesUrl = resolveKittenUrl(repoId, this.config.voices);
+		const [modelBuffer, voicesArchive] = await Promise.all([this.loadNamedAsset(KITTEN_MODEL_ASSET_NAME, modelUrl, signal), this.loadNamedAsset(KITTEN_VOICES_ASSET_NAME, voicesUrl, signal)]);
+		onProgress?.(.65);
+		this.voices = loadKittenVoicesFromArchive(voicesArchive);
+		this.session = await ort.InferenceSession.create(new Uint8Array(modelBuffer));
+		this.phonemize = phonemizerModule.phonemize;
+		onProgress?.(1);
+	}
+	async loadConfigBuffer(repoId, signal) {
+		const cached = await this.context.assetStore.getAsset(bundleFor(this.spec), KITTEN_CONFIG_ASSET_NAME);
+		if (cached) return cached;
+		const configResponse = await this.context.fetch(resolveKittenUrl(repoId, "kitten_config.json"), { signal });
+		if (configResponse.ok) return configResponse.arrayBuffer();
+		const fallback = await this.context.fetch(resolveKittenUrl(repoId, "config.json"), { signal });
+		if (!fallback.ok) throw new Error(`Failed to fetch Kitten config: HTTP ${fallback.status}`);
+		return fallback.arrayBuffer();
+	}
+	async generate(text, voiceId, signal, speed) {
+		if (!this.session || !this.config || !this.phonemize) throw new Error("Kitten model not loaded");
+		const chunks = chunkText$1(text);
+		const outputs = [];
+		for (const chunk of chunks) outputs.push(await this.generateChunk(chunk, voiceId, speed ?? 1, signal));
+		const totalLength = outputs.reduce((sum, chunk) => sum + chunk.length, 0);
+		const combined = new Float32Array(totalLength);
+		let offset = 0;
+		for (const chunk of outputs) {
+			combined.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return pcmToAudioData(combined, KITTEN_SAMPLE_RATE);
+	}
+	async *stream(text, voiceId, signal, speed) {
+		if (!this.session || !this.config || !this.phonemize) throw new Error("Kitten model not loaded");
+		const chunks = chunkText$1(text);
+		for (const chunk of chunks) {
+			if (signal.aborted) throw this.context.createAbortError();
+			yield pcmToAudioData(await this.generateChunk(chunk, voiceId, speed ?? 1, signal), KITTEN_SAMPLE_RATE);
+		}
+	}
+	listVoices() {
+		return this.spec.voices ?? [];
+	}
+	dispose() {
+		this.session = null;
+		this.voices = {};
+		this.config = null;
+		this.phonemize = null;
+	}
+	async generateChunk(text, voiceKey, speed, signal) {
+		if (!this.session || !this.config || !this.phonemize) throw new Error("Kitten model not loaded");
+		const resolvedVoiceId = resolveKittenVoiceId(this.config, voiceKey);
+		const voiceData = this.voices[resolvedVoiceId];
+		if (!voiceData) throw new Error(`Voice "${voiceKey}" not found`);
+		if (this.config.speed_priors?.[resolvedVoiceId]) speed *= this.config.speed_priors[resolvedVoiceId];
+		const phonemes = await this.phonemizeText(text, signal);
+		if (signal.aborted) throw this.context.createAbortError();
+		const inputIds = tokenizePhonemes(phonemes);
+		const referenceIndex = Math.min(text.length, voiceData.shape[0] - 1);
+		const styleDimension = voiceData.shape[1];
+		const referenceStyle = voiceData.data.slice(referenceIndex * styleDimension, (referenceIndex + 1) * styleDimension);
+		const ort = await import("onnxruntime-node");
+		const inputs = {
+			input_ids: new ort.Tensor("int64", BigInt64Array.from(inputIds.map(BigInt)), [1, inputIds.length]),
+			style: new ort.Tensor("float32", referenceStyle, [1, styleDimension]),
+			speed: new ort.Tensor("float32", new Float32Array([speed]), [1])
+		};
+		const audio = (await this.session.run(inputs))[this.session.outputNames[0]]?.data;
+		if (audio.length > 24e3) return audio.slice(0, audio.length - 5e3);
+		return audio;
+	}
+	async phonemizeText(text, signal) {
+		if (!this.phonemize) throw new Error("Kitten phonemizer not loaded");
+		const punctuation = /(\s*[;:,.!?¡¿—…"«»""()[\]{}]+\s*)+/g;
+		const sections = [];
+		let lastIndex = 0;
+		for (const match of text.matchAll(punctuation)) {
+			if (lastIndex < match.index) sections.push({
+				punctuation: false,
+				text: text.slice(lastIndex, match.index)
+			});
+			sections.push({
+				punctuation: true,
+				text: match[0]
+			});
+			lastIndex = match.index + match[0].length;
+		}
+		if (lastIndex < text.length) sections.push({
+			punctuation: false,
+			text: text.slice(lastIndex)
+		});
+		return basicTokenize((await Promise.all(sections.map(async (section) => {
+			if (section.punctuation) return section.text;
+			const result = await this.phonemize(section.text, "en-us");
+			if (signal.aborted) throw this.context.createAbortError();
+			return result.join(" ");
+		}))).join("")).join(" ");
+	}
+	async fetchArrayBuffer(url, signal) {
+		const response = await this.context.fetch(url, { signal });
+		if (!response.ok) throw new Error(`Failed to fetch Kitten asset: HTTP ${response.status}`);
+		return response.arrayBuffer();
+	}
+	async loadNamedAsset(assetName, url, signal) {
+		const cached = await this.context.assetStore.getAsset(bundleFor(this.spec), assetName);
+		if (cached) return cached;
+		return this.fetchArrayBuffer(url, signal);
+	}
+};
+const kittenNodeAdapter = {
+	id: "kitten-node",
+	name: "KittenTTS Node",
+	capabilities: {
+		install: true,
+		speak: false,
+		synthesize: true,
+		stream: true,
+		dynamicVoices: false
+	},
+	async install(spec, context, signal, onProgress) {
+		const repoId = spec.config?.modelId ?? "onnx-community/KittenTTS-Mini-v0.8-ONNX";
+		const bundle = bundleFor(spec);
+		const configBuffer = await (async () => {
+			const primary = await context.fetch(resolveKittenUrl(repoId, "kitten_config.json"), { signal });
+			if (primary.ok) return primary.arrayBuffer();
+			const fallback = await context.fetch(resolveKittenUrl(repoId, "config.json"), { signal });
+			if (!fallback.ok) throw new Error(`Failed to fetch Kitten config: HTTP ${fallback.status}`);
+			return fallback.arrayBuffer();
+		})();
+		await context.assetStore.stageAsset(bundle, KITTEN_CONFIG_ASSET_NAME, configBuffer);
+		onProgress?.(.15);
+		const config = JSON.parse(new TextDecoder().decode(configBuffer));
+		const modelUrl = resolveKittenUrl(repoId, resolveKittenModelFile(repoId, config));
+		const voicesUrl = resolveKittenUrl(repoId, config.voices);
+		const modelBuffer = await context.fetch(modelUrl, { signal }).then(async (response) => {
+			if (!response.ok) throw new Error(`Failed to fetch Kitten model: HTTP ${response.status}`);
+			return response.arrayBuffer();
+		});
+		await context.assetStore.stageAsset(bundle, KITTEN_MODEL_ASSET_NAME, modelBuffer);
+		onProgress?.(.8);
+		const voicesBuffer = await context.fetch(voicesUrl, { signal }).then(async (response) => {
+			if (!response.ok) throw new Error(`Failed to fetch Kitten voices: HTTP ${response.status}`);
+			return response.arrayBuffer();
+		});
+		await context.assetStore.stageAsset(bundle, KITTEN_VOICES_ASSET_NAME, voicesBuffer);
+		await context.assetStore.activateBundle(bundle, [
+			KITTEN_CONFIG_ASSET_NAME,
+			KITTEN_MODEL_ASSET_NAME,
+			KITTEN_VOICES_ASSET_NAME
+		]);
+		onProgress?.(1);
+	},
+	createModel(spec, context) {
+		return new KittenNodeModel(spec, context);
+	}
+};
+//#endregion
+//#region src/supertonic.runtime.ts
+const SUPERTONIC_MODEL_SESSION_KEYS = [
+	"durationPredictor",
+	"textEncoder",
+	"vectorEstimator",
+	"vocoder"
+];
+function gaussianRandom() {
+	const u1 = Math.max(1e-4, Math.random());
+	const u2 = Math.random();
+	return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function flatten3d(data) {
+	return new Float32Array(data.flat(2));
+}
+function isValidLanguage(value) {
+	return value === "en" || value === "ko" || value === "es" || value === "pt" || value === "fr";
+}
+function createDefaultAbortError() {
+	const error = /* @__PURE__ */ new Error("Aborted");
+	error.name = "AbortError";
+	return error;
+}
+var SupertonicStyle = class {
+	constructor(ttl, dp) {
+		this.ttl = ttl;
+		this.dp = dp;
+	}
+};
+var SupertonicUnicodeProcessor = class {
+	constructor(indexer) {
+		this.indexer = indexer;
+	}
+	call(textList, langList) {
+		const processedTexts = textList.map((text, index) => this.preprocessText(text, langList[index]));
+		const lengths = processedTexts.map((text) => text.length);
+		const maxLength = Math.max(...lengths);
+		return {
+			textIds: processedTexts.map((text) => {
+				const row = Array.from({ length: maxLength }, () => 0);
+				for (let index = 0; index < text.length; index += 1) {
+					const codePoint = text.codePointAt(index);
+					row[index] = codePoint != null && codePoint < this.indexer.length ? this.indexer[codePoint] : -1;
+				}
+				return row;
+			}),
+			textMask: this.lengthToMask(lengths, maxLength)
+		};
+	}
+	preprocessText(text, lang) {
+		let normalized = text.normalize("NFKD");
+		normalized = normalized.replace(/[\u{1F600}-\u{1F64F}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{1F700}-\u{1F77F}\u{1F780}-\u{1F7FF}\u{1F800}-\u{1F8FF}\u{1F900}-\u{1F9FF}\u{1FA00}-\u{1FA6F}\u{1FA70}-\u{1FAFF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}\u{1F1E6}-\u{1F1FF}]+/gu, "");
+		for (const [from, to] of Object.entries({
+			"–": "-",
+			"‑": "-",
+			"—": "-",
+			_: " ",
+			"“": "\"",
+			"”": "\"",
+			"‘": "'",
+			"’": "'",
+			"´": "'",
+			"`": "'",
+			"[": " ",
+			"]": " ",
+			"|": " ",
+			"/": " ",
+			"#": " ",
+			"→": " ",
+			"←": " "
+		})) normalized = normalized.replaceAll(from, to);
+		normalized = normalized.replace(/[♥☆♡©\\]/g, "");
+		for (const [from, to] of Object.entries({
+			"@": " at ",
+			"e.g.,": "for example, ",
+			"i.e.,": "that is, "
+		})) normalized = normalized.replaceAll(from, to);
+		normalized = normalized.replace(/ ,/g, ",").replace(/ \./g, ".").replace(/ !/g, "!").replace(/ \?/g, "?").replace(/ ;/g, ";").replace(/ :/g, ":").replace(/ '/g, "'");
+		while (normalized.includes("\"\"")) normalized = normalized.replace("\"\"", "\"");
+		while (normalized.includes("''")) normalized = normalized.replace("''", "'");
+		while (normalized.includes("``")) normalized = normalized.replace("``", "`");
+		normalized = normalized.replace(/\s+/g, " ").trim();
+		if (!/[.!?;:,'"')\]}…。」』】〉》›»]$/.test(normalized)) normalized += ".";
+		if (!isValidLanguage(lang)) throw new Error(`Invalid Supertonic language: ${lang}`);
+		return `<${lang}>${normalized}</${lang}>`;
+	}
+	lengthToMask(lengths, maxLength) {
+		return lengths.map((length) => {
+			const row = Array.from({ length: maxLength }, () => 0);
+			for (let index = 0; index < Math.min(length, maxLength); index += 1) row[index] = 1;
+			return [row];
+		});
+	}
+};
+function createSupertonicStyle(ortModule, json) {
+	const ttlDims = json.style_ttl.dims;
+	const dpDims = json.style_dp.dims;
+	return new SupertonicStyle(new ortModule.Tensor("float32", flatten3d(json.style_ttl.data), ttlDims), new ortModule.Tensor("float32", flatten3d(json.style_dp.data), dpDims));
+}
+async function loadSupertonicSessions(ortModule, modelBuffers, onProgress) {
+	const sessions = {};
+	for (let index = 0; index < SUPERTONIC_MODEL_SESSION_KEYS.length; index += 1) {
+		const key = SUPERTONIC_MODEL_SESSION_KEYS[index];
+		sessions[key] = await ortModule.InferenceSession.create(new Uint8Array(modelBuffers[key]));
+		onProgress?.(index + 1, SUPERTONIC_MODEL_SESSION_KEYS.length);
+	}
+	return sessions;
+}
+var SupertonicTextToSpeech = class {
+	sampleRate;
+	constructor(ortModule, config, textProcessor, sessions) {
+		this.ortModule = ortModule;
+		this.config = config;
+		this.textProcessor = textProcessor;
+		this.sessions = sessions;
+		this.sampleRate = config.ae.sample_rate;
+	}
+	async generate(text, language, style, totalStep, speed = 1.05, silenceDuration = .3, onProgress, isAborted, createAbortError = createDefaultAbortError) {
+		if (style.ttl.dims[0] !== 1) throw new Error("Supertonic only supports single-style synthesis in this adapter");
+		const chunks = chunkText(text, language === "ko" ? 120 : 300);
+		let wav = [];
+		let duration = 0;
+		for (let index = 0; index < chunks.length; index += 1) {
+			if (isAborted?.()) throw createAbortError();
+			const chunk = chunks[index];
+			const result = await this.generateChunk(chunk, language, style, totalStep, speed, onProgress, isAborted, createAbortError);
+			if (wav.length === 0) {
+				wav = result.wav;
+				duration = result.duration;
+			} else {
+				const silenceLength = Math.floor(silenceDuration * this.sampleRate);
+				wav = [
+					...wav,
+					...Array.from({ length: silenceLength }, () => 0),
+					...result.wav
+				];
+				duration += result.duration + silenceDuration;
+			}
+		}
+		return {
+			wav: new Float32Array(wav),
+			duration
+		};
+	}
+	async generateChunk(text, language, style, totalStep, speed, onProgress, isAborted, createAbortError = createDefaultAbortError) {
+		const { textIds, textMask } = this.textProcessor.call([text], [language]);
+		const textIdsTensor = new this.ortModule.Tensor("int64", new BigInt64Array(textIds.flat().map((value) => BigInt(value))), [1, textIds[0].length]);
+		const textMaskTensor = new this.ortModule.Tensor("float32", new Float32Array(textMask.flat(2)), [
+			1,
+			1,
+			textMask[0][0].length
+		]);
+		const durationOutputs = await this.sessions.durationPredictor.run({
+			text_ids: textIdsTensor,
+			style_dp: style.dp,
+			text_mask: textMaskTensor
+		});
+		const durations = Array.from(durationOutputs.duration.data);
+		for (let index = 0; index < durations.length; index += 1) durations[index] /= speed;
+		const textEncoderOutputs = await this.sessions.textEncoder.run({
+			text_ids: textIdsTensor,
+			style_ttl: style.ttl,
+			text_mask: textMaskTensor
+		});
+		let { xt, latentMask } = sampleNoisyLatent(durations, this.sampleRate, this.config.ae.base_chunk_size, this.config.ttl.chunk_compress_factor, this.config.ttl.latent_dim);
+		const latentMaskTensor = new this.ortModule.Tensor("float32", new Float32Array(latentMask.flat(2)), [
+			1,
+			1,
+			latentMask[0][0].length
+		]);
+		const totalStepTensor = new this.ortModule.Tensor("float32", new Float32Array([totalStep]), [1]);
+		for (let step = 0; step < totalStep; step += 1) {
+			if (isAborted?.()) throw createAbortError();
+			onProgress?.(step + 1, totalStep);
+			const xtTensor = new this.ortModule.Tensor("float32", new Float32Array(xt.flat(2)), [
+				1,
+				xt[0].length,
+				xt[0][0].length
+			]);
+			const currentStepTensor = new this.ortModule.Tensor("float32", new Float32Array([step]), [1]);
+			const vectorEstimatorOutputs = await this.sessions.vectorEstimator.run({
+				noisy_latent: xtTensor,
+				text_emb: textEncoderOutputs.text_emb,
+				style_ttl: style.ttl,
+				latent_mask: latentMaskTensor,
+				text_mask: textMaskTensor,
+				current_step: currentStepTensor,
+				total_step: totalStepTensor
+			});
+			xt = reshapeLatent(Array.from(vectorEstimatorOutputs.denoised_latent.data), xt[0].length, xt[0][0].length);
+		}
+		const latentTensor = new this.ortModule.Tensor("float32", new Float32Array(xt.flat(2)), [
+			1,
+			xt[0].length,
+			xt[0][0].length
+		]);
+		const vocoderOutputs = await this.sessions.vocoder.run({ latent: latentTensor });
+		return {
+			wav: Array.from(vocoderOutputs.wav_tts.data),
+			duration: durations[0] ?? 0
+		};
+	}
+};
+function sampleNoisyLatent(durations, sampleRate, baseChunkSize, chunkCompressFactor, latentDim) {
+	const maxDuration = Math.max(...durations);
+	const wavLengthMax = Math.floor(maxDuration * sampleRate);
+	const chunkSize = baseChunkSize * chunkCompressFactor;
+	const latentLength = Math.floor((wavLengthMax + chunkSize - 1) / chunkSize);
+	const latentDimensions = latentDim * chunkCompressFactor;
+	const wavLengths = durations.map((duration) => Math.floor(duration * sampleRate));
+	const xt = [[]];
+	for (let dimension = 0; dimension < latentDimensions; dimension += 1) {
+		const row = [];
+		for (let time = 0; time < latentLength; time += 1) row.push(gaussianRandom());
+		xt[0].push(row);
+	}
+	return {
+		xt,
+		latentMask: [[Array.from({ length: latentLength }, (_, index) => {
+			return index * chunkSize < wavLengths[0] ? 1 : 0;
+		})]]
+	};
+}
+function reshapeLatent(data, dimensions, length) {
+	const batch = [];
+	let cursor = 0;
+	for (let dimension = 0; dimension < dimensions; dimension += 1) {
+		const row = [];
+		for (let index = 0; index < length; index += 1) {
+			row.push(data[cursor] ?? 0);
+			cursor += 1;
+		}
+		batch.push(row);
+	}
+	return [batch];
+}
+function chunkText(text, maxLength) {
+	const paragraphs = text.trim().split(/\n\s*\n+/).filter(Boolean);
+	const chunks = [];
+	for (let paragraph of paragraphs) {
+		paragraph = paragraph.trim();
+		if (!paragraph) continue;
+		const sentences = paragraph.split(/(?<!Mr\.|Mrs\.|Ms\.|Dr\.|Prof\.|Sr\.|Jr\.|Ph\.D\.|etc\.|e\.g\.|i\.e\.|vs\.|Inc\.|Ltd\.|Co\.|Corp\.|St\.|Ave\.|Blvd\.)(?<!\b[A-Z]\.)(?<=[.!?])\s+/) || [paragraph];
+		let currentChunk = "";
+		for (const sentence of sentences) {
+			if (currentChunk.length + sentence.length + 1 <= maxLength) {
+				currentChunk += `${currentChunk ? " " : ""}${sentence}`;
+				continue;
+			}
+			if (currentChunk) chunks.push(currentChunk.trim());
+			currentChunk = sentence;
+		}
+		if (currentChunk) chunks.push(currentChunk.trim());
+	}
+	return chunks.length ? chunks : [text.trim()];
+}
+//#endregion
+//#region src/supertonic.shared.ts
+const SUPERTONIC_STYLE_IDS = [
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"M1",
+	"M2",
+	"M3",
+	"M4",
+	"M5"
+];
+const SUPERTONIC_LANGUAGES = [
+	{
+		id: "en",
+		label: "English"
+	},
+	{
+		id: "ko",
+		label: "Korean"
+	},
+	{
+		id: "es",
+		label: "Spanish"
+	},
+	{
+		id: "pt",
+		label: "Portuguese"
+	},
+	{
+		id: "fr",
+		label: "French"
+	}
+];
+new Map(SUPERTONIC_LANGUAGES.map((language) => [language.id, language]));
+function parseSupertonicVoiceId(voiceId) {
+	const [rawLanguage, rawStyle] = (voiceId ?? "en:M1").split(":");
+	return {
+		language: SUPERTONIC_LANGUAGES.find((entry) => entry.id === rawLanguage)?.id ?? "en",
+		styleId: SUPERTONIC_STYLE_IDS.find((entry) => entry === rawStyle) ?? "M1"
+	};
+}
+//#endregion
+//#region src/supertonic.ts
+const SUPERTONIC_MODEL_ASSET_NAMES = {
+	durationPredictor: "onnx/duration_predictor.onnx",
+	textEncoder: "onnx/text_encoder.onnx",
+	vectorEstimator: "onnx/vector_estimator.onnx",
+	vocoder: "onnx/vocoder.onnx"
+};
+function readJson(buffer) {
+	return JSON.parse(new TextDecoder().decode(buffer));
+}
+var SupertonicNodeModel = class {
+	kind = "synthesizing";
+	modelId;
+	adapterId;
+	tts = null;
+	sessions = null;
+	styles = /* @__PURE__ */ new Map();
+	constructor(spec, context) {
+		this.spec = spec;
+		this.context = context;
+		this.modelId = spec.id;
+		this.adapterId = spec.adapterId;
+	}
+	async load(signal, onProgress) {
+		const config = readJson(await this.loadAsset("onnx/tts.json", signal));
+		const unicodeIndexer = readJson(await this.loadAsset("onnx/unicode_indexer.json", signal));
+		const ortModule = await import("onnxruntime-node");
+		if (signal.aborted) throw this.context.createAbortError();
+		const styles = /* @__PURE__ */ new Map();
+		for (let index = 0; index < SUPERTONIC_STYLE_IDS.length; index += 1) {
+			const styleId = SUPERTONIC_STYLE_IDS[index];
+			const json = readJson(await this.loadAsset(`voice_styles/${styleId}.json`, signal));
+			styles.set(styleId, createSupertonicStyle(ortModule, json));
+		}
+		onProgress?.(.2);
+		const modelBuffers = {};
+		for (let index = 0; index < SUPERTONIC_MODEL_SESSION_KEYS.length; index += 1) {
+			const key = SUPERTONIC_MODEL_SESSION_KEYS[index];
+			modelBuffers[key] = await this.loadAsset(SUPERTONIC_MODEL_ASSET_NAMES[key], signal);
+			onProgress?.(.2 + (index + 1) / SUPERTONIC_MODEL_SESSION_KEYS.length * .4);
+		}
+		const sessions = await loadSupertonicSessions(ortModule, modelBuffers, (completed, total) => {
+			onProgress?.(.6 + completed / total * .4);
+		});
+		if (signal.aborted) throw this.context.createAbortError();
+		this.styles = styles;
+		this.sessions = sessions;
+		this.tts = new SupertonicTextToSpeech(ortModule, config, new SupertonicUnicodeProcessor(unicodeIndexer), sessions);
+		onProgress?.(1);
+	}
+	async generate(text, voiceId, signal, speed) {
+		if (!this.tts) throw new Error("Supertonic model not loaded");
+		const { language, styleId } = parseSupertonicVoiceId(voiceId);
+		const style = this.styles.get(styleId);
+		if (!style) throw new Error(`Unsupported Supertonic style: ${styleId}`);
+		return pcmToAudioData((await this.tts.generate(text, language, style, Number(this.spec.config?.totalStep ?? 2), speed ?? 1, .3, void 0, () => signal.aborted, () => this.context.createAbortError())).wav, this.tts.sampleRate);
+	}
+	listVoices() {
+		return this.spec.voices ?? [];
+	}
+	dispose() {
+		this.tts = null;
+		this.styles.clear();
+		const sessions = this.sessions;
+		this.sessions = null;
+		if (!sessions) return;
+		for (const session of Object.values(sessions)) session.release?.call(session);
+	}
+	async loadAsset(assetName, signal) {
+		const bundle = {
+			adapterId: this.spec.adapterId,
+			modelId: this.spec.id,
+			revision: this.spec.revision
+		};
+		const cached = await this.context.assetStore.getAsset(bundle, assetName);
+		if (cached) return cached;
+		const asset = getModelAssets(this.spec).find((entry) => entry.name === assetName);
+		if (!asset) throw new Error(`Supertonic asset "${assetName}" is missing from model "${this.spec.id}"`);
+		const response = await this.context.fetch(asset.url, { signal });
+		if (!response.ok) throw new Error(`Failed to fetch Supertonic asset "${assetName}": HTTP ${response.status}`);
+		return response.arrayBuffer();
+	}
+};
+const supertonicNodeAdapter = {
+	id: "supertonic-node",
+	name: "Supertonic Node",
+	capabilities: {
+		install: false,
+		speak: false,
+		synthesize: true,
+		stream: false,
+		dynamicVoices: false
+	},
+	createModel(spec, context) {
+		return new SupertonicNodeModel(spec, context);
+	}
+};
+//#endregion
+//#region src/index.ts
+const DEFAULT_KOKORO_MODEL_REF = "onnx-community/Kokoro-82M-v1.0-ONNX";
+function normalizeSpeakSpeed(speed) {
+	if (!Number.isFinite(speed)) return void 0;
+	return Math.min(2, Math.max(.5, speed));
+}
+function phonemesToIds(phonemes, config) {
+	const map = config.phoneme_id_map;
+	const ids = [];
+	if (map["^"]) ids.push(...map["^"]);
+	for (const phoneme of phonemes) {
+		const phonemeIds = map[phoneme];
+		if (phonemeIds === void 0) continue;
+		ids.push(...phonemeIds);
+		if (map["_"]) ids.push(...map["_"]);
+	}
+	if (map["$"]) ids.push(...map["$"]);
+	return ids;
+}
+async function loadSpecAsset(spec, assetName, context, signal) {
+	const bundle = {
+		adapterId: spec.adapterId,
+		modelId: spec.id,
+		revision: spec.revision
+	};
+	const cached = await context.assetStore.getAsset(bundle, assetName);
+	if (cached) return cached;
+	const asset = getModelAssets(spec).find((entry) => entry.name === assetName);
+	if (!asset) throw new Error(`Asset "${assetName}" is missing from model "${spec.id}"`);
+	const response = await context.fetch(asset.url, { signal });
+	if (!response.ok) throw new Error(`Failed to fetch ${asset.name}: HTTP ${response.status}`);
+	return response.arrayBuffer();
+}
+var KokoroNodeModel = class {
+	kind = "synthesizing";
+	modelId;
+	adapterId;
+	tts = null;
+	voices = [];
+	constructor(spec, createAbortError) {
+		this.spec = spec;
+		this.createAbortError = createAbortError;
+		this.modelId = spec.id;
+		this.adapterId = spec.adapterId;
+	}
+	async load(signal, onProgress) {
+		if (signal.aborted) throw this.createAbortError();
+		const kokoroModule = await import("kokoro-js");
+		const modelRef = this.spec.config?.modelId ?? DEFAULT_KOKORO_MODEL_REF;
+		this.tts = await kokoroModule.KokoroTTS.from_pretrained(modelRef, {
+			dtype: "q8",
+			device: "cpu",
+			progress_callback(progress) {
+				if (progress.status === "progress" && progress.loaded != null && progress.total) onProgress?.(progress.loaded / progress.total);
+			}
+		});
+		if (signal.aborted) throw this.createAbortError();
+		this.voices = Object.entries(this.tts.voices ?? {}).map(([id, info]) => ({
+			id,
+			name: info?.name ?? id,
+			language: info?.language ?? (id.startsWith("b") ? "en-GB" : "en-US"),
+			gender: info?.gender
+		}));
+	}
+	async generate(text, voiceId, signal, speed) {
+		if (!this.tts) throw new Error("Kokoro model not loaded");
+		if (signal.aborted) throw this.createAbortError();
+		const result = await this.tts.generate(text, {
+			voice: voiceId,
+			speed: normalizeSpeakSpeed(speed)
+		});
+		if (signal.aborted) throw this.createAbortError();
+		return {
+			sampleRate: result.sampling_rate ?? 24e3,
+			channels: [result.audio]
+		};
+	}
+	listVoices() {
+		return this.voices.length ? this.voices : this.spec.voices ?? [];
+	}
+	dispose() {
+		this.tts = null;
+		this.voices = [];
+	}
+};
+var PiperNodeModel = class {
+	kind = "synthesizing";
+	modelId;
+	adapterId;
+	session = null;
+	phonemize = null;
+	voiceConfig = null;
+	constructor(spec, context) {
+		this.spec = spec;
+		this.context = context;
+		this.modelId = spec.id;
+		this.adapterId = spec.adapterId;
+	}
+	async load(signal) {
+		const voiceAsset = getModelAssets(this.spec).find((asset) => asset.name.endsWith(".json"));
+		const modelAsset = getModelAssets(this.spec).find((asset) => asset.name.endsWith(".onnx"));
+		if (!voiceAsset || !modelAsset) throw new Error(`Piper model "${this.spec.id}" is missing required assets`);
+		const [configData, modelData] = await Promise.all([loadSpecAsset(this.spec, voiceAsset.name, this.context, signal), loadSpecAsset(this.spec, modelAsset.name, this.context, signal)]);
+		if (signal.aborted) throw this.context.createAbortError();
+		const session = await (await import("onnxruntime-node")).InferenceSession.create(new Uint8Array(modelData));
+		const phonemizerModule = await import("phonemizer");
+		if (signal.aborted) throw this.context.createAbortError();
+		this.voiceConfig = JSON.parse(new TextDecoder().decode(configData));
+		this.session = session;
+		this.phonemize = phonemizerModule.phonemize;
+	}
+	async generate(text, _voiceId, signal) {
+		if (!this.session || !this.phonemize || !this.voiceConfig) throw new Error("Piper model not loaded");
+		const languageTag = this.spec.languages[0]?.toLowerCase() ?? "en-us";
+		const phonemeTokens = await this.phonemize(text, languageTag);
+		if (signal.aborted) throw this.context.createAbortError();
+		const ids = phonemesToIds(Array.from(phonemeTokens.join("")), this.voiceConfig);
+		if (!ids.length) throw new Error("Phoneme mapping produced an empty sequence");
+		const ort = await import("onnxruntime-node");
+		const feedsMap = {
+			input: new ort.Tensor("int64", new BigInt64Array(ids.map(BigInt)), [1, ids.length]),
+			input_lengths: new ort.Tensor("int64", new BigInt64Array([BigInt(ids.length)]), [1]),
+			scales: new ort.Tensor("float32", new Float32Array([
+				this.voiceConfig.inference.noise_scale,
+				this.voiceConfig.inference.length_scale,
+				this.voiceConfig.inference.noise_w
+			]), [3])
+		};
+		if (this.voiceConfig.num_speakers > 1) feedsMap.sid = new ort.Tensor("int64", new BigInt64Array([BigInt(0)]), [1]);
+		const results = await this.session.run(feedsMap);
+		const audioData = results[Object.keys(results)[0]].data;
+		if (signal.aborted) throw this.context.createAbortError();
+		return {
+			sampleRate: this.voiceConfig.audio.sample_rate,
+			channels: [audioData]
+		};
+	}
+	listVoices() {
+		return this.spec.voices ?? [];
+	}
+	dispose() {
+		this.session = null;
+		this.phonemize = null;
+		this.voiceConfig = null;
+	}
+};
+/** TTS adapter for Kokoro models on Node.js using kokoro-js. */
+const kokoroNodeAdapter = {
+	id: "kokoro-node",
+	name: "Kokoro Node",
+	capabilities: {
+		install: false,
+		speak: false,
+		synthesize: true,
+		stream: false,
+		dynamicVoices: true
+	},
+	createModel(spec, context) {
+		return new KokoroNodeModel(spec, () => context.createAbortError());
+	}
+};
+/** TTS adapter for Piper models on Node.js using native ONNX Runtime. */
+const piperNodeAdapter = {
+	id: "piper-node",
+	name: "Piper Node",
+	capabilities: {
+		install: false,
+		speak: false,
+		synthesize: true,
+		stream: false,
+		dynamicVoices: false
+	},
+	createModel(spec, context) {
+		return new PiperNodeModel(spec, context);
+	}
+};
+/** All official Node.js TTS adapters bundled for convenience. */
+const officialNodeAdapters = [
+	kokoroNodeAdapter,
+	piperNodeAdapter,
+	kittenNodeAdapter,
+	supertonicNodeAdapter
+];
+//#endregion
+export { kittenNodeAdapter, kokoroNodeAdapter, officialNodeAdapters, piperNodeAdapter, supertonicNodeAdapter };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@polytts/node-adapters",
+  "version": "0.1.0",
+  "description": "Official Node adapter implementations for polytts.",
+  "keywords": [
+    "adapters",
+    "electron",
+    "node",
+    "polytts",
+    "raycast",
+    "text-to-speech",
+    "tts"
+  ],
+  "homepage": "https://github.com/Dunqing/polytts/tree/main/packages/node-adapters#readme",
+  "bugs": {
+    "url": "https://github.com/Dunqing/polytts/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Dunqing/polytts.git",
+    "directory": "packages/node-adapters"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "kokoro-js": "latest",
+    "onnxruntime-node": "latest",
+    "phonemizer": "latest",
+    "@polytts/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "vite-plus": "latest",
+    "@polytts/presets": "0.1.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test",
+    "test:run": "vp test run"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts"
+}