react-native-tts-kit 0.1.0

package/licenses/OpenRAIL-M.txt

@@ -0,0 +1,209 @@
+BigScience Open RAIL-M License
+dated August 18, 2022
+
+Section I: PREAMBLE
+
+This Open RAIL-M License was created by BigScience, a collaborative open innovation project aimed at
+the responsible development and use of large multilingual datasets and Large Language Models
+(“LLMs”). While a similar license was originally designed for the BLOOM model, we decided to adapt it
+and create this license in order to propose a general open and responsible license applicable to other
+machine learning based AI models (e.g. multimodal generative models).
+In short, this license strives for both the open and responsible downstream use of the accompanying
+model. When it comes to the open character, we took inspiration from open source permissive licenses
+regarding the grant of IP rights. Referring to the downstream responsible use, we added use-based
+restrictions not permitting the use of the Model in very specific scenarios, in order for the licensor to be
+able to enforce the license in case potential misuses of the Model may occur. Even though downstream
+derivative versions of the model could be released under different licensing terms, the latter will always
+have to include - at minimum - the same use-based restrictions as the ones in the original license (this
+license).
+The development and use of artificial intelligence (“AI”), does not come without concerns. The world has
+witnessed how AI techniques may, in some instances, become risky for the public in general. These risks
+come in many forms, from racial discrimination to the misuse of sensitive information.
+BigScience believes in the intersection between open and responsible AI development; thus, this License
+aims to strike a balance between both in order to enable responsible open-science in the field of AI.
+This License governs the use of the model (and its derivatives) and is informed by the model card
+associated with the model.
+
+NOW THEREFORE, You and Licensor agree as follows:
+
+1. Definitions
+(a) "License" means the terms and conditions for use, reproduction, and Distribution as defined in
+this document.
+(b) “Data” means a collection of information and/or content extracted from the dataset used with the
+Model, including to train, pretrain, or otherwise evaluate the Model. The Data is not licensed under
+this License.
+(c)“Output” means the results of operating a Model as embodied in informational content resulting
+therefrom.
+(d)“Model” means any accompanying machine-learning based assemblies (including checkpoints),
+consisting of learnt weights, parameters (including optimizer states), corresponding to the model
+architecture as embodied in the Complementary Material, that have been trained or tuned, in whole or
+in part on the Data, using the Complementary Material.
+(e) “Derivatives of the Model” means all modifications to the Model, works based on the Model, or any
+other model which is created or initialized by transfer of patterns of the weights, parameters,
+activations or output of the Model, to the other model, in order to cause the other model to perform
+similarly to the Model, including - but not limited to - distillation methods entailing the use of
+intermediate data representations or methods based on the generation of synthetic data by the Model
+for training the other model.
+(f)“Complementary Material” means the accompanying source code and scripts used to define,
+run, load, benchmark or evaluate the Model, and used to prepare data for training or evaluation, if
+any. This includes any accompanying documentation, tutorials, examples, etc, if any.
+(g) “Distribution” means any transmission, reproduction, publication or other sharing of the Model or
+Derivatives of the Model to a third party, including providing the Model as a hosted service made
+available by electronic or other remote means - e.g. API-based or web access.
+(h) “Licensor” means the copyright owner or entity authorized by the copyright owner that is
+granting the License, including the persons or entities that may have rights in the Model and/or
+distributing the Model.
+(i) "You" (or "Your") means an individual or Legal Entity exercising permissions granted by this
+License and/or making use of the Model for whichever purpose and in any field of use, including
+usage of the Model in an end-use application - e.g. chatbot, translator, image generator.
+(j) “Third Parties” means individuals or legal entities that are not under common control with
+Licensor or You.
+(k) "Contribution" means any work of authorship, including the original version of the Model and
+any modifications or additions to that Model or Derivatives of the Model thereof, that is
+intentionally submitted to Licensor for inclusion in the Model by the copyright owner or by an
+individual or Legal Entity authorized to submit on behalf of the copyright owner. For the
+purposes of this definition,
+“submitted” means any form of electronic, verbal, or written
+communication sent to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and issue tracking
+systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and
+improving the Model, but excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+(l) "Contributor" means Licensor and any individual or Legal Entity on behalf of whom a
+Contribution has been received by Licensor and subsequently incorporated within the Model.
+
+
+Section II: INTELLECTUAL PROPERTY RIGHTS
+
+Both copyright and patent grants apply to the Model, Derivatives of the Model and Complementary
+Material. The Model and Derivatives of the Model are subject to additional terms as described in Section III.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor
+hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare, publicly display, publicly perform, sublicense, and distribute the
+Complementary Material, the Model, and Derivatives of the Model.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License and where and as
+applicable, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable (except as stated in this paragraph) patent license to make, have made, use, offer
+to sell, sell, import, and otherwise transfer the Model and the Complementary Material, where such
+license applies only to those patent claims licensable by such Contributor that are necessarily infringed by
+their Contribution(s) alone or by combination of their Contribution(s) with the Model to which such
+Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim
+or counterclaim in a lawsuit) alleging that the Model and/or Complementary Material or a Contribution
+incorporated within the Model and/or Complementary Material constitutes direct or contributory patent
+infringement, then any patent licenses granted to You under this License for the Model and/or Work shall
+terminate as of the date such litigation is asserted or filed.
+Section III: CONDITIONS OF USAGE, DISTRIBUTION AND REDISTRIBUTION
+
+4. Distribution and Redistribution. You may host for Third Party remote access purposes (e.g.
+software-as-a-service), reproduce and distribute copies of the Model or Derivatives of the Model thereof
+in any medium, with or without modifications, provided that You meet the following conditions:
+
+a. Use-based restrictions as referenced in paragraph 5 MUST be included as an enforceable provision
+by You in any type of legal agreement (e.g. a license) governing the use and/or distribution of the
+Model or Derivatives of the Model, and You shall give notice to subsequent users You Distribute to,
+that the Model or Derivatives of the Model are subject to paragraph 5. This provision does not apply
+to the use of Complementary Material.
+
+b. You must give any Third Party recipients of the Model or Derivatives of the Model a copy of this
+License;
+
+c. You must cause any modified files to carry prominent notices stating that You changed the files;
+
+d. You must retain all copyright, patent, trademark, and attribution notices excluding those notices
+that do not pertain to any part of the Model, Derivatives of the Model.
+You may add Your own copyright statement to Your modifications and may provide additional or
+different license terms and conditions - respecting paragraph 4.a.
+- for use, reproduction, or Distribution
+of Your modifications, or for any such Derivatives of the Model as a whole, provided Your use,
+reproduction, and Distribution of the Model otherwise complies with the conditions stated in this License.
+
+5. Use-based restrictions. The restrictions set forth in Attachment A are considered Use-based restrictions.
+Therefore You cannot use the Model and the Derivatives of the Model for the specified restricted uses. You
+may use the Model subject to this License, including only for lawful purposes and in accordance with the
+License. Use may include creating any content with, finetuning, updating, running, training, evaluating and/or
+reparametrizing the Model. You shall require all of Your users who use the Model or a Derivative of the Model
+to comply with the terms of this paragraph (paragraph 5).
+
+6. The Output You Generate. Except as set forth herein, Licensor claims no rights in the Output You
+generate using the Model. You are accountable for the Output you generate and its subsequent uses. No
+use of the output can contravene any provision as stated in the License.
+
+Section IV: OTHER PROVISIONS
+
+7. Updates and Runtime Restrictions. To the maximum extent permitted by law, Licensor reserves the
+right to restrict (remotely or otherwise) usage of the Model in violation of this License, update the Model
+through electronic means, or modify the Output of the Model based on updates. You shall undertake
+reasonable efforts to use the latest version of the Model.
+
+8. Trademarks and related. Nothing in this License permits You to make use of Licensors’ trademarks,
+trade names, logos or to otherwise suggest endorsement or misrepresent the relationship between the
+parties; and any rights not expressly granted herein are reserved by the Licensors.
+
+9. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides
+the Model and the Complementary Material (and each Contributor provides its Contributions) on an "AS
+IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY , or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for
+determining the appropriateness of using or redistributing the Model, Derivatives of the Model, and the
+Complementary Material and assume any risks associated with Your exercise of permissions under this
+License.
+
+10. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or
+agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect,
+special, incidental, or consequential damages of any character arising as a result of this License or out of
+the use or inability to use the Model and the Complementary Material (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other
+commercial damages or losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+11. Accepting Warranty or Additional Liability. While redistributing the Model, Derivatives of the
+Model and the Complementary Material thereof, You may choose to offer, and charge a fee for, acceptance
+of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License.
+However, in accepting such obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and
+hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor
+by reason of your accepting any such warranty or additional liability.
+
+12. If any provision of this License is held to be invalid, illegal or unenforceable, the remaining
+provisions shall be unaffected thereby and remain valid as if such provision had not been set forth herein.
+
+END OF TERMS AND CONDITIONS
+
+Attachment A
+
+Use Restrictions
+
+You agree not to use the Model or Derivatives of the Model:
+(a) In any way that violates any applicable national, federal, state, local or international law
+or regulation;
+(b) For the purpose of exploiting, harming or attempting to exploit or harm minors in any
+way;
+(c) To generate or disseminate verifiably false information and/or content with the purpose of
+harming others;
+(d) To generate or disseminate personal identifiable information that can be used to harm an
+individual;
+(e) To generate or disseminate information and/or content (e.g. images, code, posts, articles),
+and place the information and/or content in any context (e.g. bot generating tweets)
+without expressly and intelligibly disclaiming that the information and/or content is
+machine generated;
+(f) To defame, disparage or otherwise harass others;
+(g) To impersonate or attempt to impersonate (e.g. deepfakes) others without their consent;
+(h) For fully automated decision making that adversely impacts an individual’s legal rights or
+otherwise creates or modifies a binding, enforceable obligation;
+(i) For any use intended to or which has the effect of discriminating against or harming
+individuals or groups based on online or offline social behavior or known or predicted
+personal or personality characteristics;
+(j) To exploit any of the vulnerabilities of a specific group of persons based on their age,
+social, physical or mental characteristics, in order to materially distort the behavior of a
+person pertaining to that group in a manner that causes or is likely to cause that person or
+another person physical or psychological harm;
+(k) For any use intended to or which has the effect of discriminating against individuals or
+groups based on legally protected characteristics or categories;
+(l) To provide medical advice and medical results interpretation;
+(m) To generate or disseminate information for the purpose to be used for administration of
+justice, law enforcement, immigration or asylum processes, such as predicting an
+individual will commit fraud/crime commitment (e.g. by text profiling, drawing causal
+relationships between assertions made in documents, indiscriminate and
+arbitrarily-targeted use).

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "react-native-tts-kit",
+  "version": "0.1.0",
+  "description": "On-device neural TTS for React Native and Expo. Multi-engine, sub-second TTFA, 31 languages, fully offline.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "jest",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "tts",
+    "text-to-speech",
+    "speech",
+    "speech-synthesis",
+    "supertonic",
+    "neural-tts",
+    "on-device",
+    "offline",
+    "offline-first",
+    "voice",
+    "ai",
+    "onnx",
+    "onnxruntime",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ahk-d/react-native-tts-kit"
+  },
+  "bugs": {
+    "url": "https://github.com/ahk-d/react-native-tts-kit/issues"
+  },
+  "author": "ahk-d",
+  "license": "MIT",
+  "homepage": "https://github.com/ahk-d/react-native-tts-kit",
+  "files": [
+    "build",
+    "src",
+    "ios",
+    "android",
+    "licenses",
+    "expo-module.config.json",
+    "RNTTSKit.podspec",
+    "ATTRIBUTIONS.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "expo": ">=51.0.0",
+    "expo-modules-core": ">=1.12.0",
+    "react": ">=18.2.0",
+    "react-native": ">=0.74.0"
+  },
+  "peerDependenciesMeta": {
+    "expo-speech": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "~19.0.10",
+    "expo-module-scripts": "^4.0.0",
+    "expo-modules-core": "~2.5.0",
+    "expo-speech": "~13.1.0",
+    "react": "19.0.0",
+    "react-native": "0.79.5",
+    "typescript": "~5.8.3"
+  }
+}

