@funpixel/tools 0.0.0-stage → 0.1.0

package/dist/gen/local/kokoro.js

@@ -0,0 +1,334 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { appleSilicon, LocalFailure, LocalRefusal, machineWords, modelsDir, generatedBy } from "./provider.js";
+import { castArgs, dialogueArgs, DIALOGUE_VERSION, hostedPreset, lineArgs, lineStem, MAX_TAGS, PRESETS, RECORD_VERSION, tags as tagList, timeline } from "./voice-rules.js";
+import { masterDialogue, mixDialogue, mixWavs, summary, wavSeconds } from "./master.js";
+export const KOKORO_ID = 'kokoro-82m';
+export const RUNNER = 'mlx_audio.tts.generate';
+export const UV_PYTHON = '3.12';
+export const MLX_AUDIO = 'mlx-audio==0.5.6';
+export const WITH = ['misaki[en]==0.9.4', 'en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl'];
+export const WEIGHTS_REPO = 'mlx-community/Kokoro-82M-bf16';
+export const WEIGHTS_REVISION = 'a71e4d38b236d968966a2002c4c895dbd12b1c3c';
+export const HF = 'https://huggingface.co';
+export const MARKER = '.funtools-weights.json';
+const WANTED = (path) => path === 'config.json' || path === 'kokoro-v1_0.safetensors' || /^voices\/[a-z]{2}_[a-z]+\.safetensors$/.test(path);
+export const SET_UP = "Kokoro isn't set up on this Mac. Run: `funtools models install kokoro-82m`";
+export const FIX = 'funtools models install kokoro-82m';
+export const NEEDS = 'Kokoro needs Apple Silicon (an M-series Mac)';
+export const VOICES = [
+    'af_heart', 'af_alloy', 'af_aoede', 'af_bella', 'af_jessica', 'af_kore', 'af_nicole', 'af_nova', 'af_river', 'af_sarah', 'af_sky',
+    'am_adam', 'am_echo', 'am_eric', 'am_fenrir', 'am_liam', 'am_michael', 'am_onyx', 'am_puck', 'am_santa',
+    'bf_alice', 'bf_emma', 'bf_isabella', 'bf_lily', 'bm_daniel', 'bm_fable', 'bm_george', 'bm_lewis',
+    'ef_dora', 'em_alex', 'em_santa', 'ff_siwis', 'hf_alpha', 'hf_beta', 'hm_omega', 'hm_psi', 'if_sara', 'im_nicola',
+    'jf_alpha', 'jf_gongitsune', 'jf_nezumi', 'jf_tebukuro', 'jm_kumo', 'pf_dora', 'pm_alex', 'pm_santa',
+    'zf_xiaobei', 'zf_xiaoni', 'zf_xiaoxiao', 'zf_xiaoyi', 'zm_yunjian', 'zm_yunxi', 'zm_yunxia', 'zm_yunyang',
+];
+export const FROM_PRESET = {
+    Zephyr: 'af_bella', Puck: 'am_puck', Charon: 'am_michael', Kore: 'af_kore', Fenrir: 'am_fenrir',
+    Leda: 'af_sky', Orus: 'am_adam', Aoede: 'af_aoede', Callirrhoe: 'af_river', Autonoe: 'af_nova',
+    Enceladus: 'am_echo', Iapetus: 'am_eric', Umbriel: 'am_liam', Algieba: 'bm_daniel', Despina: 'af_sarah',
+    Erinome: 'bf_emma', Algenib: 'am_onyx', Rasalgethi: 'bm_george', Laomedeia: 'af_jessica', Achernar: 'af_nicole',
+    Alnilam: 'bm_lewis', Schedar: 'bm_fable', Gacrux: 'bf_alice', Pulcherrima: 'bf_isabella', Achird: 'am_eric',
+    Zubenelgenubi: 'am_liam', Vindemiatrix: 'bf_lily', Sadachbia: 'am_puck', Sadaltager: 'bm_george', Sulafat: 'af_heart',
+};
+export const langOf = (voice) => voice[0];
+export function voiceFor(preset) {
+    const hosted = hostedPreset(preset);
+    if (hosted)
+        return { preset: hosted, voice: FROM_PRESET[hosted] };
+    const own = VOICES.find((v) => v === preset.trim().toLowerCase());
+    if (own)
+        return { preset: own, voice: own };
+    throw new Error(`\`preset\` must be one of ${PRESETS.map(([p]) => p).join(', ')} (or one of Kokoro's own voices: ${VOICES.slice(0, 4).join(', ')}, …)`);
+}
+const SLOWER = new Set(['slow', 'slowly', 'weary', 'tired', 'sleepy', 'drowsy', 'hesitant', 'measured', 'calm']);
+const FASTER = new Set(['fast', 'quickly', 'quick', 'hurried', 'rushed', 'urgent', 'excited', 'excitable', 'frantic', 'breathless']);
+export function pace(all) {
+    const slow = all.some((t) => SLOWER.has(t)), fast = all.some((t) => FASTER.has(t));
+    return { speed: slow === fast ? 1 : slow ? 0.88 : 1.12, unperformed: all.filter((t) => !SLOWER.has(t) && !FASTER.has(t)) };
+}
+export const plainText = (text) => {
+    const dropped = [...text.matchAll(/\[([^\]]*)\]/g)].map((m) => m[1].trim()).filter(Boolean);
+    return { text: text.replace(/\[[^\]]*\]/g, ' ').replace(/\s+/g, ' ').trim(), dropped };
+};
+const weightsDir = (m) => join(modelsDir(m), KOKORO_ID);
+function weightsReady(m) {
+    const dir = weightsDir(m);
+    try {
+        const mk = JSON.parse(readFileSync(join(dir, MARKER), 'utf8'));
+        if (mk.revision !== WEIGHTS_REVISION || !mk.files.some((f) => f.path === 'kokoro-v1_0.safetensors'))
+            return false;
+        return mk.files.every((f) => { try {
+            return statSync(join(dir, f.path)).size === f.size;
+        }
+        catch {
+            return false;
+        } });
+    }
+    catch {
+        return false;
+    }
+}
+function check(m) {
+    if (!appleSilicon(m))
+        return { state: 'unsupported', says: `${NEEDS}; this is ${machineWords(m)}. Our pick, gemini-tts-3.8, runs anywhere: drop --model` };
+    const runner = m.which(RUNNER);
+    const weights = weightsReady(m);
+    if (runner && weights)
+        return { state: 'installed', says: `${RUNNER} at ${runner}; weights in ${weightsDir(m)}` };
+    const lacks = [runner ? '' : `the runner (${RUNNER})`, weights ? '' : `the weights (${weightsDir(m)})`].filter(Boolean).join(' and ');
+    return { state: 'missing', says: SET_UP, fix: FIX, detail: `missing ${lacks}` };
+}
+async function speak(m, text, voice, speed, onLine) {
+    const runner = m.which(RUNNER);
+    if (!runner)
+        throw new LocalRefusal(SET_UP);
+    const dir = weightsDir(m);
+    const work = mkdtempSync(join(tmpdir(), 'funtools-kokoro-'));
+    try {
+        const r = await m.run(runner, [
+            '--model', dir, '--text', text, '--voice', join(dir, 'voices', `${voice}.safetensors`),
+            '--speed', String(speed), '--lang_code', langOf(voice),
+            '--output_path', work, '--file_prefix', 'take', '--audio_format', 'wav', '--join_audio',
+        ], { env: { HF_HUB_OFFLINE: '1', TRANSFORMERS_OFFLINE: '1' }, timeoutMs: 600_000, onLine });
+        const takes = existsSync(work) ? readdirSync(work).filter((f) => f.endsWith('.wav')).sort() : [];
+        if (r.code !== 0 || !takes.length) {
+            const tail = r.out.trim().split('\n').slice(-3).join(' ').slice(0, 400);
+            throw new LocalFailure(`Kokoro did not speak the line (exit ${r.code}${tail ? `: ${tail}` : ''}) — run \`funtools doctor\`, or \`${FIX} --force\` to set it up again`);
+        }
+        return readFileSync(join(work, takes[0]));
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+function finish(wav, stem, m) {
+    const ffmpeg = m.which('ffmpeg');
+    const r = ffmpeg ? masterDialogue(wav, ffmpeg) : { unavailable: 'ffmpeg is not installed' };
+    if ('dud' in r)
+        throw new LocalFailure(`The line came back silent (peak ${r.dud.toFixed(0)} dBFS) and was not saved. Try again.`);
+    if ('ok' in r)
+        return { file: { name: `${stem}.mp3`, bytes: r.ok.bytes, content_type: 'audio/mpeg' }, seconds: r.ok.seconds, note: summary(r.ok) };
+    return { file: { name: `${stem}.wav`, bytes: wav, content_type: 'audio/wav' }, seconds: wavSeconds(wav), note: `Not mastered (${r.unavailable}): brew install ffmpeg, then make it again.` };
+}
+const HONEST = 'Made on this Mac by Kokoro (local:kokoro-82m): free, not checked by us.';
+function notes(unperformed, dropped) {
+    return [
+        unperformed.length ? `Kokoro does not act ${unperformed.join(', ')} (kept in the record; only pace is acted).` : '',
+        dropped.length ? `Dropped from the text, not spoken: ${dropped.map((d) => `[${d}]`).join(' ')}.` : '',
+    ].filter(Boolean).join(' ');
+}
+async function run(req, _outDir, m, onLine) {
+    let c, l, d;
+    if (req.tool === 'cast_voice')
+        c = castArgs(req.input);
+    else if (req.tool === 'voice_line')
+        l = lineArgs(req.input);
+    else if (req.tool === 'dialogue')
+        d = dialogueArgs(req.input);
+    else
+        throw new Error(`${KOKORO_ID} makes voices (cast_voice, voice_line, dialogue), not ${req.tool}`);
+    const ready = check(m);
+    if (ready.state === 'unsupported')
+        throw new LocalRefusal(NEEDS);
+    if (ready.state === 'missing')
+        throw new LocalRefusal(SET_UP);
+    if (d)
+        return scene(d, m, onLine);
+    if (c) {
+        const v = voiceFor(c.voice.preset);
+        const { speed, unperformed } = pace(c.voice.tags);
+        const said = plainText(c.sample);
+        const out = finish(await speak(m, said.text, v.voice, speed, onLine), 'sample', m);
+        const record = { version: RECORD_VERSION, name: c.name, preset: v.preset, tags: c.voice.tags, ...(c.description ? { description: c.description } : {}), generated_by: generatedBy(KOKORO_ID), voice: v.voice };
+        return {
+            files: [{ name: 'voice.json', bytes: Buffer.from(JSON.stringify(record, null, 2)), content_type: 'application/json' }, out.file],
+            result: {
+                name: c.name, preset: v.preset, tags: c.voice.tags, voice: v.voice, sample_seconds: out.seconds, generated_by: generatedBy(KOKORO_ID),
+                summary: `${c.name}'s voice: ${v.preset}${v.voice !== v.preset ? ` (Kokoro's ${v.voice})` : ''}${c.voice.tags.length ? `, ${c.voice.tags.join(', ')}` : ''}. Pass voice.json as --voice to \`gen line --model ${KOKORO_ID}\` so every line is this voice. ${out.note} ${notes(unperformed, said.dropped)} ${HONEST}`.replace(/\s+/g, ' ').trim(),
+            },
+        };
+    }
+    const line = l;
+    let preset, voiceTags, cast = null;
+    if ('record' in line.voice) {
+        ({ preset, tags: voiceTags, cast } = readRecord(line.voice.record, '--voice'));
+    }
+    else {
+        preset = line.voice.inline.preset;
+        voiceTags = line.voice.inline.tags;
+    }
+    const v = voiceFor(preset);
+    const { speed, unperformed } = pace([...voiceTags, ...line.emotion]);
+    const said = plainText(line.text);
+    if (!said.text)
+        throw new Error('`text` must not be empty');
+    const out = finish(await speak(m, said.text, v.voice, speed, onLine), 'line', m);
+    return {
+        files: [out.file],
+        result: {
+            seconds: out.seconds, preset: v.preset, tags: voiceTags, voice: v.voice, cast, generated_by: generatedBy(KOKORO_ID),
+            summary: `Spoken in ${cast ?? v.preset}'s voice (Kokoro's ${v.voice}). ${out.note} ${notes(unperformed, said.dropped)} ${HONEST}`.replace(/\s+/g, ' ').trim(),
+        },
+    };
+}
+function readRecord(path, field) {
+    if (!existsSync(path))
+        throw new Error(`${field} ${path}: a local line reads its voice from a voice.json on this machine (\`gen voice … --model ${KOKORO_ID}\` writes one under .funtools/voice/), not an asset id`);
+    let r;
+    try {
+        r = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        throw new Error('`voice_asset_id` is not a voice record (cast_voice\'s voice.json)');
+    }
+    if (typeof r?.preset !== 'string' || typeof r?.name !== 'string')
+        throw new Error('`voice_asset_id` is not a voice record (cast_voice\'s voice.json)');
+    const preset = r.voice && VOICES.includes(r.voice) ? r.voice : r.preset;
+    return { preset, tags: tagList('tags', r.tags ?? [], MAX_TAGS), cast: r.name, named: r.preset };
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function scene(d, m, onLine) {
+    const voices = {};
+    const takes = [];
+    const unperformedAll = new Set(), droppedAll = [];
+    for (const [i, ln] of d.lines.entries()) {
+        let preset, voiceTags = [], cast = null, named = null;
+        if (UUID_RE.test(ln.voice))
+            throw new Error(`lines[${i}].voice ${ln.voice}: a local scene reads a voice from a voice.json on this machine (\`gen voice … --model ${KOKORO_ID}\` writes one under .funtools/voice/) or a preset, not an asset id`);
+        if (ln.voice.endsWith('.json') || ln.voice.includes('/'))
+            ({ preset, tags: voiceTags, cast, named } = readRecord(ln.voice, `lines[${i}].voice`));
+        else
+            preset = ln.voice;
+        let v;
+        try {
+            v = voiceFor(preset);
+        }
+        catch (e) {
+            throw new Error(`lines[${i}].voice: ${e.message}`);
+        }
+        const { speed, unperformed } = pace([...voiceTags, ...ln.tags]);
+        const said = plainText(ln.text);
+        if (!said.text)
+            throw new Error(`\`lines[${i}].text\` must not be empty`);
+        onLine?.(`line ${i + 1} of ${d.lines.length}: ${ln.speaker}`);
+        const out = finish(await speak(m, said.text, v.voice, speed, onLine), lineStem(i), m);
+        takes.push(out.file);
+        unperformed.forEach((t) => unperformedAll.add(t));
+        droppedAll.push(...said.dropped);
+        voices[ln.speaker] ??= { preset: named ?? v.preset, tags: voiceTags, voice_asset_id: null, local_voice: v.voice, ...(cast ? { cast } : {}) };
+    }
+    const pauses = d.lines.map((l) => l.pause_after_ms);
+    const ffmpeg = m.which('ffmpeg');
+    const mastered = takes.every((t) => t.name.endsWith('.mp3'));
+    const mixed = mastered && ffmpeg ? mixDialogue(takes.map((t) => t.bytes), pauses, ffmpeg) : mixWavs(takes.map((t) => t.bytes), pauses);
+    if (!mixed || 'unavailable' in mixed)
+        throw new LocalFailure(`the scene's lines could not be mixed${mixed && 'unavailable' in mixed ? ` (${mixed.unavailable})` : ''} — brew install ffmpeg, then make it again`);
+    const file = `dialogue.${mixed.ext}`;
+    const t = timeline(d.lines, mixed.frames, mixed.rate, takes.map((x) => x.name));
+    const doc = { version: DIALOGUE_VERSION, file, duration: t.duration, model: KOKORO_ID, gap_ms: d.gap_ms, complete: true, voices, tracks: t.tracks };
+    const said = `${d.lines.length} line${d.lines.length === 1 ? '' : 's'} on ${t.tracks.length} track${t.tracks.length === 1 ? '' : 's'}, ${t.duration.toFixed(1)} s`;
+    const level = mixed.ext === 'mp3' ? `Mixed at ${mixed.lufs === null ? '' : `${mixed.lufs.toFixed(0)} LUFS, `}${mixed.kbps} kbps.` : 'Not mastered (ffmpeg is not installed): brew install ffmpeg, then make it again.';
+    return {
+        files: [
+            { name: file, bytes: mixed.bytes, content_type: mixed.ext === 'mp3' ? 'audio/mpeg' : 'audio/wav' },
+            { name: 'dialogue.json', bytes: Buffer.from(JSON.stringify(doc, null, 2)), content_type: 'application/json' },
+            ...takes,
+        ],
+        result: {
+            seconds: t.duration, lines: d.lines.length, tracks: t.tracks.length, complete: true, generated_by: generatedBy(KOKORO_ID),
+            summary: `The scene: ${said} as ${file}, each line also as ${takes[0].name.replace(/01/, 'NN')}, the timeline in dialogue.json. ${level} ${notes([...unperformedAll], droppedAll)} ${HONEST}`.replace(/\s+/g, ' ').trim(),
+        },
+    };
+}
+const mb = (n) => (n / 1e6).toFixed(1);
+async function fetchWeights(m, progress) {
+    const dir = weightsDir(m);
+    const list = await m.fetch(`${HF}/api/models/${WEIGHTS_REPO}/tree/${WEIGHTS_REVISION}?recursive=true`);
+    if (!list.ok)
+        throw new LocalFailure(`the weights' file list answered ${list.status} — check the connection and run it again`);
+    const tree = (await list.json());
+    const files = tree.filter((f) => f.type === 'file' && WANTED(f.path)).map((f) => ({ path: f.path, size: f.lfs?.size ?? f.size, sha256: f.lfs?.oid }));
+    if (!files.some((f) => f.path === 'kokoro-v1_0.safetensors') || !files.some((f) => f.path.startsWith('voices/')))
+        throw new LocalFailure('the weights\' file list has no model or no voices — nothing was changed');
+    const total = files.reduce((n, f) => n + f.size, 0);
+    let done = 0, shown = -1;
+    const show = (force = false) => {
+        const pct = total ? Math.floor((done / total) * 100) : 100;
+        if (force || pct !== shown) {
+            shown = pct;
+            progress(`weights: ${mb(done)} / ${mb(total)} MB (${pct}%)`, true);
+        }
+    };
+    show(true);
+    rmSync(join(dir, MARKER), { force: true });
+    for (const f of files) {
+        const to = join(dir, f.path);
+        try {
+            if (statSync(to).size === f.size && !f.sha256) {
+                done += f.size;
+                show();
+                continue;
+            }
+        }
+        catch { }
+        mkdirSync(dirname(to), { recursive: true });
+        const res = await m.fetch(`${HF}/${WEIGHTS_REPO}/resolve/${WEIGHTS_REVISION}/${f.path}`);
+        if (!res.ok || !res.body)
+            throw new LocalFailure(`${f.path} answered ${res.status} — run it again; what was fetched is kept`);
+        const part = `${to}.part`;
+        const hash = createHash('sha256');
+        const sink = createWriteStream(part);
+        let got = 0;
+        const reader = res.body.getReader();
+        for (;;) {
+            const { value, done: end } = await reader.read();
+            if (end)
+                break;
+            hash.update(value);
+            got += value.length;
+            done += value.length;
+            if (!sink.write(value))
+                await new Promise((r) => sink.once('drain', () => r()));
+            show();
+        }
+        await new Promise((r, j) => sink.end((e) => (e ? j(e) : r())));
+        if (got !== f.size) {
+            rmSync(part, { force: true });
+            throw new LocalFailure(`${f.path}: got ${got} bytes, expected ${f.size} — run it again`);
+        }
+        if (f.sha256 && hash.digest('hex') !== f.sha256) {
+            rmSync(part, { force: true });
+            throw new LocalFailure(`${f.path}: its sha256 is not the hub's — nothing of it was kept; run it again`);
+        }
+        renameSync(part, to);
+    }
+    show(true);
+    writeFileSync(join(dir, MARKER), JSON.stringify({ repo: WEIGHTS_REPO, revision: WEIGHTS_REVISION, files: files.map(({ path, size }) => ({ path, size })) }, null, 2) + '\n');
+}
+async function install(m, opts) {
+    if (!appleSilicon(m))
+        throw new LocalRefusal(`${NEEDS}; this is ${machineWords(m)}. Our pick, gemini-tts-3.8, runs anywhere`);
+    if (opts.force || !m.which(RUNNER)) {
+        const uv = m.which('uv');
+        if (!uv)
+            throw new LocalRefusal('the runner installs with uv, which is not here: brew install uv (or see docs.astral.sh/uv), then run this again');
+        const args = ['tool', 'install', '--python', UV_PYTHON, ...(opts.force ? ['--force'] : []), MLX_AUDIO, ...WITH.flatMap((w) => ['--with', w])];
+        opts.progress(`runner: uv ${args.join(' ')}`);
+        const r = await m.run(uv, args, { timeoutMs: 1_200_000, onLine: (l) => opts.progress(`  ${l}`) });
+        if (r.code !== 0)
+            throw new LocalFailure(`uv tool install failed (exit ${r.code}) — its output is above; fix what it names and run this again`);
+        if (!m.which(RUNNER))
+            throw new LocalFailure(`uv installed mlx-audio, but ${RUNNER} is not on PATH — run \`uv tool update-shell\`, open a new terminal, and run this again`);
+    }
+    else
+        opts.progress(`runner: ${RUNNER} is already installed (--force reinstalls it)`);
+    if (opts.force || !weightsReady(m))
+        await fetchWeights(m, opts.progress);
+    else
+        opts.progress(`weights: already in ${weightsDir(m)} (--force fetches them again)`);
+}
+export const kokoro = { id: KOKORO_ID, tools: ['cast_voice', 'voice_line', 'dialogue'], check, run, install };

package/dist/gen/local/master.js

@@ -0,0 +1,248 @@
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export const DIALOGUE_LUFS = -16;
+export const DUD_DBFS = -40;
+export const TRIM_DBFS = -50;
+export const PEAK_CEILING_DBFS = -1;
+export const MAX_BYTES = 1048576;
+export const BITRATES_KBPS = [128, 96, 64, 48];
+export const RATE = 44100;
+export const CHANNELS = 2;
+const PRE_ROLL_MS = 5;
+const TAIL_FADE_MS = 20;
+const dbToAmp = (db) => 10 ** (db / 20);
+export const peakDbfs = (s) => {
+    let m = 0;
+    for (const v of s)
+        m = Math.max(m, Math.abs(v));
+    return 20 * Math.log10(m);
+};
+export function trimSilence(s, rate = RATE, ch = CHANNELS) {
+    const win = Math.max(1, Math.floor(rate / 100));
+    const floor = dbToAmp(TRIM_DBFS);
+    const frames = Math.floor(s.length / ch);
+    const windows = Math.ceil(frames / win);
+    const loud = (w) => {
+        const a = w * win * ch, b = Math.min((w + 1) * win * ch, s.length);
+        for (let i = a; i < b; i++)
+            if (Math.abs(s[i]) > floor)
+                return true;
+        return false;
+    };
+    let first = -1;
+    for (let w = 0; w < windows; w++)
+        if (loud(w)) {
+            first = w;
+            break;
+        }
+    if (first < 0)
+        return s;
+    let last = first;
+    for (let w = windows - 1; w >= first; w--)
+        if (loud(w)) {
+            last = w;
+            break;
+        }
+    const start = Math.max(0, first * win - Math.floor((rate * PRE_ROLL_MS) / 1000));
+    const end = Math.min((last + 1) * win, frames);
+    const out = s.slice(start * ch, end * ch);
+    const n = Math.min(Math.floor((rate * TAIL_FADE_MS) / 1000), Math.floor(out.length / ch));
+    const total = Math.floor(out.length / ch);
+    for (let i = 0; i < n; i++) {
+        const g = (n - 1 - i) / Math.max(1, n - 1);
+        for (let c = 0; c < ch; c++)
+            out[(total - n + i) * ch + c] *= g;
+    }
+    return out;
+}
+export const gainDb = (lufs, peak, target = DIALOGUE_LUFS) => lufs === null ? 0 : Math.min(target - lufs, PEAK_CEILING_DBFS - peak);
+export const bitrateFor = (seconds) => BITRATES_KBPS.find((k) => (seconds * k * 1000) / 8 * 1.02 < MAX_BYTES) ?? BITRATES_KBPS[BITRATES_KBPS.length - 1];
+const realFfmpeg = (bin) => (args) => {
+    const r = spawnSync(bin, ['-hide_banner', '-nostats', '-y', ...args], { encoding: 'utf8', timeout: 120_000, maxBuffer: 64 * 1024 * 1024 });
+    if (r.error)
+        return { ok: false, stderr: '', why: r.error.code === 'ENOENT' ? 'ffmpeg is not installed' : r.error.message };
+    return { ok: r.status === 0, stderr: r.stderr ?? '', why: r.status === 0 ? undefined : (r.stderr ?? '').trim().split('\n').slice(-2).join(' ') };
+};
+function lufsOf(ff, raw) {
+    const r = ff(['-f', 'f32le', '-ar', String(RATE), '-ac', String(CHANNELS), '-i', raw, '-filter_complex', 'ebur128', '-f', 'null', '-']);
+    const summary = r.stderr.slice(Math.max(0, r.stderr.lastIndexOf('Summary:')));
+    const m = /I:\s*(-?\d+(?:\.\d+)?)\s*LUFS/.exec(summary);
+    const v = m ? Number(m[1]) : null;
+    return v === null || v <= -69 ? null : v;
+}
+export function masterDialogue(input, ffmpeg = 'ffmpeg') {
+    const ff = realFfmpeg(ffmpeg);
+    const dir = mkdtempSync(join(tmpdir(), 'funtools-master-'));
+    try {
+        const src = join(dir, 'in'), raw = join(dir, 'in.f32');
+        writeFileSync(src, input);
+        const dec = ff(['-v', 'error', '-i', src, '-f', 'f32le', '-ac', String(CHANNELS), '-ar', String(RATE), raw]);
+        if (!dec.ok)
+            return { unavailable: dec.why ?? 'ffmpeg could not decode the clip' };
+        const bytes = readFileSync(raw);
+        let pcm = new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.length - (bytes.length % 4)));
+        const peak = peakDbfs(pcm);
+        if (!Number.isFinite(peak) || peak < DUD_DBFS)
+            return { dud: peak };
+        pcm = trimSilence(pcm);
+        const trimmedRaw = join(dir, 'trimmed.f32');
+        writeFileSync(trimmedRaw, Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+        const lufs = lufsOf(ff, trimmedRaw);
+        const gain = gainDb(lufs, peakDbfs(pcm));
+        const amp = dbToAmp(gain);
+        for (let i = 0; i < pcm.length; i++)
+            pcm[i] *= amp;
+        for (;;) {
+            const seconds = pcm.length / CHANNELS / RATE;
+            const kbps = bitrateFor(seconds);
+            const shaped = join(dir, 'shaped.f32'), out = join(dir, 'out.mp3');
+            writeFileSync(shaped, Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+            const enc = ff(['-v', 'error', '-f', 'f32le', '-ar', String(RATE), '-ac', String(CHANNELS), '-i', shaped, '-c:a', 'libmp3lame', '-b:a', `${kbps}k`, '-write_xing', '1', out]);
+            if (!enc.ok)
+                return { unavailable: enc.why ?? 'ffmpeg could not encode MP3' };
+            const mp3 = readFileSync(out);
+            if (mp3.length <= MAX_BYTES) {
+                return { ok: { bytes: mp3, seconds, lufs: lufs === null ? null : lufs + gain, peak_dbfs: peakDbfs(pcm), trimmed: true, kbps } };
+            }
+            const frames = Math.floor(pcm.length / CHANNELS);
+            const keep = frames - Math.floor(frames / 10);
+            if (keep <= 0)
+                return { unavailable: 'clip could not fit 1 MiB' };
+            pcm = pcm.slice(0, keep * CHANNELS);
+        }
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function summary(m) {
+    const parts = [`${m.seconds.toFixed(1)}s`];
+    if (m.lufs !== null)
+        parts.push(`${m.lufs.toFixed(0)} LUFS`);
+    parts.push(`peak ${m.peak_dbfs.toFixed(1)} dBFS`);
+    if (m.trimmed)
+        parts.push('silence trimmed');
+    return `Mastered: ${parts.join(', ')}.`;
+}
+export function wavSeconds(b) {
+    if (b.length < 44 || b.toString('ascii', 0, 4) !== 'RIFF' || b.toString('ascii', 8, 12) !== 'WAVE')
+        return null;
+    let off = 12, rate = 0, block = 0;
+    while (off + 8 <= b.length) {
+        const id = b.toString('ascii', off, off + 4), size = b.readUInt32LE(off + 4);
+        if (id === 'fmt ') {
+            rate = b.readUInt32LE(off + 12);
+            block = b.readUInt16LE(off + 20);
+        }
+        if (id === 'data')
+            return rate && block ? Math.min(size, b.length - off - 8) / block / rate : null;
+        off += 8 + size + (size % 2);
+    }
+    return null;
+}
+export function decodePcm(input, ffmpeg = 'ffmpeg') {
+    const ff = realFfmpeg(ffmpeg);
+    const dir = mkdtempSync(join(tmpdir(), 'funtools-decode-'));
+    try {
+        const src = join(dir, 'in'), raw = join(dir, 'in.f32');
+        writeFileSync(src, input);
+        const dec = ff(['-v', 'error', '-i', src, '-f', 'f32le', '-ac', String(CHANNELS), '-ar', String(RATE), raw]);
+        if (!dec.ok)
+            return { unavailable: dec.why ?? 'ffmpeg could not decode the clip' };
+        const b = readFileSync(raw);
+        return new Float32Array(b.buffer.slice(b.byteOffset, b.byteOffset + b.length - (b.length % 4)));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function mixDialogue(takes, pauses, ffmpeg = 'ffmpeg') {
+    const pcm = [];
+    for (const t of takes) {
+        const p = decodePcm(t, ffmpeg);
+        if (!(p instanceof Float32Array))
+            return p;
+        pcm.push(p);
+    }
+    const frames = pcm.map((p) => Math.floor(p.length / CHANNELS));
+    const gaps = pauses.map((ms) => Math.round((ms * RATE) / 1000));
+    const total = frames.reduce((n, f, i) => n + f + (i < frames.length - 1 ? gaps[i] : 0), 0);
+    const mix = new Float32Array(total * CHANNELS);
+    let at = 0;
+    pcm.forEach((p, i) => {
+        mix.set(p.subarray(0, frames[i] * CHANNELS), at * CHANNELS);
+        at += frames[i] + (i < pcm.length - 1 ? gaps[i] : 0);
+    });
+    const ff = realFfmpeg(ffmpeg);
+    const dir = mkdtempSync(join(tmpdir(), 'funtools-mix-'));
+    try {
+        const raw = join(dir, 'mix.f32'), out = join(dir, 'mix.mp3');
+        writeFileSync(raw, Buffer.from(mix.buffer, mix.byteOffset, mix.byteLength));
+        const lufs = lufsOf(ff, raw);
+        const gain = gainDb(lufs, peakDbfs(mix));
+        if (gain !== 0) {
+            const amp = dbToAmp(gain);
+            for (let i = 0; i < mix.length; i++)
+                mix[i] *= amp;
+            writeFileSync(raw, Buffer.from(mix.buffer, mix.byteOffset, mix.byteLength));
+        }
+        const kbps = bitrateFor(total / RATE);
+        const enc = ff(['-v', 'error', '-f', 'f32le', '-ar', String(RATE), '-ac', String(CHANNELS), '-i', raw, '-c:a', 'libmp3lame', '-b:a', `${kbps}k`, '-write_xing', '1', out]);
+        if (!enc.ok)
+            return { unavailable: enc.why ?? 'ffmpeg could not encode MP3' };
+        return { bytes: readFileSync(out), frames, total, rate: RATE, lufs: lufs === null ? null : lufs + gain, kbps, ext: 'mp3' };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+function wavPcm(b) {
+    if (b.length < 44 || b.toString('ascii', 0, 4) !== 'RIFF' || b.toString('ascii', 8, 12) !== 'WAVE')
+        return null;
+    let off = 12, rate = 0, channels = 0, bits = 0;
+    while (off + 8 <= b.length) {
+        const id = b.toString('ascii', off, off + 4), size = b.readUInt32LE(off + 4);
+        if (id === 'fmt ') {
+            channels = b.readUInt16LE(off + 10);
+            rate = b.readUInt32LE(off + 12);
+            bits = b.readUInt16LE(off + 22);
+        }
+        if (id === 'data')
+            return rate && channels && bits ? { rate, channels, bits, data: b.subarray(off + 8, Math.min(b.length, off + 8 + size)) } : null;
+        off += 8 + size + (size % 2);
+    }
+    return null;
+}
+export function mixWavs(takes, pauses) {
+    const w = takes.map(wavPcm);
+    const f = w[0];
+    if (!f || w.some((x) => !x || x.rate !== f.rate || x.channels !== f.channels || x.bits !== f.bits))
+        return null;
+    const block = (f.channels * f.bits) / 8;
+    const frames = w.map((x) => Math.floor(x.data.length / block));
+    const gaps = pauses.map((ms) => Math.round((ms * f.rate) / 1000));
+    const parts = [];
+    w.forEach((x, i) => {
+        parts.push(x.data.subarray(0, frames[i] * block));
+        if (i < w.length - 1)
+            parts.push(Buffer.alloc(gaps[i] * block));
+    });
+    const data = Buffer.concat(parts);
+    const h = Buffer.alloc(44);
+    h.write('RIFF', 0);
+    h.writeUInt32LE(36 + data.length, 4);
+    h.write('WAVE', 8);
+    h.write('fmt ', 12);
+    h.writeUInt32LE(16, 16);
+    h.writeUInt16LE(1, 20);
+    h.writeUInt16LE(f.channels, 22);
+    h.writeUInt32LE(f.rate, 24);
+    h.writeUInt32LE(f.rate * block, 28);
+    h.writeUInt16LE(block, 32);
+    h.writeUInt16LE(f.bits, 34);
+    h.write('data', 36);
+    h.writeUInt32LE(data.length, 40);
+    return { bytes: Buffer.concat([h, data]), frames, total: data.length / block, rate: f.rate, lufs: null, kbps: 0, ext: 'wav' };
+}

package/dist/gen/local/provider.js

@@ -0,0 +1,65 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+export const uvBinDir = (env, home = homedir()) => env.UV_TOOL_BIN_DIR || env.XDG_BIN_HOME || join(home, '.local', 'bin');
+function onPath(program, dirs) {
+    for (const dir of dirs.filter(Boolean)) {
+        const p = join(dir, program);
+        try {
+            if (statSync(p).isFile()) {
+                accessSync(p, constants.X_OK);
+                return p;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+export function realMachine(env = process.env) {
+    return {
+        platform: process.platform,
+        arch: process.arch,
+        env,
+        home: env.FUNPIXEL_STATE_HOME || homedir(),
+        translated: () => {
+            if (process.platform !== 'darwin')
+                return false;
+            const r = spawnSync('sysctl', ['-in', 'sysctl.proc_translated'], { encoding: 'utf8', timeout: 5_000 });
+            return r.stdout?.trim() === '1';
+        },
+        which: (program) => onPath(program, [...(env.PATH ?? '').split(delimiter), uvBinDir(env)]),
+        run: (program, args, opts = {}) => new Promise((done) => {
+            const child = spawn(program, args, { cwd: opts.cwd, env: { ...env, ...opts.env }, stdio: ['ignore', 'pipe', 'pipe'] });
+            let out = '', partial = '';
+            const take = (b) => {
+                const s = b.toString();
+                out += s;
+                partial += s;
+                const lines = partial.split(/\r?\n|\r/);
+                partial = lines.pop() ?? '';
+                for (const l of lines)
+                    if (l.trim())
+                        opts.onLine?.(l);
+            };
+            child.stdout.on('data', take);
+            child.stderr.on('data', take);
+            const t = opts.timeoutMs ? setTimeout(() => { out += `\n(stopped after ${Math.round(opts.timeoutMs / 1000)} s)`; child.kill('SIGTERM'); }, opts.timeoutMs) : undefined;
+            child.on('close', (code) => { clearTimeout(t); done({ code: code ?? 1, out }); });
+            child.on('error', (e) => { clearTimeout(t); done({ code: 127, out: e.message }); });
+        }),
+        fetch: (...a) => fetch(...a),
+    };
+}
+export const modelsDir = (m) => join(m.home, '.funpixel', 'models');
+export class LocalRefusal extends Error {
+}
+export class LocalFailure extends Error {
+}
+export const generatedBy = (id) => `local:${id}`;
+export function machineWords(m) {
+    if (m.platform === 'darwin')
+        return m.arch === 'arm64' ? 'an Apple Silicon Mac' : 'an Intel Mac';
+    return `${m.platform} (${m.arch})`;
+}
+export const appleSilicon = (m) => m.platform === 'darwin' && (m.arch === 'arm64' || m.translated());