edge-tts-rs-node 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 edge-tts-rs-node contributors
+Copyright (c) 2026 edge-tts-rust contributors
+
+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

@@ -1,3 +1,203 @@
-# Temporary Holding Version
+# edge-tts-rs-node
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+把 Rust 的 [`edge-tts-rust`](https://crates.io/crates/edge-tts-rust) 封装成 Node.js / Electron 主进程可直接调用的 N-API 原生扩展。
+
+对外 API 与 [`node-edge-tts`](https://www.npmjs.com/package/node-edge-tts) 保持一致，可以按同样的方式 `new EdgeTTS(options)`，调用 `ttsPromise`、`toBuffer`、`streamAudio`、`getVoices`。
+
+- 原生实现来自 `edge-tts-rust`（Rust + tokio + rustls），Node 侧只做一层薄包装。
+- N-API（Node-API）ABI 稳定，**Electron 下不需要 `electron-rebuild`**。
+- 复用 Rust 侧的连接池：同一个 `EdgeTTS` 实例的多次请求会复用已预热的 WebSocket。
+- 支持流式合成、逐词字幕时间戳、语音列表。
+
+---
+
+## 目录结构
+
+```
+src/lib.rs        # N-API 绑定（Rust）
+index.js          # EdgeTTS 类，node-edge-tts 兼容层
+index.d.ts        # 对外类型定义
+native.js         # napi build 生成的加载器（提交到仓库）
+test/index.js     # 与 node-edge-tts 测试文件等价的联网测试
+test/smoke.js     # 不联网的冒烟测试
+.cargo/config.toml# 国内 crates 镜像（不需要时可删除）
+```
+
+## 构建
+
+前置条件：
+
+- Node.js >= 18
+- Rust 工具链（`rustup`，Windows 使用 `stable-x86_64-pc-windows-msvc`）
+- Windows：Visual Studio Build Tools（含 “使用 C++ 的桌面开发”）；macOS：Xcode Command Line Tools；Linux：`gcc`/`clang` 等
+
+```bash
+npm install
+npm run build          # 等价于 napi build --platform --release --js native.js --dts native.d.ts
+npm run test:smoke     # 不联网，验证扩展可加载
+npm test               # 联网合成 test/test.mp3 和 test/test.mp3.json
+```
+
+Windows 上会生成 `edge-tts-rs-node.win32-x64-msvc.node`。
+
+> 国内网络下 `crates.io` 直连可能超时。仓库内的 `.cargo/config.toml` 已把 Cargo 源指向 `rsproxy.cn`，不需要时删除该文件即可。
+
+## 快速开始
+
+和 `node-edge-tts` 完全一致的用法：
+
+```js
+const path = require('node:path')
+const { EdgeTTS } = require('edge-tts-rs-node')
+
+const tts = new EdgeTTS({
+  outputFormat: 'audio-24khz-96kbitrate-mono-mp3',
+  saveSubtitles: true,
+  timeout: 10000,
+})
+
+await tts.ttsPromise('你好，世界', path.join(__dirname, 'output.mp3'))
+await tts.close()
+```
+
+`saveSubtitles: true` 时会额外写出 `output.mp3.json`：
+
+```json
+[
+  { "part": "你好", "start": 100, "end": 500 },
+  { "part": "，世界", "start": 500, "end": 1200 }
+]
+```
+
+`start` / `end` 单位是毫秒。
+
+## API
+
+### `new EdgeTTS(options?)`
+
+| 选项 | 类型 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| `voice` | `string` | `zh-CN-XiaoyiNeural` | 语音短名或完整 Microsoft voice 标识 |
+| `lang` | `string` | `zh-CN` | 仅为兼容 `node-edge-tts` 保留；实际语言由 `voice` 决定 |
+| `outputFormat` | `string` | `audio-24khz-48kbitrate-mono-mp3` | 输出格式，如 `audio-24khz-96kbitrate-mono-mp3`、`webm-24khz-16bit-mono-opus` |
+| `saveSubtitles` | `boolean` | `false` | `ttsPromise` 是否写 `.json` 字幕；`streamAudio` 是否产出字幕对象 |
+| `rate` | `string` | `default` | 语速，如 `+10%`、`-10%` |
+| `pitch` | `string` | `default` | 音调，如 `+10Hz`、`-10Hz` |
+| `volume` | `string` | `default` | 音量，如 `+10%`、`-50%` |
+| `timeout` | `number` | `10000` | WebSocket 连接超时（毫秒） |
+| `receiveTimeout` | `number` | `60000` | 单帧接收超时（毫秒） |
+| `wsPoolSize` | `number` | `1` | 保持预热的空闲 WebSocket 数量；设为 `0` 关闭连接池 |
+| `proxy` | `string` | — | **暂不支持**，传入会直接报错（见“与 node-edge-tts 的差异”） |
+
+### `ttsPromise(text, audioPath): Promise<void>`
+
+合成文本并写入 `audioPath`。开启 `saveSubtitles` 时同时写入 `${audioPath}.json`。
+
+### `toBuffer(text): Promise<Buffer>`
+
+合成并返回音频 Buffer，不落盘。
+
+### `streamAudio(text): AsyncGenerator<Buffer | SubtitleCue>`
+
+边接收边产出：
+
+- `Buffer`：音频分片；
+- `{ part, start, end }`：逐词时间戳（仅当 `saveSubtitles: true`）。
+
+提前 `break` 会取消请求并关闭 WebSocket：
+
+```js
+const tts = new EdgeTTS({ voice: 'en-US-AriaNeural', saveSubtitles: true })
+
+for await (const chunk of tts.streamAudio('Hello world')) {
+  if (Buffer.isBuffer(chunk)) {
+    process.stdout.write(chunk)
+  } else {
+    console.error(chunk) // { part: 'Hello', start: 100, end: 487 }
+  }
+}
+
+await tts.close()
+```
+
+### `getVoices(): Promise<Voice[]>` / `listVoices()`
+
+返回 Edge Read Aloud 的语音列表（Microsoft 原始字段：`Name`、`ShortName`、`Gender`、`Locale` 等，另有 `VoiceTag`）。
+
+### `close(): Promise<void>`
+
+释放原生客户端与连接池。建议在应用退出或不再使用时调用；实例被 GC 时也会兜底关闭。
+
+## Electron 主进程
+
+N-API 是 ABI 稳定的，同一个 `.node` 文件可以在 Node 与 Electron 中直接加载，无需为 Electron 重新编译。
+
+```js
+// electron 主进程
+const { app, ipcMain } = require('electron')
+const path = require('node:path')
+const { EdgeTTS } = require('edge-tts-rs-node')
+
+const tts = new EdgeTTS({ voice: 'zh-CN-XiaoyiNeural' })
+
+ipcMain.handle('tts:save', async (_event, text) => {
+  const file = path.join(app.getPath('userData'), `tts-${Date.now()}.mp3`)
+  await tts.ttsPromise(text, file)
+  return file
+})
+
+app.on('before-quit', () => {
+  tts.close()
+})
+```
+
+### 打包注意事项
+
+原生模块不能从 `asar` 包内直接 `dlopen`，需要解包：
+
+```jsonc
+// electron-builder
+"build": {
+  "asarUnpack": ["**/*.node"]
+}
+```
+
+`electron-forge` 同理，将 `**/*.node` 加入 `packagerConfig.asar.unpack`。
+
+Node 侧版本要求：Electron 12+ / Node 14+ 均支持 N-API 8；本包 `engines` 标为 Node >= 18。
+
+## 多平台分发
+
+当前仓库的 `npm run build` 只构建当前平台。发布到 npm 并支持多平台时，可以使用 napi-rs 的平台子包方案：
+
+1. 在各平台（或 CI）分别执行 `napi build --platform --release`；
+2. 用 `napi create-npm-dirs` / 官方 GitHub Actions 模板生成 `edge-tts-rs-node-win32-x64-msvc` 等平台包；
+3. `native.js` 会自动按 `process.platform` / `process.arch` 选择本地文件或平台包。
+
+## 与 `node-edge-tts` 的差异
+
+| 项目 | 说明 |
+| --- | --- |
+| `proxy` | `edge-tts-rust 0.1.7` 没有代理支持，传入 `proxy` 会抛出明确的错误。如需代理，需要给 Rust crate 增加代理连接（HTTP CONNECT + TLS 隧道）后重新封装。 |
+| `lang` | 仅保存，不参与 SSML 生成；语言由 `voice` 的 locale 决定，因此请保证两者匹配。 |
+| `timeout` | 语义为连接超时；另外提供 `receiveTimeout` 控制单帧接收。`node-edge-tts` 的 `timeout` 是整体超时。 |
+| `ttsPromise` | 内部一次性合成后写盘，音频会在内存中聚合。超长文本建议改用 `streamAudio` 边收边写。 |
+| 字幕 | 使用 Rust 侧返回的逐词边界并补齐原文空白/标点，输出格式与 `node-edge-tts` 的 `.json` 一致。 |
+| 错误 | 统一为 `Error`，消息带 `EdgeTTS:` 前缀。 |
+| 语音列表 | `getVoices()` 返回数组，字段为 Microsoft 原始命名（`ShortName` 等）。 |
+
+## 实现说明
+
+Rust 侧（`src/lib.rs`）提供：
+
+- `createClient` / `closeClient`：客户端生命周期与连接池；
+- `synthesize`：一次性合成，返回 `{ audio, boundaries }`；
+- `listVoices`：语音列表；
+- `startStream` / `cancelStream`：通过 `ThreadsafeFunction` 把流式事件推回 JS，支持提前取消；
+- `normalizeVoice` / `defaultExtensionForFormat`：与 crate 行为一致的工具函数。
+
+异步任务运行在 napi-rs 内置的 tokio runtime 上（`tokio_rt` feature）。流式事件通过 TSFN 按序回调，JS 包装层再转成 `AsyncGenerator`。
+
+## License
+
+MIT。底层 [`edge-tts-rust`](https://github.com/initsnow/edge-tts-rust) 同样为 MIT。

package/index.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" />
+
+export interface EdgeTTSOptions {
+  /** Voice short name or full Microsoft voice identifier. Default: `zh-CN-XiaoyiNeural`. */
+  voice?: string
+  /** Kept for `node-edge-tts` compatibility. The effective language comes from `voice`. */
+  lang?: string
+  /** Audio output format. Default: `audio-24khz-48kbitrate-mono-mp3`. */
+  outputFormat?: string
+  /** Write `${audioPath}.json` word-boundary subtitles from `ttsPromise`. Default: `false`. */
+  saveSubtitles?: boolean
+  /** Not supported by edge-tts-rust 0.1.7; passing one rejects with an error. */
+  proxy?: string
+  /** Rate, for example `+10%` / `-10%` / `default`. */
+  rate?: string
+  /** Pitch, for example `+10Hz` / `-10Hz` / `default`. */
+  pitch?: string
+  /** Volume, for example `+10%` / `-50%` / `default`. */
+  volume?: string
+  /** WebSocket connect timeout in milliseconds. Default: `10000`. */
+  timeout?: number
+  /** Per-frame receive timeout in milliseconds. Default: `60000`. */
+  receiveTimeout?: number
+  /** Idle WebSocket connections kept warm between requests. Default: `1`. */
+  wsPoolSize?: number
+}
+
+export interface SubtitleCue {
+  part: string
+  /** Milliseconds from the start of the audio. */
+  start: number
+  /** Milliseconds from the start of the audio. */
+  end: number
+}
+
+export interface Voice {
+  Name: string
+  ShortName: string
+  Gender: string
+  Locale: string
+  SuggestedCodec?: string
+  FriendlyName?: string
+  Status?: string
+  VoiceTag?: {
+    ContentCategories?: string[]
+    VoicePersonalities?: string[]
+  }
+  [key: string]: unknown
+}
+
+export declare class EdgeTTS {
+  constructor(options?: EdgeTTSOptions)
+
+  voice: string
+  lang: string
+  outputFormat: string
+  saveSubtitles: boolean
+  rate: string
+  pitch: string
+  volume: string
+  proxy?: string
+  timeout: number
+  receiveTimeout: number
+  wsPoolSize: number
+
+  /** Synthesize `text` and return the audio bytes. */
+  toBuffer(text: string): Promise<Buffer>
+
+  /** Synthesize `text` to `audioPath`, optionally writing `${audioPath}.json` subtitles. */
+  ttsPromise(text: string, audioPath: string): Promise<void>
+
+  /** List the voices served by the Edge Read Aloud endpoint. */
+  getVoices(): Promise<Voice[]>
+
+  /** Alias of `getVoices`. */
+  listVoices(): Promise<Voice[]>
+
+  /**
+   * Stream audio chunks and, when `saveSubtitles` is enabled, word boundary
+   * cues. Break out of the loop to stop the request.
+   */
+  streamAudio(text: string): AsyncGenerator<Buffer | SubtitleCue, void, undefined>
+
+  /** Release the native client and its pooled WebSocket connections. */
+  close(): Promise<void>
+}
+
+export default EdgeTTS

package/index.js

@@ -0,0 +1,293 @@
+'use strict'
+
+const fs = require('node:fs/promises')
+const native = require('./native.js')
+
+const DEFAULT_OPTIONS = {
+  voice: 'zh-CN-XiaoyiNeural',
+  lang: 'zh-CN',
+  outputFormat: 'audio-24khz-48kbitrate-mono-mp3',
+  saveSubtitles: false,
+  rate: 'default',
+  pitch: 'default',
+  volume: 'default',
+  timeout: 10000,
+  receiveTimeout: 60000,
+  wsPoolSize: 1,
+}
+
+const clientFinalizer =
+  typeof FinalizationRegistry === 'function'
+    ? new FinalizationRegistry((clientId) => {
+        try {
+          native.closeClient(clientId)
+        } catch {
+          // The environment is already tearing down.
+        }
+      })
+    : null
+
+/**
+ * Drop-in style replacement for `node-edge-tts`, backed by the Rust
+ * `edge-tts-rust` crate.
+ */
+class EdgeTTS {
+  constructor(options = {}) {
+    const opts = options || {}
+
+    this.voice = opts.voice ?? DEFAULT_OPTIONS.voice
+    this.lang = opts.lang ?? DEFAULT_OPTIONS.lang
+    this.outputFormat = opts.outputFormat ?? DEFAULT_OPTIONS.outputFormat
+    this.saveSubtitles = Boolean(opts.saveSubtitles)
+    this.rate = opts.rate ?? DEFAULT_OPTIONS.rate
+    this.pitch = opts.pitch ?? DEFAULT_OPTIONS.pitch
+    this.volume = opts.volume ?? DEFAULT_OPTIONS.volume
+    this.proxy = opts.proxy
+    this.timeout = opts.timeout ?? DEFAULT_OPTIONS.timeout
+    this.receiveTimeout = opts.receiveTimeout ?? DEFAULT_OPTIONS.receiveTimeout
+    this.wsPoolSize = opts.wsPoolSize ?? DEFAULT_OPTIONS.wsPoolSize
+
+    this._clientId = null
+    this._clientPromise = null
+    this._closed = false
+  }
+
+  _nativeCreateOptions() {
+    return {
+      proxy: this.proxy,
+      connectTimeoutMs: Math.max(1, Math.floor(Number(this.timeout) || 0)),
+      receiveTimeoutMs: Math.max(1, Math.floor(Number(this.receiveTimeout) || 0)),
+      wsPoolSize: Math.max(0, Math.floor(Number(this.wsPoolSize) || 0)),
+    }
+  }
+
+  _speakOptions() {
+    return {
+      voice: this.voice,
+      rate: this.rate,
+      volume: this.volume,
+      pitch: this.pitch,
+      outputFormat: this.outputFormat,
+      boundary: 'word',
+    }
+  }
+
+  async _ensureClient() {
+    if (this._closed) {
+      throw new Error('EdgeTTS: instance has already been closed')
+    }
+    if (this._clientId !== null) {
+      return this._clientId
+    }
+    if (!this._clientPromise) {
+      this._clientPromise = native
+        .createClient(this._nativeCreateOptions())
+        .then((clientId) => {
+          if (this._closed) {
+            native.closeClient(clientId)
+            throw new Error('EdgeTTS: instance has already been closed')
+          }
+          this._clientId = clientId
+          if (clientFinalizer) {
+            clientFinalizer.register(this, clientId, this)
+          }
+          return clientId
+        })
+        .finally(() => {
+          this._clientPromise = null
+        })
+    }
+    return this._clientPromise
+  }
+
+  async _synthesize(text) {
+    if (typeof text !== 'string') {
+      throw new TypeError('EdgeTTS: text must be a string')
+    }
+    const clientId = await this._ensureClient()
+    const result = await native.synthesize(clientId, text, this._speakOptions())
+    return {
+      audio: result.audio,
+      boundaries: result.boundaries || [],
+    }
+  }
+
+  /**
+   * Synthesize `text` and return the audio as a Buffer.
+   * @param {string} text
+   * @returns {Promise<Buffer>}
+   */
+  async toBuffer(text) {
+    const { audio } = await this._synthesize(text)
+    return audio
+  }
+
+  /**
+   * Synthesize `text` into `audioPath`. When `saveSubtitles` is enabled a
+   * `${audioPath}.json` file is written next to the audio, matching
+   * `node-edge-tts`.
+   * @param {string} text
+   * @param {string} audioPath
+   * @returns {Promise<void>}
+   */
+  async ttsPromise(text, audioPath) {
+    const { audio, boundaries } = await this._synthesize(text)
+    await fs.writeFile(audioPath, audio)
+
+    if (this.saveSubtitles) {
+      const subtitles = correctSubtitleParts(
+        boundaries.map(({ part, start, end }) => ({ part, start, end })),
+        text,
+      )
+      await fs.writeFile(
+        `${audioPath}.json`,
+        JSON.stringify(subtitles, null, '  '),
+        'utf-8',
+      )
+    }
+  }
+
+  /**
+   * List the voices offered by the Edge service.
+   * @returns {Promise<Array<object>>}
+   */
+  async getVoices() {
+    const clientId = await this._ensureClient()
+    return native.listVoices(clientId)
+  }
+
+  /** Alias of `getVoices`. */
+  async listVoices() {
+    return this.getVoices()
+  }
+
+  /**
+   * Stream audio chunks and (when `saveSubtitles` is enabled) word boundary
+   * cues as they arrive. Yields `Buffer` objects and
+   * `{ part, start, end }` objects.
+   * @param {string} text
+   * @returns {AsyncGenerator<Buffer | { part: string, start: number, end: number }>}
+   */
+  async *streamAudio(text) {
+    if (typeof text !== 'string') {
+      throw new TypeError('EdgeTTS: text must be a string')
+    }
+    const clientId = await this._ensureClient()
+
+    const queue = []
+    let notify = null
+    let finished = false
+    let failure = null
+
+    const wake = () => {
+      const resolve = notify
+      notify = null
+      if (resolve) resolve()
+    }
+
+    const callback = (error, event) => {
+      if (error) {
+        failure = error instanceof Error ? error : new Error(String(error))
+      } else if (event) {
+        if (event.error) {
+          failure = new Error(event.error)
+        } else if (event.audio) {
+          queue.push(Buffer.from(event.audio))
+        } else if (event.boundary && this.saveSubtitles) {
+          queue.push({
+            part: event.boundary.part,
+            start: event.boundary.start,
+            end: event.boundary.end,
+          })
+        } else if (event.done) {
+          finished = true
+        }
+      }
+      wake()
+    }
+
+    const streamId = await native.startStream(
+      clientId,
+      text,
+      this._speakOptions(),
+      callback,
+    )
+
+    try {
+      while (true) {
+        if (failure) throw failure
+        if (queue.length > 0) {
+          yield queue.shift()
+          continue
+        }
+        if (finished) return
+        await new Promise((resolve) => {
+          notify = resolve
+        })
+      }
+    } finally {
+      if (!finished) {
+        try {
+          native.cancelStream(streamId)
+        } catch {
+          // Already finished.
+        }
+      }
+    }
+  }
+
+  /**
+   * Release the native client and its pooled WebSocket connections.
+   * @returns {Promise<void>}
+   */
+  async close() {
+    this._closed = true
+    if (this._clientPromise) {
+      try {
+        await this._clientPromise
+      } catch {
+        // Creation failed; nothing to release.
+      }
+    }
+    if (this._clientId !== null) {
+      if (clientFinalizer) clientFinalizer.unregister(this)
+      native.closeClient(this._clientId)
+      this._clientId = null
+    }
+  }
+}
+
+/**
+ * `node-edge-tts` reconstructs subtitle cues from the original text so that
+ * skipped whitespace and punctuation end up in the cue. Kept for parity.
+ */
+function correctSubtitleParts(subtitles, text) {
+  if (subtitles.length === 0) return subtitles
+
+  const chars = text.split('')
+  let charIndex = 0
+
+  subtitles.forEach((cue, index) => {
+    let fullPart = ''
+    let stepIndex = 0
+    const nextPart = subtitles[index + 1]?.part
+
+    for (let i = charIndex; i < chars.length; i++) {
+      if (chars[i] === cue.part[stepIndex]) {
+        fullPart += chars[i]
+        stepIndex += 1
+      } else if (nextPart && chars[i] === nextPart[0]) {
+        charIndex = i
+        break
+      } else {
+        fullPart += chars[i]
+      }
+    }
+
+    cue.part = fullPart
+  })
+
+  return subtitles
+}
+
+module.exports = { EdgeTTS, default: EdgeTTS }

package/native.d.ts

@@ -0,0 +1,55 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export interface NativeOptions {
+  voice?: string
+  rate?: string
+  volume?: string
+  pitch?: string
+  outputFormat?: string
+  /** `"word"` (default) or `"sentence"`. */
+  boundary?: string
+  connectTimeoutMs?: number
+  receiveTimeoutMs?: number
+  wsPoolSize?: number
+  proxy?: string
+}
+export interface BoundaryJs {
+  part: string
+  /** Milliseconds from the beginning of the audio. */
+  start: number
+  /** Milliseconds from the beginning of the audio. */
+  end: number
+  /** `"word"` or `"sentence"`. */
+  kind: string
+}
+export interface SynthesisResultJs {
+  audio: Buffer
+  boundaries: Array<BoundaryJs>
+}
+export interface StreamEventJs {
+  audio?: Buffer
+  boundary?: BoundaryJs
+  /** Set when the stream failed. The `done` event still follows. */
+  error?: string
+  done?: boolean
+}
+/**
+ * Create a client. Kept alive until `closeClient` is called (or the process
+ * exits). Reusing one client across requests keeps the warmed WebSocket pool.
+ */
+export declare function createClient(options?: NativeOptions | undefined | null): Promise<number>
+export declare function closeClient(clientId: number): boolean
+export declare function synthesize(clientId: number, text: string, options?: NativeOptions | undefined | null): Promise<SynthesisResultJs>
+export declare function listVoices(clientId: number): Promise<any>
+/**
+ * Start a streaming synthesis. `callback` is invoked as `(err, event)` on the
+ * JavaScript thread. The returned id can be passed to `cancelStream`.
+ */
+export declare function startStream(clientId: number, text: string, options: NativeOptions | undefined | null, callback: (err: Error | null, arg: StreamEventJs) => any): Promise<number>
+/** Cancel an in-flight stream. Returns `false` if it already finished. */
+export declare function cancelStream(streamId: number): boolean
+export declare function normalizeVoice(voice: string): string
+export declare function defaultExtensionForFormat(outputFormat: string): string

package/native.js

@@ -0,0 +1,322 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'edge-tts-rs-node.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.android-arm64.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'edge-tts-rs-node.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'edge-tts-rs-node.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'edge-tts-rs-node.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'edge-tts-rs-node.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'edge-tts-rs-node.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./edge-tts-rs-node.darwin-universal.node')
+      } else {
+        nativeBinding = require('edge-tts-rs-node-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'edge-tts-rs-node.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.darwin-x64.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'edge-tts-rs-node.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.darwin-arm64.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'edge-tts-rs-node.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./edge-tts-rs-node.freebsd-x64.node')
+      } else {
+        nativeBinding = require('edge-tts-rs-node-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'edge-tts-rs-node.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./edge-tts-rs-node.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('edge-tts-rs-node-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'edge-tts-rs-node.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./edge-tts-rs-node.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('edge-tts-rs-node-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { createClient, closeClient, synthesize, listVoices, startStream, cancelStream, normalizeVoice, defaultExtensionForFormat } = nativeBinding
+
+module.exports.createClient = createClient
+module.exports.closeClient = closeClient
+module.exports.synthesize = synthesize
+module.exports.listVoices = listVoices
+module.exports.startStream = startStream
+module.exports.cancelStream = cancelStream
+module.exports.normalizeVoice = normalizeVoice
+module.exports.defaultExtensionForFormat = defaultExtensionForFormat

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "edge-tts-rs-node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Node.js / Electron bindings for the edge-tts-rust crate, with a node-edge-tts compatible API",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "native.js",
+    "native.d.ts",
+    "*.node",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "napi build --platform --release --js native.js --dts native.d.ts",
+    "build:debug": "napi build --platform --js native.js --dts native.d.ts",
+    "test": "node test/index.js",
+    "test:smoke": "node test/smoke.js"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.18.4"
+  },
+  "napi": {
+    "name": "edge-tts-rs-node",
+    "triples": {
+      "defaults": true,
+      "additional": []
+    }
+  },
+  "keywords": [
+    "edge-tts",
+    "tts",
+    "text-to-speech",
+    "rust",
+    "napi",
+    "electron"
+  ]
+}