package/src/engines/BufferedStreamEmitter.ts

@@ -0,0 +1,50 @@
+/**
+ * Per-stream emitter that buffers events emitted before any listener attaches.
+ *
+ * The native side of `stream()` starts producing chunks the moment we kick it
+ * off, but the JS caller usually attaches `.on('chunk')` immediately after —
+ * there's a small async gap. Without buffering, early chunks would be silently
+ * dropped. Once a listener is attached, queued events drain to it.
+ *
+ * This class is exported separately from SupertonicEngine so it can be unit
+ * tested without needing the native module to load.
+ */
+export class BufferedStreamEmitter {
+  private chunkListeners: Array<(pcm: Uint8Array) => void> = [];
+  private endListeners: Array<() => void> = [];
+  private errorListeners: Array<(err: Error) => void> = [];
+  private pendingChunks: Uint8Array[] = [];
+  private pendingEnd = false;
+  private pendingError: Error | null = null;
+
+  on(event: 'chunk', listener: (pcm: Uint8Array) => void): void;
+  on(event: 'end', listener: () => void): void;
+  on(event: 'error', listener: (err: Error) => void): void;
+  on(event: 'chunk' | 'end' | 'error', listener: (...args: any[]) => void): void {
+    if (event === 'chunk') {
+      this.chunkListeners.push(listener);
+      const drained = this.pendingChunks;
+      this.pendingChunks = [];
+      for (const pcm of drained) listener(pcm);
+    } else if (event === 'end') {
+      this.endListeners.push(listener);
+      if (this.pendingEnd) { this.pendingEnd = false; listener(); }
+    } else if (event === 'error') {
+      this.errorListeners.push(listener);
+      if (this.pendingError) { const e = this.pendingError; this.pendingError = null; listener(e); }
+    }
+  }
+
+  emitChunk(pcm: Uint8Array): void {
+    if (this.chunkListeners.length === 0) { this.pendingChunks.push(pcm); return; }
+    for (const l of this.chunkListeners) l(pcm);
+  }
+  emitEnd(): void {
+    if (this.endListeners.length === 0) { this.pendingEnd = true; return; }
+    for (const l of this.endListeners) l();
+  }
+  emitError(err: Error): void {
+    if (this.errorListeners.length === 0) { this.pendingError = err; return; }
+    for (const l of this.errorListeners) l(err);
+  }
+}

