dsh-her 0.1.0 → 0.2.0

package/lib/voice/ming-voices.js

@@ -0,0 +1,181 @@
+/**
+ * Her own Ming voices (docs/Ming本地声音设计.md §4), in `<home>/voices/ming/`:
+ * `<id>.wav` (the reference recording) and `<id>.json`. Ming says every
+ * sentence in such a voice by cloning that recording.
+ *
+ * - designed: made from a description. The same description gives a
+ *   slightly different voice every time, so a few candidates are made, one is
+ *   kept, and from then on she clones it;
+ * - cloned: from a recording you add, only with your word that it is your
+ *   own voice or that you may use it. It never leaves this computer.
+ *
+ * Candidates not kept yet wait in `drafts/` and are cleared after a day.
+ * The voice settings (quality, moods, idle minutes) are in `settings.json`.
+ */
+import { execFile } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { wavFromPcm16 } from "../core/index.js";
+const run = promisify(execFile);
+export const DEFAULT_MING_SETTINGS = { quality: 'quality', moods: true };
+export const MING_STEPS = { quality: 10, speed: 5 };
+const DRAFT_TTL_MS = 24 * 3_600_000;
+/** A clone reference: long enough to carry the voice, short enough to keep each sentence quick. */
+export const CLONE_MIN_S = 3;
+export const CLONE_MAX_S = 15;
+export class OwnVoices {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    list() {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir)
+            .filter(f => f.endsWith('.json') && f !== 'settings.json')
+            .flatMap(f => {
+            try {
+                const voice = JSON.parse(readFileSync(join(this.dir, f), 'utf8'));
+                return existsSync(join(this.dir, `${voice.id}.wav`)) ? [voice] : [];
+            }
+            catch {
+                return [];
+            }
+        })
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    /** The recording Ming clones for a voice. */
+    ref(id) {
+        const voice = this.list().find(v => v.id === id);
+        return voice === undefined ? undefined : { wav: join(this.dir, `${voice.id}.wav`), text: voice.text };
+    }
+    /** Keep a candidate for a while (until it is kept, or a day). */
+    addDraft(wav, draft) {
+        const drafts = join(this.dir, 'drafts');
+        mkdirSync(drafts, { recursive: true });
+        for (const f of readdirSync(drafts)) {
+            if (Date.now() - statSync(join(drafts, f)).mtimeMs > DRAFT_TTL_MS)
+                rmSync(join(drafts, f), { force: true });
+        }
+        const id = randomUUID();
+        writeFileSync(join(drafts, `${id}.wav`), wav);
+        writeFileSync(join(drafts, `${id}.json`), JSON.stringify(draft));
+        return id;
+    }
+    /** Keep a candidate as one of her voices. A clone needs your consent and what the recording says. */
+    keep(draftId, name, change = {}) {
+        if (!/^[0-9a-f-]{36}$/.test(draftId))
+            throw new Error('找不到这个试听');
+        const drafts = join(this.dir, 'drafts');
+        if (!existsSync(join(drafts, `${draftId}.wav`)))
+            throw new Error('这个试听已经过期了，再生成一次吧');
+        const draft = JSON.parse(readFileSync(join(drafts, `${draftId}.json`), 'utf8'));
+        if (draft.kind === 'clone' && change.consent !== true)
+            throw new Error('要先确认这是你本人的声音，或者你有授权');
+        const text = (change.text ?? draft.text).trim();
+        if (text === '')
+            throw new Error('要写上录音里说的话');
+        if (name.trim() === '')
+            throw new Error('给这个声音起个名字');
+        const voice = {
+            id: `v${Date.now().toString(36)}`, name: name.trim().slice(0, 20), kind: draft.kind, text,
+            ...(draft.description === undefined ? {} : { description: draft.description }), createdAt: new Date().toISOString(),
+        };
+        copyFileSync(join(drafts, `${draftId}.wav`), join(this.dir, `${voice.id}.wav`));
+        writeFileSync(join(this.dir, `${voice.id}.json`), `${JSON.stringify(voice, null, 2)}\n`);
+        return voice;
+    }
+    remove(id) {
+        if (!/^v[0-9a-z]+$/.test(id))
+            return;
+        rmSync(join(this.dir, `${id}.wav`), { force: true });
+        rmSync(join(this.dir, `${id}.json`), { force: true });
+    }
+    settings() {
+        try {
+            return { ...DEFAULT_MING_SETTINGS, ...JSON.parse(readFileSync(join(this.dir, 'settings.json'), 'utf8')) };
+        }
+        catch {
+            return { ...DEFAULT_MING_SETTINGS };
+        }
+    }
+    saveSettings(patch) {
+        const next = { ...this.settings(), ...patch };
+        mkdirSync(this.dir, { recursive: true });
+        writeFileSync(join(this.dir, 'settings.json'), `${JSON.stringify(next, null, 2)}\n`);
+        return next;
+    }
+}
+/**
+ * A recording you add, made ready to clone: converted by macOS's afconvert
+ * (wav, m4a from Voice Memos, mp3, aiff …) to 44.1 kHz mono, quiet start and
+ * end cut off, at most CLONE_MAX_S. Also at 16 kHz, to recognize what it says.
+ */
+export async function prepareRecording(bytes, name) {
+    const dir = await mkdtemp(join(tmpdir(), 'dsh-her-clone-'));
+    try {
+        const ext = /\.([a-z0-9]{1,5})$/i.exec(name)?.[1] ?? 'wav';
+        const input = join(dir, `in.${ext}`);
+        await writeFile(input, bytes);
+        const full = join(dir, 'full.wav');
+        try {
+            await run('afconvert', ['-f', 'WAVE', '-d', 'LEI16@44100', '-c', '1', input, full], { timeout: 60_000 });
+        }
+        catch {
+            throw new Error('读不了这个录音文件（试试 wav、m4a 或 mp3）');
+        }
+        const samples = trimSilence(pcmOf(new Uint8Array(await readFile(full))), 44_100);
+        const seconds = samples.length / 44_100;
+        if (seconds < CLONE_MIN_S)
+            throw new Error(`录音太短了（${seconds.toFixed(1)} 秒），至少要 ${CLONE_MIN_S} 秒清楚的说话`);
+        const clip = samples.subarray(0, CLONE_MAX_S * 44_100);
+        const pcm = new Uint8Array(clip.buffer, clip.byteOffset, clip.byteLength);
+        const wav = wavFromPcm16(pcm, 44_100);
+        const trimmed = join(dir, 'trimmed.wav');
+        await writeFile(trimmed, wav);
+        const small = join(dir, 'small.wav');
+        await run('afconvert', ['-f', 'WAVE', '-d', 'LEI16@16000', '-c', '1', trimmed, small], { timeout: 60_000 });
+        const pcm16 = pcmOf(new Uint8Array(await readFile(small)));
+        return { wav, pcm16k: new Uint8Array(pcm16.buffer, pcm16.byteOffset, pcm16.byteLength), seconds: clip.length / 44_100 };
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+/** The 16-bit samples of a WAV file (its `data` chunk). */
+function pcmOf(wav) {
+    const view = new DataView(wav.buffer, wav.byteOffset, wav.byteLength);
+    let at = 12;
+    while (at + 8 <= wav.byteLength) {
+        const id = String.fromCharCode(...wav.subarray(at, at + 4));
+        const size = view.getUint32(at + 4, true);
+        if (id === 'data') {
+            const bytes = wav.slice(at + 8, at + 8 + Math.min(size, wav.byteLength - at - 8));
+            return new Int16Array(bytes.buffer, 0, Math.floor(bytes.byteLength / 2));
+        }
+        at += 8 + size + (size % 2);
+    }
+    throw new Error('录音文件里没有声音');
+}
+/** Cut quiet 10 ms frames off both ends, keeping 0.1 s around the speech. */
+export function trimSilence(samples, rate) {
+    const frame = Math.round(rate / 100);
+    const loud = (i) => {
+        let sum = 0;
+        for (let j = i; j < Math.min(i + frame, samples.length); j++)
+            sum += samples[j] * samples[j];
+        return Math.sqrt(sum / frame) > 0.01 * 32768;
+    };
+    let start = 0;
+    while (start < samples.length && !loud(start))
+        start += frame;
+    let end = samples.length - frame;
+    while (end > start && !loud(end))
+        end -= frame;
+    const pad = rate / 10;
+    return samples.subarray(Math.max(0, start - pad), Math.min(samples.length, end + frame + pad));
+}

package/lib/voice/ming.js

@@ -0,0 +1,335 @@
+/**
+ * Ming-3.0-tts on this computer (docs/Ming本地声音设计.md): offline, free,
+ * with moods, and voices of your own. Apple chips with macOS 14+ only (MLX).
+ *
+ * - Install (on request, from the "她" page): uv (voice/uv.ts) builds a
+ *   Python 3.12 environment in `<home>/ming/env` and installs mlx-audio from
+ *   python/ming-requirements.txt, every package pinned with its hash; the
+ *   model (voice/ming-model.ts) is downloaded into `<home>/ming/model`, each
+ *   file checked against its size and SHA-256. An interrupted download goes
+ *   on where it stopped. Deleting `<home>/ming` uninstalls it.
+ * - Run: python/ming_worker.py, one process that keeps the model loaded
+ *   (about 2 GB of memory); sentences go to it one at a time. It starts with
+ *   the first sentence (or when you start talking, `warm`), and stops after
+ *   some minutes without a sentence to give the memory back.
+ * - A worker that dies is started again with the next sentence; one that dies
+ *   twice within five minutes is left stopped (`failed`) until `restart`.
+ */
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { release, totalmem } from 'node:os';
+import { dirname, join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
+import { wavFromPcm16 } from "../core/index.js";
+import { MING_MODEL, MING_MODEL_BYTES } from "./ming-model.js";
+import { installUv, run, uvEnv } from "./uv.js";
+const PYTHON_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'python');
+const WORKER = join(PYTHON_DIR, 'ming_worker.py');
+const REQUIREMENTS = join(PYTHON_DIR, 'ming-requirements.txt');
+const LOAD_TIMEOUT_MS = 180_000;
+const SPEAK_TIMEOUT_MS = 90_000;
+const CRASH_WINDOW_MS = 5 * 60_000;
+/** Why Ming cannot run here, or undefined when it can: Apple chips and macOS 14 (Darwin 23) or later. */
+export function mingUnsupported(platform = process.platform, arch = process.arch, darwin = release()) {
+    if (platform !== 'darwin' || arch !== 'arm64')
+        return '本机 Ming 只支持 Apple 芯片的 Mac';
+    if (Number.parseInt(darwin, 10) < 23)
+        return '本机 Ming 要 macOS 14 或更新';
+    return undefined;
+}
+/** Minutes without a sentence before the worker stops: 10 on a Mac with 16 GB or less, else 30. */
+export const defaultIdleMinutes = (memory = totalmem()) => (memory <= 16 * 2 ** 30 ? 10 : 30);
+export class MingVoice {
+    root;
+    uvHome;
+    logger;
+    state;
+    worker;
+    starting;
+    installing;
+    pending = new Map();
+    queue = Promise.resolve();
+    nextId = 1;
+    lastUse = 0;
+    crashes = [];
+    stderr = [];
+    idleMinutes;
+    idleTimer;
+    /** `root`: `<home>/ming`; `uvHome`: `<home>/uv`, shared with the Edge voice. `idleMinutes` 0: never stop. */
+    constructor(root, uvHome, logger, idleMinutes = defaultIdleMinutes()) {
+        this.root = root;
+        this.uvHome = uvHome;
+        this.logger = logger;
+        this.idleMinutes = idleMinutes;
+        const unsupported = mingUnsupported();
+        this.state = unsupported !== undefined ? { state: 'unsupported', error: unsupported } : { state: this.installed ? 'stopped' : 'absent' };
+        this.idleTimer = setInterval(() => this.stopWhenIdle(), 60_000);
+        this.idleTimer.unref();
+    }
+    get status() {
+        return this.state;
+    }
+    get installed() {
+        return existsSync(this.python) && existsSync(join(this.modelDir, '.verified'));
+    }
+    setIdleMinutes(minutes) {
+        this.idleMinutes = minutes;
+    }
+    get python() {
+        return join(this.root, 'env', 'bin', 'python3');
+    }
+    get modelDir() {
+        return join(this.root, 'model');
+    }
+    /** Install everything (once; a second call joins the first). Progress shows in `status`. */
+    install() {
+        if (this.state.state === 'unsupported')
+            return Promise.reject(new Error(this.state.error));
+        this.installing ??= this.doInstall().finally(() => { this.installing = undefined; });
+        return this.installing;
+    }
+    async doInstall() {
+        const step = (text, extra = {}) => { this.state = { state: 'installing', step: text, ...extra }; };
+        try {
+            step('准备 Python（第一次约 1 分钟）');
+            const env = uvEnv(this.uvHome);
+            const uv = await installUv(this.uvHome);
+            const envDir = join(this.root, 'env');
+            if (!existsSync(this.python))
+                await run(uv, ['venv', '--quiet', '--python', '3.12', envDir], 600_000, env);
+            step('安装语音程序（约 450 MB）');
+            await run(uv, ['pip', 'install', '--quiet', '--require-hashes', '--python', this.python, '-r', REQUIREMENTS], 1_200_000, env);
+            // Installed now: the downloads are not needed any more.
+            rmSync(env.UV_CACHE_DIR, { recursive: true, force: true });
+            await this.downloadModel((done, total) => step('下载声音模型（约 1.6 GB）', { done, total }));
+            this.state = { state: 'stopped' };
+            this.logger.info('dsh-her: Ming voice installed');
+        }
+        catch (error) {
+            this.state = { state: 'failed', error: `安装本机 Ming 失败：${error.message}` };
+            throw new Error(this.state.error);
+        }
+    }
+    /** Every model file, checked; files already checked (listed in `.verified`) are kept. */
+    async downloadModel(onProgress) {
+        mkdirSync(this.modelDir, { recursive: true });
+        const marker = join(this.modelDir, '.verified');
+        if (existsSync(marker))
+            return;
+        const checkedFile = join(this.modelDir, '.checked.json');
+        const checked = new Set(existsSync(checkedFile) ? JSON.parse(readFileSync(checkedFile, 'utf8')) : []);
+        let done = 0;
+        for (const file of MING_MODEL.files) {
+            const target = join(this.modelDir, file.name);
+            if (checked.has(file.sha256) && existsSync(target) && statSync(target).size === file.size) {
+                done += file.size;
+                onProgress(done, MING_MODEL_BYTES);
+                continue;
+            }
+            const before = done;
+            let lastError;
+            for (const source of MING_MODEL.sources) {
+                try {
+                    await download(`${source}${file.name}`, target, file, got => onProgress(before + got, MING_MODEL_BYTES));
+                    lastError = undefined;
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                    this.logger.warn(`dsh-her: Ming model ${file.name} from ${source} failed (${lastError.message})`);
+                }
+            }
+            if (lastError !== undefined)
+                throw new Error(`下载 ${file.name} 失败：${lastError.message}`);
+            done = before + file.size;
+            checked.add(file.sha256);
+            writeFileSync(checkedFile, JSON.stringify([...checked]));
+        }
+        writeFileSync(marker, `${MING_MODEL.repo}@${MING_MODEL.revision}\n`);
+        rmSync(checkedFile, { force: true });
+    }
+    /** Stop and delete everything (about 2 GB). */
+    uninstall() {
+        this.stop();
+        rmSync(this.root, { recursive: true, force: true });
+        if (this.state.state !== 'unsupported')
+            this.state = { state: 'absent' };
+    }
+    /** You started talking: have the model loaded by the time she answers. */
+    warm() {
+        if (this.installed && this.state.state === 'stopped')
+            void this.ensure().catch(() => undefined);
+    }
+    /** After `failed`: forget the crashes and start again. */
+    async restart() {
+        this.stop();
+        this.crashes = [];
+        if (this.installed)
+            this.state = { state: 'stopped' };
+        await this.ensure();
+    }
+    /** One sentence. Sentences are said one at a time, in the order asked. */
+    synthesize(request) {
+        const job = this.queue.then(() => this.speakNow(request));
+        this.queue = job.catch(() => undefined);
+        return job;
+    }
+    stop() {
+        const worker = this.worker;
+        this.worker = undefined;
+        this.starting = undefined;
+        if (worker !== undefined) {
+            worker.removeAllListeners('exit');
+            worker.kill();
+            this.failPending(new Error('本机 Ming 已停止'));
+        }
+        if (this.state.state === 'ready' || this.state.state === 'loading')
+            this.state = { state: 'stopped' };
+    }
+    /** Stop for good (the plugin is unloading). */
+    close() {
+        clearInterval(this.idleTimer);
+        this.stop();
+    }
+    async speakNow(request) {
+        await this.ensure();
+        this.lastUse = Date.now();
+        const reply = await this.send({ op: 'speak', ...request }, SPEAK_TIMEOUT_MS);
+        this.lastUse = Date.now();
+        const pcm = Buffer.from(String(reply.pcm16), 'base64');
+        const sampleRate = Number(reply.sampleRate);
+        return { audio: wavFromPcm16(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength), sampleRate), durationMs: Math.round(pcm.byteLength / 2 / sampleRate * 1000), ms: Number(reply.ms) };
+    }
+    ensure() {
+        if (this.state.state === 'ready' && this.worker !== undefined)
+            return Promise.resolve();
+        if (this.state.state === 'unsupported')
+            return Promise.reject(new Error(this.state.error));
+        if (this.state.state === 'installing')
+            return Promise.reject(new Error('本机 Ming 正在安装'));
+        if (!this.installed)
+            return Promise.reject(new Error('本机 Ming 还没安装'));
+        if (this.state.state === 'failed' && this.crashes.length >= 2)
+            return Promise.reject(new Error(this.state.error ?? '本机 Ming 出错了'));
+        this.starting ??= this.start().finally(() => { this.starting = undefined; });
+        return this.starting;
+    }
+    async start() {
+        this.state = { state: 'loading' };
+        this.stderr = [];
+        const worker = spawn(this.python, ['-I', WORKER], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, HF_HUB_OFFLINE: '1', TRANSFORMERS_OFFLINE: '1', TOKENIZERS_PARALLELISM: 'false', PYTHONUNBUFFERED: '1' },
+        });
+        this.worker = worker;
+        createInterface({ input: worker.stdout }).on('line', line => this.onReply(line));
+        createInterface({ input: worker.stderr }).on('line', line => {
+            this.stderr.push(line);
+            if (this.stderr.length > 20)
+                this.stderr.shift();
+        });
+        worker.on('error', error => this.onExit(worker, error.message));
+        worker.on('exit', code => this.onExit(worker, `退出码 ${code}`));
+        try {
+            const reply = await this.send({ op: 'load', model: this.modelDir }, LOAD_TIMEOUT_MS);
+            this.state = { state: 'ready' };
+            this.lastUse = Date.now();
+            this.logger.info(`dsh-her: Ming voice loaded (${String(reply.loadMs)} ms)`);
+        }
+        catch (error) {
+            this.stop();
+            this.state = { state: 'failed', error: `本机 Ming 启动失败：${error.message}` };
+            this.crashes.push(Date.now());
+            throw new Error(this.state.error);
+        }
+    }
+    send(message, timeoutMs) {
+        const worker = this.worker;
+        if (worker?.stdin === null || worker === undefined)
+            return Promise.reject(new Error('本机 Ming 没有在运行'));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error('本机 Ming 太久没有回应'));
+                // A worker stuck on one sentence is stuck for all of them.
+                this.stop();
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: reply => { clearTimeout(timer); resolve(reply); },
+                reject: error => { clearTimeout(timer); reject(error); },
+            });
+            worker.stdin.write(`${JSON.stringify({ ...message, id })}\n`);
+        });
+    }
+    onReply(line) {
+        let reply;
+        try {
+            reply = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const waiting = this.pending.get(Number(reply.id));
+        if (waiting === undefined)
+            return;
+        this.pending.delete(Number(reply.id));
+        if (reply.ok === true)
+            waiting.resolve(reply);
+        else
+            waiting.reject(new Error(String(reply.error ?? '未知错误')));
+    }
+    onExit(worker, why) {
+        if (worker !== this.worker)
+            return;
+        this.worker = undefined;
+        const detail = this.stderr.slice(-3).join(' ').slice(-300);
+        this.failPending(new Error(`本机 Ming 意外退出（${why}）${detail === '' ? '' : `：${detail}`}`));
+        const now = Date.now();
+        this.crashes = [...this.crashes.filter(at => now - at < CRASH_WINDOW_MS), now];
+        this.state = this.crashes.length >= 2
+            ? { state: 'failed', error: `本机 Ming 连续出错（${why}）${detail === '' ? '' : `：${detail}`}` }
+            : { state: 'stopped' };
+        this.logger.warn(`dsh-her: Ming voice exited (${why}) ${detail}`);
+    }
+    failPending(error) {
+        for (const waiting of this.pending.values())
+            waiting.reject(error);
+        this.pending.clear();
+    }
+    stopWhenIdle() {
+        if (this.idleMinutes <= 0 || this.state.state !== 'ready' || this.pending.size > 0)
+            return;
+        if (Date.now() - this.lastUse < this.idleMinutes * 60_000)
+            return;
+        this.logger.info(`dsh-her: Ming voice idle for ${this.idleMinutes} min, stopped to free memory`);
+        this.stop();
+    }
+}
+/** One file from `url` into `target`, checked against its size and SHA-256 before it takes the file's place. */
+async function download(url, target, file, onProgress) {
+    const res = await fetch(url, { redirect: 'follow', signal: AbortSignal.timeout(3_600_000) });
+    if (!res.ok || res.body === null)
+        throw new Error(`HTTP ${res.status}`);
+    const hash = createHash('sha256');
+    let got = 0;
+    const count = new Transform({
+        transform(chunk, _encoding, done) {
+            hash.update(chunk);
+            got += chunk.length;
+            onProgress(got);
+            done(null, chunk);
+        },
+    });
+    const part = `${target}.part`;
+    await pipeline(Readable.fromWeb(res.body), count, createWriteStream(part));
+    if (got !== file.size || hash.digest('hex') !== file.sha256) {
+        rmSync(part, { force: true });
+        throw new Error('下载的文件校验不对');
+    }
+    renameSync(part, target);
+}

