use-voice-control 0.1.86 → 0.1.87

package/README.md

@@ -26,6 +26,7 @@
     <a href="https://codespaces.new/OpenSourceAGI/qwksearch-research-agent">
     <img src="https://github.com/codespaces/badge.svg" width="150" height="20" />
     </a>
+    <a href="https://codecov.io/gh/OpenSourceAGI/qwksearch-research-agent"><img src="https://codecov.io/gh/OpenSourceAGI/qwksearch-research-agent/graph/badge.svg?component=package-use-voice-control" alt="Coverage" /></a>
 </p>
 
 <p align="center">
@@ -42,6 +43,12 @@ React hooks and components for seamless voice control and speech I/O (Speech-to-
 npm install use-voice-control
 ```
 
+Or read a document aloud straight from the terminal, no install and no code:
+
+```bash
+npx use-voice-control README.md -o readme.wav
+```
+
 ---
 
 ## 🎤 Features
@@ -58,6 +65,14 @@ npm install use-voice-control
 - **Server & Client Support**: Run on backend or stream to client
 - **Multiple Output Formats**: WAV, PCM, or raw audio buffers
 
+### Markdown & Files
+
+- **Markdown aware**: `#`, `**` and backticks are never read out — headings are
+  spoken as headings, code blocks are announced, links keep their text
+- **Files in, audio out**: `.md` and `.txt` files rendered to WAV from the
+  [command line](#-command-line) or from Node
+- **Local synthesis**: Kokoro runs on the CPU, so document text never leaves the machine
+
 ### React Integration
 - **Custom Hooks**: `useVoiceControl()`, `useSpeechRecognition()`, `useSpeechSynthesis()`
 - **Pre-built Components**: Audio recorder, voice selector, playback controls
@@ -118,6 +133,154 @@ export function VoiceOutput() {
 
 ---
 
+## 🖥️ Command Line
+
+Read a Markdown or text file aloud into an audio file, without writing any code:
+
+```bash
+npx use-voice-control README.md
+# wrote README.wav — 96.4s of audio from README.md in 41.2s
+```
+
+The Markdown is **converted before it is spoken**: `#`, `**`, backticks and the
+rest are never read out. Headings become their own spoken lines with a pause
+after them, list markers are dropped (ordered numbers are kept), links keep their
+text and lose their URL, tables are read row by row, and fenced code blocks are
+announced — "TypeScript code block." — instead of being spelled out character by
+character. See [Markdown → speech](#-markdown--speech) for the rules and how to
+change them.
+
+Speech is synthesized locally with [Kokoro](https://huggingface.co/hexgrad/Kokoro-82M)
+on the CPU: nothing is sent to a third-party service. The first run downloads the
+weights (about 90 MB at the default `q8`) into the Hugging Face cache; every run
+after that is offline.
+
+### Common commands
+
+```bash
+# Markdown or plain text in, WAV out (defaults to <input>.wav, next to the input)
+npx use-voice-control notes.md
+npx use-voice-control notes.txt -o spoken.wav
+
+# Pick a voice and a speaking rate
+npx use-voice-control notes.md -v am_michael -s 1.15
+npx use-voice-control --list-voices
+
+# Speak a string, no file needed
+npx use-voice-control --text "Build finished, three tests failed." -o alert.wav
+
+# Read from a pipe, and write the WAV to stdout
+cat notes.md | npx use-voice-control - -o - > notes.wav
+git log -1 --format=%B | npx use-voice-control - -o commit.wav
+
+# Check what will be spoken, without downloading the model
+npx use-voice-control README.md --print
+```
+
+`--print` is the fastest way to see the Markdown conversion — it converts the
+document, prints the text, and exits before any model is loaded.
+
+### Options
+
+| Option | Meaning |
+| --- | --- |
+| `<file>` | File to read. `-` reads stdin. `.md`, `.markdown`, `.mdx` are read as Markdown; everything else as plain text. |
+| `--text <string>` | Speak this string instead of reading a file. |
+| `-f, --format <fmt>` | `auto` (default), `markdown`, or `text`. Overrides the extension. |
+| `-o, --out <file>` | Audio file to write. Default: the input path with a `.wav` extension, or `out.wav` when the input is stdin or `--text`. `-` writes the WAV to stdout. |
+| `-p, --print` | Print the speakable text and exit — no model, no audio. |
+| `-q, --quiet` | No progress output. |
+| `-v, --voice <id>` | Voice id, default `af_heart`. See `--list-voices`. |
+| `-s, --speed <n>` | Speaking rate between 0.5 and 2. Default 1. |
+| `--headings <mode>` | `text` (default), `announce` ("Heading: Install"), or `skip`. |
+| `--code <mode>` | `announce` (default), `read`, or `skip`. |
+| `--links <mode>` | `text` (default) or `text-and-url`. |
+| `--tables <mode>` | `rows` (default) or `skip`. |
+| `--front-matter` | Read the YAML front matter instead of skipping it. |
+| `--model <id>` | Hugging Face model id. Default `onnx-community/Kokoro-82M-v1.0-ONNX`. |
+| `--dtype <type>` | `fp32`, `fp16`, `q8` (default), `q4`, `q4f16`. |
+| `--device <device>` | `cpu` (default), `wasm`, `webgpu`. |
+| `--chunk <chars>` | Target characters per synthesis chunk. Default 400. |
+| `--gap <ms>` | Silence inserted between chunks. Default 120. |
+| `-h, --help` | Show the full usage text. |
+| `-V, --version` | Print the package version. |
+
+Long documents are split on sentence and paragraph boundaries, synthesized chunk
+by chunk, and joined into one file — Kokoro's context is only a few hundred
+phonemes, so this is what makes a whole README work.
+
+The command exits `0` on success and `1` on a bad option, a missing file, a
+document with nothing to say, or a failed model load; progress goes to stderr, so
+`-o -` gives you a clean WAV on stdout.
+
+### From code
+
+The same thing without the shell:
+
+```ts
+import { renderDocument } from 'use-voice-control/node';
+
+const result = await renderDocument({
+  file: 'README.md',
+  output: 'readme.wav',
+  voice: 'af_heart',
+});
+
+console.log(`${result.durationSeconds.toFixed(1)}s of audio from ${result.source}`);
+```
+
+`use-voice-control/node` also exports `loadDocument` (file → speakable text),
+`synthesizeSamples` / `synthesizeWav` (text → audio), `runCli`, and the Markdown
+helpers below.
+
+---
+
+## 📝 Markdown → speech
+
+Markdown handed straight to a speech engine is read literally: *"hash hash
+Getting started"*, *"star star important star star"*. `markdownToSpeech` parses
+the document instead and emits only the words, keeping the structure the marks
+encoded.
+
+```ts
+import { markdownToSpeech } from 'use-voice-control/markdown';
+
+markdownToSpeech('## Install\n\nRun `npm i` and see the [docs](https://x.dev).');
+// "Install.
+//
+//  Run npm i and see the docs."
+```
+
+| Markdown | Spoken as |
+| --- | --- |
+| `# Heading` and setext underlines | The heading text on its own, with a pause after it |
+| `**bold**`, `_italic_`, `~~struck~~` | The words, no marks |
+| `` `code span` `` | The code text, no backticks |
+| A fenced code block | "TypeScript code block." (or the code, or nothing) |
+| `[text](url)` | The link text; the URL is dropped |
+| `![alt](src)` | The alt text |
+| `- item`, `1. item`, `- [x] task` | The item; bullets and checkboxes dropped, numbers kept |
+| `> quote` | The quoted words |
+| `\| a \| b \|` | "a, b." — the delimiter row is dropped |
+| `---`, `<!-- … -->`, `[ref]: url` | Nothing |
+| YAML front matter | Nothing, unless `frontMatter: true` |
+
+Options: `headings` (`text` \| `announce` \| `skip`), `codeBlocks` (`announce` \|
+`read` \| `skip`), `links` (`text` \| `text-and-url`), `images` (`alt` \| `skip`),
+`tables` (`rows` \| `skip`), `frontMatter`, and `addTerminalPunctuation`.
+
+`markdownToSpeechSegments` returns the same content as typed blocks —
+`{ type: 'heading' | 'paragraph' | 'list-item' | 'quote' | 'code' | 'table-row',
+text, level }` — for callers that want to highlight the current heading or skip
+between sections. `stripInlineMarkdown` handles a single line, and
+`looksLikeMarkdown` is the heuristic behind `--format auto`.
+
+The same conversion runs in the browser: `ReadAloudController` and `useReadAloud`
+convert text that looks like Markdown before speaking it, so an editor's raw
+document does not have its syntax read back to the listener.
+
+---
+
 ## 🗣️ Read Aloud & Live Dictation
 
 Two ready-made browser engines ship from `use-voice-control/client` (framework
@@ -147,8 +310,11 @@ function ReadButton({ text }: { text: string }) {
 }
 ```
 
-Options: `provider`, `voice`, `endpoint`, `maxChunkLength`, and `synthesize` to
-plug in your own TTS. Controls: `speak`, `pause`, `resume`, `stop`, `toggle`.
+Options: `provider`, `voice`, `endpoint`, `maxChunkLength`, `format`
+(`auto` \| `markdown` \| `text` — `auto` converts text that looks like Markdown so
+`##` and `**` are not read out), `markdown` for the conversion options, and
+`synthesize` to plug in your own TTS. Controls: `speak`, `pause`, `resume`,
+`stop`, `toggle`.
 
 ### Live dictation
 
@@ -293,30 +459,35 @@ interface VoiceControlOptions {
 
 #### Kokoro Voices
 
-16 professional voices optimized for natural speech synthesis:
+28 voices optimized for natural speech synthesis. Run `npx use-voice-control
+--list-voices` to print them with their accent and gender. The `a`/`b` prefix is
+the accent (American / British English) and the letter after it is the gender.
 
-**Female Voices:**
+**American English — female:**
 ```
-af_heart    - Warm, caring tone
-af_alloy    - Neutral, professional
-af_aoede    - Bright, energetic
-af_bella    - Soft, gentle
+af_heart    - Warm, caring tone      af_nicole   - Clear, articulate
+af_alloy    - Neutral, professional  af_nova     - Even, unhurried
+af_aoede    - Bright, energetic      af_river    - Calm, soothing
+af_bella    - Soft, gentle           af_sarah    - Warm, approachable
 af_jessica  - Friendly, conversational
-af_nicole   - Clear, articulate
-af_river    - Calm, soothing
-af_sarah    - Warm, approachable
-af_sky      - Young, vibrant
+af_kore     - Steady, measured       af_sky      - Young, vibrant
 ```
 
-**Male Voices:**
+**American English — male:**
 ```
-am_adam     - Deep, authoritative
-am_echo     - Resonant, smooth
-am_fable    - Narrative, engaging
-am_fenrir   - Bold, strong
+am_adam     - Deep, authoritative    am_michael  - Professional, clear
+am_echo     - Resonant, smooth       am_onyx     - Dark, mysterious
+am_eric     - Direct, matter-of-fact am_puck     - Playful, quick
+am_fenrir   - Bold, strong           am_santa    - Jovial, avuncular
 am_liam     - Friendly, warm
-am_michael  - Professional, clear
-am_onyx     - Dark, mysterious
+```
+
+**British English:**
+```
+bf_alice    - Crisp, precise         bm_daniel   - Measured, formal
+bf_emma     - Warm, unhurried        bm_fable    - Narrative, engaging
+bf_isabella - Bright, articulate     bm_george   - Deep, steady
+bf_lily     - Light, gentle          bm_lewis    - Relaxed, conversational
 ```
 
 **Example:**
@@ -400,16 +571,21 @@ Generate speech audio directly from the server or Edge runtime:
 ```ts
 import { generateSpeech } from 'use-voice-control/speech';
 
-// Generate Kokoro speech
+// Generate Kokoro speech — runs the model locally on the CPU via `kokoro-js`
 const audio = await generateSpeech({
   text: "Hello, world!",
   provider: 'kokoro',
   voice: 'af_heart'
 });
 
-// Returns: { audio: ArrayBuffer, contentType: string }
+// Returns: { audio: ArrayBuffer, contentType: string } — a 16-bit PCM WAV
 ```
 
+Text longer than the model's context is chunked on sentence boundaries and joined
+automatically, so a whole document can be passed in one call. Deepgram
+(`provider: 'deepgram'`) goes through a Cloudflare Workers AI binding instead and
+returns MP3; it is not available from the CLI.
+
 ### TypeScript Support
 
 Full type definitions included:
@@ -516,6 +692,7 @@ const SpeechWorker = require('use-voice-control/speech/worker.js');
 ## 🔐 Privacy & Security
 
 - **Client-side STT**: Moonshine.js runs entirely in the browser—no audio leaves your device
+- **Local CLI TTS**: `npx use-voice-control` runs Kokoro on your CPU; the document text is never uploaded
 - **Optional Server TTS**: Choose Kokoro (server-side) or Deepgram (with API key)
 - **No Tracking**: No analytics or usage telemetry
 - **HTTPS Required**: Microphone access requires secure context
@@ -548,6 +725,14 @@ const SpeechWorker = require('use-voice-control/speech/worker.js');
 export { ReadAloudController, LiveTranscriber, isTranscriptionSupported } from 'use-voice-control/client';
 export { useReadAloud, useLiveTranscription, SpokenPhraseOverlay } from 'use-voice-control/react';
 
+// Markdown → speech (implemented)
+export { markdownToSpeech, markdownToSpeechSegments, stripInlineMarkdown, looksLikeMarkdown } from 'use-voice-control/markdown';
+export type { MarkdownToSpeechOptions, SpeechSegment } from 'use-voice-control/markdown';
+
+// Files → audio, and the CLI (implemented, Node)
+export { renderDocument, loadDocument, synthesizeSamples, synthesizeWav, runCli } from 'use-voice-control/node';
+export type { RenderOptions, RenderResult, KokoroNodeOptions } from 'use-voice-control/node';
+
 // Hooks
 export { useSpeechRecognition } from 'use-voice-control/hooks';
 export { useSpeechSynthesis } from 'use-voice-control/hooks';

package/bin/use-voice-control.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview Launcher for the `use-voice-control` command.
+ *
+ * The command itself is built into `dist/cli.js`; this file exists so the
+ * shebang lives in a plain, never-bundled file and so a missing build fails with
+ * an instruction rather than a module-resolution error.
+ */
+let runCli;
+try {
+  ({ runCli } = await import(new URL("../dist/cli.js", import.meta.url).href));
+} catch (error) {
+  process.stderr.write(
+    "use-voice-control: the package is not built — run `npm run build` in " +
+      `packages/use-voice-control first.\n(${error?.message ?? error})\n`
+  );
+  process.exit(1);
+}
+
+process.exitCode = await runCli(process.argv.slice(2));

package/dist/cli.js

@@ -0,0 +1,374 @@
+import { looksLikeMarkdown as g, markdownToSpeech as S } from "./markdown.js";
+import { a as $, e as y, w as M, K as x, d as T } from "./kokoro-node-DJ_Rxp_N.js";
+const E = [".md", ".markdown", ".mdown", ".mkd", ".mdx"], O = [".txt", ".text", ""];
+function v(t) {
+  const e = t.split(/[\\/]/).pop() ?? "", s = e.lastIndexOf(".");
+  return s > 0 ? e.slice(s).toLowerCase() : "";
+}
+function h(t, e, s = "auto") {
+  if (s !== "auto") return s;
+  if (e) {
+    const o = v(e);
+    if (E.includes(o)) return "markdown";
+    if (O.includes(o)) return "text";
+  }
+  return g(t) ? "markdown" : "text";
+}
+function m(t, e, s = {}) {
+  return e === "text" ? t.replace(/\r\n?/g, `
+`).trim() : S(t, s);
+}
+async function w(t) {
+  const { file: e, text: s, format: o = "auto", markdown: r = {} } = t;
+  if (s !== void 0) {
+    const n = h(s, void 0, o);
+    return { text: m(s, n, r), format: n, source: "--text" };
+  }
+  if (!e) throw new Error("No input: pass a file path, `-` for stdin, or --text");
+  if (e === "-") {
+    const n = t.readStdin ? await t.readStdin() : await q(), c = h(n, void 0, o);
+    return { text: m(n, c, r), format: c, source: "stdin" };
+  }
+  const { readFile: i } = await import("node:fs/promises"), a = await i(e, "utf8"), l = h(a, e, o);
+  return { text: m(a, l, r), format: l, source: e };
+}
+async function q() {
+  const t = [];
+  for await (const e of process.stdin)
+    t.push(Buffer.isBuffer(e) ? e : Buffer.from(e));
+  return Buffer.concat(t).toString("utf8");
+}
+function D(t) {
+  const e = v(t);
+  return `${e ? t.slice(0, -e.length) : t}.wav`;
+}
+async function N(t) {
+  const e = await w(t);
+  if (!e.text.trim())
+    throw new Error(`Nothing to speak: ${e.source} has no readable text`);
+  const s = t.synthesize ?? $, { samples: o, sampleRate: r } = await s(e.text, t), i = y(o, r), a = t.output ?? (t.file && t.file !== "-" ? D(t.file) : "out.wav");
+  if (a === "-")
+    process.stdout.write(Buffer.from(i));
+  else {
+    const { writeFile: l } = await import("node:fs/promises");
+    await l(a, Buffer.from(i));
+  }
+  return {
+    output: a,
+    text: e.text,
+    format: e.format,
+    source: e.source,
+    durationSeconds: M(o, r),
+    bytes: i.byteLength
+  };
+}
+const F = {
+  auto: "auto",
+  markdown: "markdown",
+  md: "markdown",
+  text: "text",
+  txt: "text",
+  plain: "text"
+}, V = ["fp32", "fp16", "q8", "q4", "q4f16"], B = ["wasm", "webgpu", "cpu"], C = `use-voice-control — read a Markdown or text file aloud into an audio file
+
+Usage
+  npx use-voice-control <file.md|file.txt|-> [options]
+  npx use-voice-control --text "Hello there" -o hello.wav
+  cat notes.md | npx use-voice-control - -o notes.wav
+
+Markdown is converted before it is spoken: "#", "**" and the rest are not read
+out, headings become their own spoken lines, links keep their text, and fenced
+code blocks are announced instead of being spelled out.
+
+Input
+  <file>                 File to read. Use "-" to read stdin.
+  --text <string>        Speak this string instead of reading a file.
+  -f, --format <fmt>     auto (default), markdown, or text.
+
+Output
+  -o, --out <file>       Audio file to write. Default: the input path with a
+                         .wav extension. Use "-" to write the WAV to stdout.
+  -p, --print            Print the speakable text and exit — no model, no audio.
+                         Useful for checking the Markdown conversion.
+  -q, --quiet            No progress output.
+
+Voice
+  -v, --voice <id>       Voice id. Default af_heart. See --list-voices.
+  -s, --speed <n>        Speaking rate, 0.5-2. Default 1.
+      --list-voices      Print the available voices and exit.
+
+Markdown handling
+  --headings <mode>      text (default) | announce | skip
+  --code <mode>          announce (default) | read | skip
+  --links <mode>         text (default) | text-and-url
+  --tables <mode>        rows (default) | skip
+  --front-matter         Read the YAML front matter instead of skipping it.
+
+Model
+  --model <id>           Hugging Face model id.
+                         Default onnx-community/Kokoro-82M-v1.0-ONNX.
+  --dtype <type>         fp32 | fp16 | q8 (default) | q4 | q4f16
+  --device <device>      cpu (default) | wasm | webgpu
+  --chunk <chars>        Target characters per synthesis chunk. Default 400.
+  --gap <ms>             Silence between chunks. Default 120.
+
+Other
+  -h, --help             Show this help.
+  -V, --version          Print the package version.
+
+The first run downloads the Kokoro weights (about 90 MB at the default q8) into
+the Hugging Face cache; later runs are offline. Speech is synthesized locally —
+no text leaves the machine.`;
+function d(t, e, s, o) {
+  const r = t[e + 1];
+  return r === void 0 || r.startsWith("-") ? (o.push(`${s} needs a value`), { next: e + 1 }) : { value: r, next: e + 1 };
+}
+function k(t, e, s) {
+  if (t === void 0) return;
+  const o = Number(t);
+  if (!Number.isFinite(o)) {
+    s.push(`${e} expects a number, got "${t}"`);
+    return;
+  }
+  return o;
+}
+function f(t, e, s, o) {
+  if (t !== void 0) {
+    if (!e.includes(t)) {
+      o.push(`${s} expects one of ${e.join(", ")} — got "${t}"`);
+      return;
+    }
+    return t;
+  }
+}
+function L(t) {
+  const e = [], s = {}, o = {
+    command: "speak",
+    format: "auto",
+    voice: "af_heart",
+    speed: 1,
+    markdown: s,
+    quiet: !1,
+    errors: e
+  };
+  let r = !1;
+  for (let i = 0; i < t.length; i += 1) {
+    const a = t[i];
+    if (r || !a.startsWith("-") || a === "-") {
+      o.input !== void 0 ? e.push(`unexpected extra input "${a}" — pass one file at a time`) : o.input = a;
+      continue;
+    }
+    if (a === "--") {
+      r = !0;
+      continue;
+    }
+    const l = a.indexOf("=");
+    if (l > 1) {
+      t.splice(i, 1, a.slice(0, l), a.slice(l + 1)), i -= 1;
+      continue;
+    }
+    switch (a) {
+      case "-h":
+      case "--help":
+        return o.command = "help", o;
+      case "-V":
+      case "--version":
+        return o.command = "version", o;
+      case "--list-voices":
+        return o.command = "list-voices", o;
+      case "-p":
+      case "--print":
+      case "--dry-run":
+        o.command = "print";
+        break;
+      case "-q":
+      case "--quiet":
+        o.quiet = !0;
+        break;
+      case "--front-matter":
+        s.frontMatter = !0;
+        break;
+      case "-o":
+      case "--out":
+      case "--output": {
+        const { value: n, next: c } = d(t, i, a, e);
+        o.output = n, i = c;
+        break;
+      }
+      case "--text": {
+        const n = t[i + 1];
+        n === void 0 ? e.push("--text needs a value") : o.text = n, i += 1;
+        break;
+      }
+      case "-f":
+      case "--format": {
+        const { value: n, next: c } = d(t, i, a, e);
+        if (i = c, n !== void 0) {
+          const u = F[n.toLowerCase()];
+          u ? o.format = u : e.push(`--format expects auto, markdown or text — got "${n}"`);
+        }
+        break;
+      }
+      case "-v":
+      case "--voice": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, n !== void 0 && (x.includes(n) ? o.voice = n : e.push(`unknown voice "${n}" — run --list-voices to see them all`));
+        break;
+      }
+      case "-s":
+      case "--speed": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c;
+        const u = k(n, a, e);
+        u !== void 0 && (u < 0.5 || u > 2 ? e.push("--speed must be between 0.5 and 2") : o.speed = u);
+        break;
+      }
+      case "--model": {
+        const { value: n, next: c } = d(t, i, a, e);
+        o.model = n, i = c;
+        break;
+      }
+      case "--dtype": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, o.dtype = f(n, V, a, e) ?? o.dtype;
+        break;
+      }
+      case "--device": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, o.device = f(n, B, a, e) ?? o.device;
+        break;
+      }
+      case "--chunk":
+      case "--chunk-length": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c;
+        const u = k(n, a, e);
+        u !== void 0 && (u < 40 ? e.push("--chunk must be at least 40 characters") : o.maxChunkLength = u);
+        break;
+      }
+      case "--gap": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c;
+        const u = k(n, a, e);
+        u !== void 0 && (u < 0 ? e.push("--gap cannot be negative") : o.gapMs = u);
+        break;
+      }
+      case "--headings": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, s.headings = f(n, ["text", "announce", "skip"], a, e) ?? s.headings;
+        break;
+      }
+      case "--code":
+      case "--code-blocks": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, s.codeBlocks = f(n, ["announce", "read", "skip"], a, e) ?? s.codeBlocks;
+        break;
+      }
+      case "--links": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, s.links = f(n, ["text", "text-and-url"], a, e) ?? s.links;
+        break;
+      }
+      case "--tables": {
+        const { value: n, next: c } = d(t, i, a, e);
+        i = c, s.tables = f(n, ["rows", "skip"], a, e) ?? s.tables;
+        break;
+      }
+      default:
+        e.push(`unknown option "${a}" — run --help to see the options`);
+    }
+  }
+  return o.text !== void 0 && o.input !== void 0 && e.push("pass either a file or --text, not both"), o;
+}
+function I() {
+  const t = x.map((e) => {
+    const s = T(e);
+    return `  ${e.padEnd(14)}${s.name.padEnd(12)}${s.gender.padEnd(8)}${s.accent}`;
+  });
+  return [`${x.length} Kokoro voices:`, ...t].join(`
+`);
+}
+async function K() {
+  try {
+    const { readFile: t } = await import("node:fs/promises");
+    for (const e of ["../package.json", "../../package.json"])
+      try {
+        const s = new URL(e, import.meta.url), o = JSON.parse(await t(s, "utf8"));
+        if ((o == null ? void 0 : o.name) === "use-voice-control" && o.version) return o.version;
+      } catch {
+      }
+  } catch {
+  }
+  return "unknown";
+}
+async function z(t, e = {}) {
+  const s = e.log ?? ((n) => process.stdout.write(`${n}
+`)), o = e.error ?? ((n) => process.stderr.write(`${n}
+`)), r = L([...t]);
+  if (r.command === "help")
+    return s(C), 0;
+  if (r.command === "version")
+    return s(await K()), 0;
+  if (r.command === "list-voices")
+    return s(I()), 0;
+  if (r.errors.length > 0)
+    return r.errors.forEach((n) => o(`use-voice-control: ${n}`)), o("Run `npx use-voice-control --help` for usage."), 1;
+  const i = e.stdinIsTTY ?? !!process.stdin.isTTY, a = r.input ?? (r.text === void 0 && !i ? "-" : void 0);
+  if (a === void 0 && r.text === void 0)
+    return o("use-voice-control: no input — pass a file, pipe text in, or use --text"), o("Run `npx use-voice-control --help` for usage."), 1;
+  const l = {
+    file: a,
+    text: r.text,
+    format: r.format,
+    markdown: r.markdown,
+    readStdin: e.readStdin
+  };
+  try {
+    if (r.command === "print") {
+      const u = await w(l);
+      return s(u.text), 0;
+    }
+    const n = Date.now(), c = await N({
+      ...l,
+      output: r.output,
+      voice: r.voice,
+      speed: r.speed,
+      model: r.model,
+      dtype: r.dtype,
+      device: r.device,
+      maxChunkLength: r.maxChunkLength,
+      gapMs: r.gapMs,
+      synthesize: e.synthesize,
+      onModelProgress: r.quiet ? void 0 : (u) => {
+        if ((u == null ? void 0 : u.status) === "progress" && u.file && u.total) {
+          const p = Math.round((u.loaded ?? 0) / u.total * 100);
+          o(`downloading ${u.file}: ${p}%`);
+        }
+      },
+      onChunk: r.quiet ? void 0 : ({ index: u, total: p }) => o(`speaking chunk ${u + 1}/${p}`)
+    });
+    if (!r.quiet) {
+      const u = c.durationSeconds.toFixed(1), p = ((Date.now() - n) / 1e3).toFixed(1), b = c.output === "-" ? "stdout" : c.output;
+      o(`wrote ${b} — ${u}s of audio from ${c.source} in ${p}s`);
+    }
+    return 0;
+  } catch (n) {
+    return o(`use-voice-control: ${n instanceof Error ? n.message : String(n)}`), 1;
+  }
+}
+export {
+  E as M,
+  O as T,
+  C as USAGE,
+  h as a,
+  N as b,
+  D as d,
+  v as e,
+  I as formatVoiceList,
+  w as l,
+  L as parseArgs,
+  q as r,
+  z as runCli,
+  m as t
+};
+//# sourceMappingURL=cli.js.map