package/src/engines/Engine.ts

@@ -0,0 +1,28 @@
+import type {
+  ClonedVoice,
+  CloneOptions,
+  EngineCapabilities,
+  EngineId,
+  PrefetchProgress,
+  SpeakOptions,
+  StreamHandle,
+  Voice,
+} from '../types';
+
+export interface Engine {
+  readonly id: EngineId;
+  readonly capabilities: EngineCapabilities;
+
+  isAvailable(): Promise<boolean>;
+  prefetch(onProgress?: (p: PrefetchProgress) => void): Promise<void>;
+
+  getVoices(): Promise<Voice[]>;
+  speak(text: string, options?: SpeakOptions): Promise<void>;
+  stream(text: string, options?: SpeakOptions): StreamHandle;
+  stop(): Promise<void>;
+
+  /** Delete any locally cached model files so the next prefetch re-downloads. */
+  clearCache?(): Promise<void>;
+
+  cloneVoice?(options: CloneOptions): Promise<ClonedVoice>;
+}

package/src/engines/SupertonicEngine.ts

@@ -0,0 +1,250 @@
+import { requireNativeModule } from 'expo-modules-core';
+import { Platform } from 'react-native';
+
+import type {
+  EngineCapabilities,
+  EngineId,
+  PrefetchProgress,
+  SpeakOptions,
+  StreamHandle,
+  Voice,
+} from '../types';
+
+// iOS has CoreML/ANE fp16 acceleration; even an 8-step diffusion takes ~1s.
+// Android relies on NNAPI + commodity SoCs (e.g. Snapdragon 720G in mid-tier
+// phones) and tops out around 1-1.2s per diffusion step at fp32, so 8 steps
+// stretches synthesis to 10-14s. Supertonic-3 was trained for 2-8 step
+// inference; 6 steps is the quality/speed sweet spot on Android — audibly
+// closer to 8-step than to 4-step, while still ~25% faster than 8.
+// Callers can override per-call via SpeakOptions.totalStep.
+const DEFAULT_TOTAL_STEP = Platform.OS === 'android' ? 6 : 8;
+import { BufferedStreamEmitter } from './BufferedStreamEmitter';
+import {
+  DEFAULT_LANGUAGE,
+  DEFAULT_VOICE_ID,
+  SUPERTONIC_LANGUAGES,
+  SUPERTONIC_VOICES,
+  findVoice,
+} from '../voices/catalog';
+import { stripProsody } from '../voices/prosody';
+import type { Engine } from './Engine';
+
+type Subscription = { remove(): void };
+type ChunkPayload = { id: string; pcm: string };
+type IdPayload = { id: string };
+type ErrorPayload = { id: string; message: string };
+
+interface TTSKitNative {
+  isAvailable(): Promise<boolean>;
+  prefetch(): Promise<void>;
+  speak(
+    id: string,
+    text: string,
+    voiceId: string,
+    lang: string,
+    totalStep: number,
+    speed: number,
+    volume: number
+  ): Promise<void>;
+  stream(
+    id: string,
+    text: string,
+    voiceId: string,
+    lang: string,
+    totalStep: number,
+    speed: number,
+    volume: number
+  ): Promise<void>;
+  stop(): Promise<void>;
+  clearCache(): Promise<void>;
+  addListener(name: string, listener: (event: any) => void): Subscription;
+}
+
+let nativeModule: TTSKitNative | null = null;
+function getNative(): TTSKitNative {
+  if (!nativeModule) {
+    nativeModule = requireNativeModule<TTSKitNative>('RNTTSKit');
+  }
+  return nativeModule;
+}
+
+let counter = 0;
+const newId = () => `op_${Date.now().toString(36)}_${(++counter).toString(36)}`;
+
+function decodeBase64(b64: string): Uint8Array {
+  if (typeof atob === 'function') {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  const lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  const cleaned = b64.replace(/=+$/, '');
+  const out = new Uint8Array((cleaned.length * 3) >> 2);
+  let o = 0;
+  for (let i = 0; i < cleaned.length; i += 4) {
+    const a = lookup.indexOf(cleaned[i]);
+    const b = lookup.indexOf(cleaned[i + 1]);
+    const c = lookup.indexOf(cleaned[i + 2] ?? 'A');
+    const d = lookup.indexOf(cleaned[i + 3] ?? 'A');
+    out[o++] = (a << 2) | (b >> 4);
+    if (cleaned[i + 2]) out[o++] = ((b & 15) << 4) | (c >> 2);
+    if (cleaned[i + 3]) out[o++] = ((c & 3) << 6) | d;
+  }
+  return out.subarray(0, o);
+}
+
+// BufferedStreamEmitter is exported from its own module so we can unit-test
+// it without needing the native module to load. See ./BufferedStreamEmitter.ts
+
+function resolveLang(options: SpeakOptions): string {
+  const lang = options.language ?? DEFAULT_LANGUAGE;
+  if (!SUPERTONIC_LANGUAGES.includes(lang)) {
+    throw new Error(`[ttskit] Unsupported language for Supertonic: ${lang}`);
+  }
+  return lang;
+}
+
+export class SupertonicEngine implements Engine {
+  readonly id: EngineId = 'supertonic';
+  readonly capabilities: EngineCapabilities = {
+    streaming: true,
+    cloning: false,
+    emotionTags: false,
+    offline: true,
+    languages: [...SUPERTONIC_LANGUAGES],
+  };
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      return await getNative().isAvailable();
+    } catch {
+      return false;
+    }
+  }
+
+  async prefetch(onProgress?: (p: PrefetchProgress) => void): Promise<void> {
+    const native = getNative();
+    const sub = onProgress
+      ? native.addListener('onPrefetchProgress', (e: PrefetchProgress) => onProgress(e))
+      : null;
+    try {
+      await native.prefetch();
+    } finally {
+      sub?.remove();
+    }
+  }
+
+  async getVoices(): Promise<Voice[]> {
+    return SUPERTONIC_VOICES;
+  }
+
+  async speak(text: string, options: SpeakOptions = {}): Promise<void> {
+    const voiceId = options.voice ?? DEFAULT_VOICE_ID;
+    if (!findVoice(voiceId)) throw new Error(`[ttskit] Unknown voice: ${voiceId}`);
+    const lang = resolveLang(options);
+    const id = newId();
+    const native = getNative();
+    const cleanText = stripProsody(text);
+
+    const subs: Subscription[] = [];
+    if (options.onStart) {
+      subs.push(native.addListener('onSpeakStart', (e: IdPayload) => {
+        if (e.id === id) options.onStart?.();
+      }));
+    }
+    if (options.onDone) {
+      subs.push(native.addListener('onSpeakDone', (e: IdPayload) => {
+        if (e.id === id) options.onDone?.();
+      }));
+    }
+    try {
+      await native.speak(
+        id,
+        cleanText,
+        voiceId,
+        lang,
+        options.totalStep ?? DEFAULT_TOTAL_STEP,
+        options.rate ?? 1.05,
+        options.volume ?? 1
+      );
+    } catch (err) {
+      options.onError?.(err as Error);
+      throw err;
+    } finally {
+      subs.forEach((s) => s.remove());
+    }
+  }
+
+  stream(text: string, options: SpeakOptions = {}): StreamHandle {
+    const voiceId = options.voice ?? DEFAULT_VOICE_ID;
+    if (!findVoice(voiceId)) throw new Error(`[ttskit] Unknown voice: ${voiceId}`);
+    const lang = resolveLang(options);
+
+    const id = newId();
+    const native = getNative();
+    const emitter = new BufferedStreamEmitter();
+    const cleanText = stripProsody(text);
+    let cleanedUp = false;
+
+    const chunkSub = native.addListener('onStreamChunk', (e: ChunkPayload) => {
+      if (e.id !== id) return;
+      emitter.emitChunk(decodeBase64(e.pcm));
+    });
+    const endSub = native.addListener('onStreamEnd', (e: IdPayload) => {
+      if (e.id !== id) return;
+      emitter.emitEnd();
+      cleanup();
+    });
+    const errSub = native.addListener('onStreamError', (e: ErrorPayload) => {
+      if (e.id !== id) return;
+      emitter.emitError(new Error(e.message));
+      cleanup();
+    });
+
+    function cleanup() {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      chunkSub.remove();
+      endSub.remove();
+      errSub.remove();
+    }
+
+    native
+      .stream(
+        id,
+        cleanText,
+        voiceId,
+        lang,
+        options.totalStep ?? DEFAULT_TOTAL_STEP,
+        options.rate ?? 1.05,
+        options.volume ?? 1
+      )
+      .catch((err: Error) => {
+        emitter.emitError(err);
+        cleanup();
+      });
+
+    const handle: StreamHandle = {
+      id,
+      on(event: 'chunk' | 'end' | 'error', listener: (...args: any[]) => void) {
+        // @ts-expect-error: emitter has overloaded signatures, runtime forwards correctly
+        emitter.on(event, listener);
+        return handle;
+      },
+      async cancel() {
+        cleanup();
+        await native.stop();
+      },
+    };
+    return handle;
+  }
+
+  async stop(): Promise<void> {
+    await getNative().stop();
+  }
+
+  async clearCache(): Promise<void> {
+    await getNative().clearCache();
+  }
+}