package/lib/voice/speech-queue.js

@@ -22,14 +22,16 @@ export class SpeechQueue {
     sent = new Map();
     synth;
     out;
+    /** `synth` gets what to say and the sentence's cues (its emotion colours the voice). */
     constructor(synth, out) {
         this.synth = synth;
         this.out = out;
     }
-    say(uid, seq, text, cues = []) {
+    /** `spoken`: what to say when it differs from the subtitle `text` (sound markers for Ming). */
+    say(uid, seq, text, cues = [], spoken) {
         if (this.cancelled.has(uid))
             return;
-        this.jobs.push({ uid, kind: 'sentence', seq, text, cues });
+        this.jobs.push({ uid, kind: 'sentence', seq, text, cues, ...(spoken === undefined ? {} : { spoken }) });
         this.startAhead();
         void this.pump();
     }
@@ -65,7 +67,7 @@ export class SpeechQueue {
                 continue;
             if (++sentences > AHEAD)
                 break;
-            job.audio ??= this.synth(job.text).catch(() => undefined);
+            job.audio ??= this.synth(job.spoken ?? job.text, job.cues).catch(() => undefined);
         }
     }
     async pump() {

package/lib/voice/uv.js

@@ -0,0 +1,60 @@
+/**
+ * Running Python tools without asking the computer for a Python: uv
+ * (https://github.com/astral-sh/uv), one pinned, checksummed download kept
+ * in `<home>/uv`, fetches a Python of its own into the same folder and builds
+ * virtual environments with it. No dialogs, nothing system-wide. Used by the
+ * Edge voice (when the computer has no usable Python) and the Ming voice.
+ */
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export function run(cmd, args, timeout, env) {
+    return new Promise((resolve, reject) => {
+        execFile(cmd, args, { timeout, maxBuffer: 8 << 20, ...(env === undefined ? {} : { env: { ...process.env, ...env } }) }, (error, stdout, stderr) => {
+            if (error !== null)
+                reject(new Error(String(stderr || error.message).trim().split('\n').slice(-2).join(' ')));
+            else
+                resolve(String(stdout));
+        });
+    });
+}
+/** What uv needs to keep its Python and downloads inside `uvHome`. */
+export function uvEnv(uvHome) {
+    return { UV_PYTHON_INSTALL_DIR: join(uvHome, 'python'), UV_CACHE_DIR: join(uvHome, 'cache'), UV_NO_CONFIG: '1' };
+}
+/** uv, pinned: version and the SHA-256 of each download (from the release's .sha256 files). */
+const UV_VERSION = '0.11.26';
+const UV_ASSETS = {
+    'darwin-arm64': { file: 'uv-aarch64-apple-darwin.tar.gz', sha256: '8f7fbf1708399b921857bce71e1d60f0d3ccf52a30caebc1c1a2f175dce13ab6' },
+    'darwin-x64': { file: 'uv-x86_64-apple-darwin.tar.gz', sha256: '922b460202707dd5f4ccacbadbe7f6a546cc46e82a99bf50ca99a7977a78eddd' },
+    'win32-x64': { file: 'uv-x86_64-pc-windows-msvc.zip', sha256: '4e1278ede866be6c0bf32d2f466cc6de7a9fb399ecf20c9ce2d186e52424be47' },
+};
+/** The uv binary in `uvHome`, downloaded and checked the first time. */
+export async function installUv(uvHome) {
+    const key = `${process.platform}-${process.arch}`;
+    const asset = UV_ASSETS[key];
+    if (asset === undefined)
+        throw new Error(`这台电脑（${key}）没有 Python，也没有现成的办法自动装：请先装 Python 3`);
+    const dir = join(uvHome, UV_VERSION);
+    const found = [join(dir, 'uv'), join(dir, 'uv.exe'), join(dir, asset.file.replace(/\.(tar\.gz|zip)$/, ''), 'uv')].find(p => existsSync(p));
+    if (found !== undefined)
+        return found;
+    const res = await fetch(`https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${asset.file}`, { redirect: 'follow', signal: AbortSignal.timeout(300_000) });
+    if (!res.ok)
+        throw new Error(`下载 uv 失败（${res.status}）`);
+    const bytes = Buffer.from(await res.arrayBuffer());
+    if (createHash('sha256').update(bytes).digest('hex') !== asset.sha256)
+        throw new Error('下载的 uv 校验不对，没有使用');
+    await mkdir(dir, { recursive: true });
+    const archive = join(dir, asset.file);
+    await writeFile(archive, bytes);
+    // tar reads both the .tar.gz and (Windows 10+) the .zip.
+    await run('tar', ['-xf', archive, '-C', dir], 120_000);
+    await rm(archive, { force: true });
+    const uv = [join(dir, 'uv'), join(dir, 'uv.exe'), join(dir, asset.file.replace(/\.(tar\.gz|zip)$/, ''), 'uv')].find(p => existsSync(p));
+    if (uv === undefined)
+        throw new Error('uv 解压后找不到');
+    return uv;
+}