@polytts/node 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,50 @@
+# @polytts/node
+
+[![npm version](https://img.shields.io/npm/v/@polytts/node)](https://www.npmjs.com/package/@polytts/node)
+
+Node entrypoint for [`polytts`](https://github.com/Dunqing/polytts).
+
+Use this package for Node runtimes such as Electron main or preload code, Raycast extensions, and server-side synthesis workflows.
+
+## Install
+
+```bash
+npm install @polytts/node
+```
+
+## Usage
+
+```ts
+import { createNodeTTS } from "@polytts/node";
+
+const tts = createNodeTTS();
+
+await tts.ready();
+await tts.writeWav("./hello.wav", "Hello from Node.");
+```
+
+For progressive synthesis:
+
+```ts
+for await (const chunk of tts.synthesizeStream("Hello from a streaming Node runtime.")) {
+  console.log(chunk.sampleRate, chunk.channels[0]?.length ?? 0);
+}
+```
+
+The high-level API also exposes:
+
+- `install(modelId?, onProgress?)`
+- `uninstall(modelId?)`
+- `getInstallState(modelId?)`
+- `isInstalled(modelId?)`
+
+`@polytts/node` intentionally does not expose `speak()`. In Node hosts, playback is application-specific, so the package focuses on synthesis and file/byte output (`synthesize()`, `synthesizeToWav()`, `writeWav()`).
+
+## Built-in models
+
+- Kokoro 82M
+- Piper voice bundles
+- KittenTTS Mini and Nano
+- Supertonic 2
+
+`Browser Speech` is intentionally browser-only and is not part of this package.

package/dist/index.d.mts

@@ -0,0 +1,138 @@
+import { AssetBundleKey, AssetStore, AssetStore as AssetStore$1, AudioData, AudioData as AudioData$1, CatalogSource, InstallState, InstallState as InstallState$1, ModelId, ModelId as ModelId$1, ModelRuntimeInfo, ModelSpec, PrepareOptions, RuntimePhase, RuntimeState, SpeakOptions, TTSAdapter, Voice, Voice as Voice$1, VoiceId, VoiceId as VoiceId$1 } from "@polytts/core";
+import { officialNodeAdapters } from "@polytts/node-adapters";
+import { officialNodeCatalog, officialNodeModels } from "@polytts/presets";
+
+//#region src/storage/fs-asset-store.d.ts
+/**
+ * Filesystem-backed asset store that caches TTS model files on disk. Defaults to `~/.polytts/cache`
+ * when no root directory is provided.
+ */
+declare class FsAssetStore implements AssetStore$1 {
+  private readonly rootDir;
+  constructor(rootDir?: string);
+  stageAsset(bundle: AssetBundleKey, assetName: string, data: ArrayBuffer): Promise<void>;
+  activateBundle(bundle: AssetBundleKey, assetNames: string[]): Promise<void>;
+  isInstalled(bundle: AssetBundleKey, requiredAssetNames?: string[]): Promise<boolean>;
+  getAsset(bundle: AssetBundleKey, assetName: string): Promise<ArrayBuffer | null>;
+  removeBundle(bundle: AssetBundleKey): Promise<void>;
+  private readMeta;
+  private bundleDir;
+  private metaPath;
+  private revisionDir;
+  private activeRevisionDir;
+  private stagingDir;
+  private stagedAssetPath;
+  private activeAssetPath;
+}
+//#endregion
+//#region src/index.d.ts
+/** Audio data returned by synthesis operations. */
+type NodeAudio = AudioData$1;
+/** Options for preparing (loading) a TTS model. */
+type NodePrepareOptions = PrepareOptions;
+/** Options for synthesis operations (voice, speed, etc.). */
+type NodeSynthesizeOptions = SpeakOptions;
+/** A TTS adapter that provides a specific TTS backend (e.g. Piper, Kokoro). */
+type NodeTTSAdapter = TTSAdapter;
+/** Subset of the core RuntimeState exposed by the Node TTS runtime. */
+type NodeRuntimeState = Pick<RuntimeState, "models" | "supportedModelIds" | "activeModelId" | "activeVoiceId" | "voices" | "isPreparing" | "isSpeaking" | "phase" | "phaseModelId" | "phaseProgress" | "runtimeInfoByModel" | "error" | "installStates" | "installStateHydrated">;
+/** Configuration options for {@link createNodeTTSRuntime} and {@link createNodeTTS}. */
+interface NodeTTSRuntimeOptions {
+  /** TTS adapters to use; defaults to official Node adapters. */
+  adapters?: NodeTTSAdapter[];
+  /** Inline model specs to register (merged with catalogs). */
+  models?: ModelSpec[];
+  /** Catalog sources providing model definitions. */
+  catalogs?: CatalogSource[];
+  /** Custom asset store for downloaded model files. */
+  assetStore?: AssetStore$1;
+  /** Filesystem directory for the default asset store cache. */
+  cacheDir?: string;
+  /** Custom fetch implementation for downloading assets. */
+  fetch?: typeof fetch;
+  /** Model to activate on startup. */
+  initialModelId?: ModelId$1;
+  /** Voice to activate on startup. */
+  initialVoiceId?: VoiceId$1;
+}
+/** Low-level Node TTS runtime providing model management and synthesis capabilities. */
+interface NodeTTSRuntime {
+  getState(): NodeRuntimeState;
+  /** Subscribes to state changes; returns an unsubscribe function. */
+  subscribe(listener: (state: NodeRuntimeState) => void): () => void;
+  listModels(): ModelSpec[];
+  getModel(modelId: ModelId$1): ModelSpec | null;
+  /** Returns the install state for the given model. */
+  getInstallState(modelId: ModelId$1): InstallState$1 | null;
+  /** Returns true if the model's assets are fully available. */
+  isInstalled(modelId: ModelId$1): boolean;
+  listVoices(modelId?: ModelId$1): Promise<Voice$1[]>;
+  /** Downloads model assets, with optional progress callback. */
+  install(modelId: ModelId$1, onProgress?: (progress: number) => void): Promise<void>;
+  /** Removes previously downloaded model assets. */
+  uninstall(modelId: ModelId$1): Promise<void>;
+  /** Loads a model so it is ready for synthesis. */
+  prepare(modelId: ModelId$1, options?: NodePrepareOptions): Promise<void>;
+  /** Returns an async iterable of audio chunks for streaming synthesis. */
+  synthesizeStream(text: string, options?: NodeSynthesizeOptions): AsyncIterable<NodeAudio>;
+  /** Synthesizes text and returns the complete audio data. */
+  synthesize(text: string, options?: NodeSynthesizeOptions): Promise<NodeAudio>;
+  /** Releases all resources held by this runtime. */
+  dispose(): void;
+}
+/** High-level Node TTS interface with model/voice selection, WAV export, and convenience methods. */
+interface NodeTTS {
+  /** The underlying low-level Node TTS runtime. */
+  readonly runtime: NodeTTSRuntime;
+  getState(): NodeRuntimeState;
+  /** Subscribes to state changes; returns an unsubscribe function. */
+  subscribe(listener: (state: NodeRuntimeState) => void): () => void;
+  listModels(): ModelSpec[];
+  /** Returns the model for the given ID, or null. */
+  getModel(modelId?: ModelId$1 | null): ModelSpec | null;
+  /** Returns the currently active model, or null. */
+  getSelectedModel(): ModelSpec | null;
+  /** Returns the install state for the given or active model. */
+  getInstallState(modelId?: ModelId$1 | null): InstallState$1 | null;
+  /** Returns true if the given or active model's assets are fully available. */
+  isInstalled(modelId?: ModelId$1 | null): boolean;
+  listVoices(modelId?: ModelId$1): Promise<Voice$1[]>;
+  /** Returns the currently active voice, or null. */
+  getSelectedVoice(): Voice$1 | null;
+  /** Downloads model assets; defaults to the active model if omitted. */
+  install(modelId?: ModelId$1, onProgress?: (progress: number) => void): Promise<void>;
+  /** Removes downloaded assets; defaults to the active model if omitted. */
+  uninstall(modelId?: ModelId$1): Promise<void>;
+  /** Activates a model, downloading and loading it if necessary. */
+  selectModel(modelId: ModelId$1, options?: Omit<NodePrepareOptions, "modelId">): Promise<void>;
+  /** Activates a voice, resolving its parent model automatically. */
+  selectVoice(voiceId: VoiceId$1): Promise<void>;
+  /** Ensures the selected (or specified) model is loaded and ready to synthesize. */
+  ready(options?: {
+    modelId?: ModelId$1;
+    voiceId?: VoiceId$1;
+    onProgress?: (progress: number) => void;
+  }): Promise<void>;
+  /** Returns an async iterable of audio chunks for streaming synthesis. */
+  synthesizeStream(text: string, options?: NodeSynthesizeOptions): AsyncIterable<NodeAudio>;
+  /** Synthesizes text and returns the complete audio data. */
+  synthesize(text: string, options?: NodeSynthesizeOptions): Promise<NodeAudio>;
+  /** Synthesizes text and returns WAV-encoded bytes. */
+  synthesizeToWav(text: string, options?: NodeSynthesizeOptions): Promise<Uint8Array>;
+  /** Synthesizes text and writes the result as a WAV file to disk. */
+  writeWav(path: string, text: string, options?: NodeSynthesizeOptions): Promise<void>;
+  /** Releases all resources held by this instance. */
+  dispose(): void;
+}
+/**
+ * Creates a low-level Node TTS runtime. Defaults to official adapters and model catalogs when none
+ * are provided. Use {@link createNodeTTS} for a higher-level API.
+ */
+declare function createNodeTTSRuntime(options?: NodeTTSRuntimeOptions): NodeTTSRuntime;
+/**
+ * Creates a high-level Node TTS instance with model/voice selection, WAV encoding, and file output.
+ * This is the recommended entry point for server-side TTS usage.
+ */
+declare function createNodeTTS(options?: NodeTTSRuntimeOptions): NodeTTS;
+//#endregion
+export { type AssetStore, type AudioData, FsAssetStore, type InstallState, type ModelId, type ModelRuntimeInfo, NodeAudio, NodePrepareOptions, NodeRuntimeState, NodeSynthesizeOptions, NodeTTS, NodeTTSAdapter, NodeTTSRuntime, NodeTTSRuntimeOptions, type RuntimePhase, type Voice, type VoiceId, createNodeTTS, createNodeTTSRuntime, officialNodeAdapters, officialNodeCatalog, officialNodeModels };

package/dist/index.mjs

@@ -0,0 +1,357 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createTTSRuntime, isInstallStateAvailable, resolveInstallState } from "@polytts/core";
+import { officialNodeAdapters, officialNodeAdapters as officialNodeAdapters$1 } from "@polytts/node-adapters";
+import { officialNodeCatalog, officialNodeModels, officialNodeModels as officialNodeModels$1 } from "@polytts/presets";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+//#region src/storage/fs-asset-store.ts
+function encodeSegment(value) {
+	return encodeURIComponent(value);
+}
+function toArrayBuffer(data) {
+	return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+/**
+* Filesystem-backed asset store that caches TTS model files on disk. Defaults to `~/.polytts/cache`
+* when no root directory is provided.
+*/
+var FsAssetStore = class {
+	constructor(rootDir = join(homedir(), ".polytts", "cache")) {
+		this.rootDir = rootDir;
+	}
+	async stageAsset(bundle, assetName, data) {
+		const targetPath = this.stagedAssetPath(bundle, assetName);
+		await mkdir(dirname(targetPath), { recursive: true });
+		await writeFile(targetPath, Buffer.from(data));
+	}
+	async activateBundle(bundle, assetNames) {
+		const stagedDir = this.stagingDir(bundle);
+		const activeDir = this.activeRevisionDir(bundle);
+		await Promise.all(assetNames.map(async (assetName) => {
+			await readFile(this.stagedAssetPath(bundle, assetName));
+		}));
+		const currentMeta = await this.readMeta(bundle);
+		await rm(activeDir, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(dirname(activeDir), { recursive: true });
+		await rename(stagedDir, activeDir);
+		if (currentMeta && currentMeta.revision !== bundle.revision) await rm(this.revisionDir(bundle, currentMeta.revision), {
+			recursive: true,
+			force: true
+		});
+		await writeFile(this.metaPath(bundle), JSON.stringify({
+			revision: bundle.revision,
+			assetNames
+		}), "utf8");
+	}
+	async isInstalled(bundle, requiredAssetNames) {
+		const meta = await this.readMeta(bundle);
+		if (!meta || meta.revision !== bundle.revision) return false;
+		const assetNames = requiredAssetNames?.length ? requiredAssetNames : meta.assetNames;
+		try {
+			await Promise.all(assetNames.map((assetName) => readFile(this.activeAssetPath(bundle, assetName))));
+			return true;
+		} catch (error) {
+			if (error.code === "ENOENT") return false;
+			throw error;
+		}
+	}
+	async getAsset(bundle, assetName) {
+		const meta = await this.readMeta(bundle);
+		if (!meta || meta.revision !== bundle.revision) return null;
+		try {
+			return toArrayBuffer(await readFile(this.activeAssetPath(bundle, assetName)));
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+	}
+	async removeBundle(bundle) {
+		await rm(this.bundleDir(bundle), {
+			recursive: true,
+			force: true
+		});
+	}
+	async readMeta(bundle) {
+		return readJson(this.metaPath(bundle));
+	}
+	bundleDir(bundle) {
+		return join(this.rootDir, encodeSegment(bundle.adapterId), encodeSegment(bundle.modelId));
+	}
+	metaPath(bundle) {
+		return join(this.bundleDir(bundle), "meta.json");
+	}
+	revisionDir(bundle, revision = bundle.revision) {
+		return join(this.bundleDir(bundle), "revisions", encodeSegment(revision));
+	}
+	activeRevisionDir(bundle) {
+		return this.revisionDir(bundle, bundle.revision);
+	}
+	stagingDir(bundle) {
+		return join(this.bundleDir(bundle), "staging", encodeSegment(bundle.revision));
+	}
+	stagedAssetPath(bundle, assetName) {
+		return join(this.stagingDir(bundle), ...assetName.split("/"));
+	}
+	activeAssetPath(bundle, assetName) {
+		return join(this.activeRevisionDir(bundle), ...assetName.split("/"));
+	}
+};
+//#endregion
+//#region src/index.ts
+function encodeWav(audio) {
+	const channelCount = audio.channels.length;
+	if (channelCount === 0) throw new Error("Cannot encode empty audio");
+	const frameCount = audio.channels[0].length;
+	const bytesPerSample = 2;
+	const blockAlign = channelCount * bytesPerSample;
+	const byteRate = audio.sampleRate * blockAlign;
+	const dataSize = frameCount * blockAlign;
+	const buffer = new ArrayBuffer(44 + dataSize);
+	const view = new DataView(buffer);
+	const output = new Uint8Array(buffer);
+	const writeAscii = (offset, value) => {
+		for (let i = 0; i < value.length; i += 1) view.setUint8(offset + i, value.charCodeAt(i));
+	};
+	writeAscii(0, "RIFF");
+	view.setUint32(4, 36 + dataSize, true);
+	writeAscii(8, "WAVE");
+	writeAscii(12, "fmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, channelCount, true);
+	view.setUint32(24, audio.sampleRate, true);
+	view.setUint32(28, byteRate, true);
+	view.setUint16(32, blockAlign, true);
+	view.setUint16(34, 16, true);
+	writeAscii(36, "data");
+	view.setUint32(40, dataSize, true);
+	let offset = 44;
+	for (let frameIndex = 0; frameIndex < frameCount; frameIndex += 1) for (let channelIndex = 0; channelIndex < channelCount; channelIndex += 1) {
+		const sample = audio.channels[channelIndex][frameIndex] ?? 0;
+		const clamped = Math.max(-1, Math.min(1, sample));
+		view.setInt16(offset, clamped < 0 ? clamped * 32768 : clamped * 32767, true);
+		offset += bytesPerSample;
+	}
+	return output;
+}
+function toNodeRuntimeState(state) {
+	return {
+		models: state.models,
+		supportedModelIds: state.supportedModelIds,
+		activeModelId: state.activeModelId,
+		activeVoiceId: state.activeVoiceId,
+		voices: state.voices,
+		isPreparing: state.isPreparing,
+		isSpeaking: state.isSpeaking,
+		phase: state.phase,
+		phaseModelId: state.phaseModelId,
+		phaseProgress: state.phaseProgress,
+		runtimeInfoByModel: state.runtimeInfoByModel,
+		error: state.error,
+		installStates: state.installStates,
+		installStateHydrated: state.installStateHydrated
+	};
+}
+function createCatalogs(options) {
+	const configuredCatalogs = options.catalogs ?? [];
+	if (configuredCatalogs.length > 0) {
+		if (options.models?.length) return [{ models: options.models }, ...configuredCatalogs];
+		return configuredCatalogs;
+	}
+	return [{ models: options.models?.length ? options.models : officialNodeModels$1 }];
+}
+var NodeRuntimeImpl = class {
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	getState() {
+		return toNodeRuntimeState(this.runtime.getState());
+	}
+	subscribe(listener) {
+		return this.runtime.subscribe((state) => {
+			listener(toNodeRuntimeState(state));
+		});
+	}
+	listModels() {
+		return this.runtime.listModels();
+	}
+	getModel(modelId) {
+		return this.runtime.getModel(modelId);
+	}
+	getInstallState(modelId) {
+		const model = this.runtime.getModel(modelId);
+		if (!model) return null;
+		return resolveInstallState(model, this.runtime.getState().installStates[model.id]);
+	}
+	isInstalled(modelId) {
+		return isInstallStateAvailable(this.getInstallState(modelId));
+	}
+	listVoices(modelId) {
+		return this.runtime.listVoices(modelId);
+	}
+	install(modelId, onProgress) {
+		return this.runtime.install(modelId, onProgress);
+	}
+	uninstall(modelId) {
+		return this.runtime.uninstall(modelId);
+	}
+	prepare(modelId, options) {
+		return this.runtime.prepare(modelId, options);
+	}
+	synthesize(text, options) {
+		return this.runtime.synthesize(text, options);
+	}
+	synthesizeStream(text, options) {
+		return this.runtime.synthesizeStream(text, options);
+	}
+	dispose() {
+		this.runtime.dispose();
+	}
+};
+var NodeTTSImpl = class {
+	constructor(runtime) {
+		this.runtime = runtime;
+	}
+	getState() {
+		return this.runtime.getState();
+	}
+	subscribe(listener) {
+		return this.runtime.subscribe(listener);
+	}
+	listModels() {
+		return this.runtime.listModels();
+	}
+	getModel(modelId) {
+		if (!modelId) return null;
+		return this.runtime.getModel(modelId);
+	}
+	getSelectedModel() {
+		return this.getModel(this.runtime.getState().activeModelId);
+	}
+	getInstallState(modelId) {
+		const resolvedModelId = modelId ?? this.runtime.getState().activeModelId;
+		if (!resolvedModelId) return null;
+		return this.runtime.getInstallState(resolvedModelId);
+	}
+	isInstalled(modelId) {
+		return isInstallStateAvailable(this.getInstallState(modelId));
+	}
+	listVoices(modelId) {
+		return this.runtime.listVoices(modelId);
+	}
+	getSelectedVoice() {
+		const state = this.runtime.getState();
+		return state.voices.find((voice) => voice.id === state.activeVoiceId) ?? null;
+	}
+	async install(modelId, onProgress) {
+		const targetModelId = modelId ?? this.runtime.getState().activeModelId;
+		if (!targetModelId) throw new Error("No active model selected");
+		await this.runtime.install(targetModelId, onProgress);
+	}
+	async uninstall(modelId) {
+		const targetModelId = modelId ?? this.runtime.getState().activeModelId;
+		if (!targetModelId) throw new Error("No active model selected");
+		await this.runtime.uninstall(targetModelId);
+	}
+	async selectModel(modelId, options) {
+		await this.runtime.prepare(modelId, options);
+	}
+	async selectVoice(voiceId) {
+		const selection = this.resolveModelSelection({ voiceId });
+		await this.runtime.prepare(selection.modelId, { voiceId: selection.voiceId });
+	}
+	async ready(options) {
+		const modelId = options?.modelId ?? this.runtime.getState().activeModelId;
+		if (!modelId) throw new Error("No active model selected");
+		await this.runtime.prepare(modelId, {
+			voiceId: options?.voiceId,
+			onProgress: options?.onProgress
+		});
+	}
+	synthesize(text, options) {
+		return this.runtime.synthesize(text, options);
+	}
+	synthesizeStream(text, options) {
+		return this.runtime.synthesizeStream(text, options);
+	}
+	async synthesizeToWav(text, options) {
+		return encodeWav(await this.runtime.synthesize(text, options));
+	}
+	async writeWav(path, text, options) {
+		const wav = await this.synthesizeToWav(text, options);
+		await writeFile(path, Buffer.from(wav.buffer, wav.byteOffset, wav.byteLength));
+	}
+	dispose() {
+		this.runtime.dispose();
+	}
+	resolveModelId(modelId) {
+		const runtimeState = this.runtime.getState();
+		const resolved = modelId ?? runtimeState.activeModelId ?? runtimeState.supportedModelIds[0] ?? runtimeState.models[0]?.id;
+		if (!resolved) throw new Error("No models are registered in this NodeTTS instance");
+		return resolved;
+	}
+	resolveModelSelection(options) {
+		const modelId = this.resolveModelId(options?.modelId);
+		const voiceId = options?.voiceId;
+		if (!voiceId) return { modelId };
+		const model = this.runtime.getModel(modelId);
+		if (!model) return {
+			modelId,
+			voiceId
+		};
+		if (this.modelHasVoice(model, voiceId)) return {
+			modelId,
+			voiceId
+		};
+		const matchingFamilyModelId = this.findModelIdForVoice(voiceId, model.family);
+		if (matchingFamilyModelId) return {
+			modelId: matchingFamilyModelId,
+			voiceId
+		};
+		return {
+			modelId,
+			voiceId
+		};
+	}
+	findModelIdForVoice(voiceId, familyId) {
+		return this.runtime.getState().models.find((model) => (familyId == null || model.family === familyId) && this.modelHasVoice(model, voiceId))?.id ?? null;
+	}
+	modelHasVoice(model, voiceId) {
+		return model.defaultVoiceId === voiceId || model.voices?.some((voice) => voice.id === voiceId) === true;
+	}
+};
+/**
+* Creates a low-level Node TTS runtime. Defaults to official adapters and model catalogs when none
+* are provided. Use {@link createNodeTTS} for a higher-level API.
+*/
+function createNodeTTSRuntime(options = {}) {
+	return new NodeRuntimeImpl(createTTSRuntime({
+		adapters: options.adapters?.length ? options.adapters : officialNodeAdapters$1,
+		catalogs: createCatalogs(options),
+		assetStore: options.assetStore ?? new FsAssetStore(options.cacheDir),
+		audioPlayer: null,
+		fetch: options.fetch,
+		initialModelId: options.initialModelId,
+		initialVoiceId: options.initialVoiceId
+	}));
+}
+/**
+* Creates a high-level Node TTS instance with model/voice selection, WAV encoding, and file output.
+* This is the recommended entry point for server-side TTS usage.
+*/
+function createNodeTTS(options = {}) {
+	return new NodeTTSImpl(createNodeTTSRuntime(options));
+}
+//#endregion
+export { FsAssetStore, createNodeTTS, createNodeTTSRuntime, officialNodeAdapters, officialNodeCatalog, officialNodeModels };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@polytts/node",
+  "version": "0.1.0",
+  "description": "Node entrypoint for polytts text-to-speech runtimes.",
+  "keywords": [
+    "electron",
+    "node",
+    "onnx",
+    "polytts",
+    "raycast",
+    "text-to-speech",
+    "tts"
+  ],
+  "homepage": "https://github.com/Dunqing/polytts/tree/main/packages/node#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"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@polytts/core": "0.1.0",
+    "@polytts/node-adapters": "0.1.0",
+    "@polytts/presets": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "vite-plus": "latest"
+  },
+  "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"
+}