@gentbajko/slopify 3.0.0 → 3.0.2

package/README.md

@@ -34,14 +34,16 @@ For Docker on Linux with Node 26+, Docker Engine and the Docker Compose plugin,
 `slopify --docker` or `npx @gentbajko/slopify@latest --docker`. It writes one
 `compose.yaml` and its `.env` under `~/.local/share/slopify/docker/slopify/` and starts
 Slopify at `http://127.0.0.1:6969`, restarting with Docker. Project files go to
-`~/Slopify/Projects` (`--projects-dir` to choose another, `--port` for the port); the
+`Documents/Slopify/Projects` (`--projects-dir` to choose another, `--port` for the port); the
 database, keys and logs stay private in the `slopify-data` volume.
 
 If Claude Code, Codex or Gemini is installed, it asks once before setting up the host CLI
 bridge, a private helper that runs those CLIs on your machine with their existing logins.
 Use `--host-cli=off` for API keys only, or `--accept-host-cli` to approve without a prompt.
 
-Update with `npx @gentbajko/slopify@latest update`, Docker or not. It waits for running
+Update with `npx @gentbajko/slopify@latest update`, Docker or not. Without Docker, `update`
+asks the running app to update itself, so it works only while Slopify is running (to just
+start the newest version, run `npx @gentbajko/slopify@latest`). It waits for running
 work, keeps a copy to go back to (the database, or a recovery volume in Docker), and puts
 the previous version back if the new one doesn't start. Installations made by 2.5.0 or
 earlier are taken over as they are: same volume, same project folder. See the
@@ -88,10 +90,10 @@ for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not
 | `--port` | `SLOPIFY_PORT` | `6969` |
 | `--host` | `SLOPIFY_HOST` | `127.0.0.1` |
 | `--data-dir` | `SLOPIFY_DATA_DIR` | `~/.slopify` |
-| `--projects-dir` (Docker only) | `SLOPIFY_DOCKER_PROJECTS_DIR` | remembered path; otherwise `~/Slopify/Projects` (custom names: `~/Slopify/<container>/Projects`) |
+| `--projects-dir` (Docker only) | `SLOPIFY_DOCKER_PROJECTS_DIR` | remembered path; otherwise `<Documents>/Slopify/Projects` (custom names: `<Documents>/Slopify/<container>/Projects`); installs from before 3.0 keep `~/Slopify/Projects` |
 | `--no-open` | `SLOPIFY_NO_OPEN` | the browser opens |
 | `--docker` | — | run locally; with the flag, install or update the Docker version |
-| `update` | — | update the running app, or the Docker installation if you have one |
+| `update` | — | update the running app (it must be running), or the Docker installation if you have one |
 | — | `SLOPIFY_FFMPEG` | the bundled binary |
 
 There is no login. Binding to anything but `127.0.0.1` hands the app and every key in

package/dist/adapter-registry.js

@@ -1,3 +1,4 @@
+import { tmpdir } from "node:os";
 import { codexImage } from "./adapters/image/codex.js";
 import { falImage } from "./adapters/image/fal.js";
 import { googleImage } from "./adapters/image/google.js";
@@ -13,9 +14,13 @@ import { nodeGeminiModels } from "./adapters/llm/gemini-models.js";
 import { openRouterLlm } from "./adapters/llm/openrouter.js";
 import { cartesiaTts } from "./adapters/tts/cartesia.js";
 import { elevenLabsTts } from "./adapters/tts/elevenlabs.js";
+import { geminiTts } from "./adapters/tts/gemini.js";
 import { inworldTts } from "./adapters/tts/inworld.js";
 import { openAiTts } from "./adapters/tts/openai.js";
+import { ffmpegPcmToMp3 } from "./adapters/tts/pcm-mp3.js";
+import { systemTts, systemVoiceId } from "./adapters/tts/system.js";
 import { hostLlmIds } from "./kernel/ports/host-cli.js";
+import { detectSpeechCached } from "./kernel/ports/system-speech.js";
 import { cliBinary } from "./slices/settings/cli-paths.js";
 import { keyForAttempt } from "./slices/settings/keys.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
@@ -63,6 +68,28 @@ export function buildRegistry(deps) {
         ["openai-tts", openAiTts({ fetch: deps.fetch, key: keyOf("openai-tts") })],
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
         ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
+        // No key: the speech program this computer has, run like a CLI.
+        [
+            systemVoiceId,
+            systemTts({
+                detect: () => detectSpeechCached(deps.probe, deps.host ?? process),
+                run: deps.spawn,
+                ffmpeg: deps.ffmpeg,
+                tempRoot: tmpdir(),
+                env: (deps.host ?? process).env,
+            }),
+        ],
+        // Its own key, or else the one saved for Google images (`sharedKeyOf`).
+        [
+            "google-tts",
+            geminiTts({
+                fetch: deps.fetch,
+                key: keyOf("google-tts"),
+                toMp3: deps.ffmpeg === undefined
+                    ? () => Promise.reject(new Error("ffmpeg is not available to encode Gemini speech"))
+                    : ffmpegPcmToMp3(deps.ffmpeg),
+            }),
+        ],
     ]);
     // Keyed image providers receive only their own key; Codex uses the shared CLI login.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has
@@ -100,6 +127,7 @@ export function buildRegistry(deps) {
             db: deps.db,
             probe: deps.probe,
             hostCliStatus: deps.hostCli?.status,
+            host: deps.host,
         })).map((status) => ({
             family: status.family,
             id: status.id,

package/dist/adapters/alignment/text.js

@@ -53,7 +53,9 @@ export function speechWords(text, observed = "", aliases = [], formsOf = wordFor
     }
     if (words.length === 0)
         throw new Error(empty);
-    return words.map(({ text: shown, spoken, forms }) => forms.length > 1 ? { text: shown, spoken, forms } : { text: shown, spoken });
+    // An aliased word keeps its forms even when there is one: `respoken` would otherwise read
+    // the written text again without the aliases, and "&" alone says nothing.
+    return words.map(({ text: shown, spoken, forms, aliased }) => forms.length > 1 || aliased ? { text: shown, spoken, forms } : { text: shown, spoken });
 }
 // The form of a word the recording seems to say, else its default.
 export function respoken(word, observed, formsOf = wordForms) {

package/dist/adapters/key-probes.js

@@ -4,25 +4,74 @@ import { cartesiaVersion } from "./tts/cartesia.js";
 // invalid_api_key, Inworld with 403 "does not exist". Observed on 2026-09-27; their
 // documentation says 401.
 const bearer = (key) => ({ Authorization: `Bearer ${key}` });
+// Health check → "Model reachable": one read per chosen model, or one of the list. A model's
+// own page answers 404 when the key can't use it.
+const openAiModel = {
+    url: (model) => `https://api.openai.com/v1/models/${encodeURIComponent(model)}`,
+};
+function listed(ids) {
+    return (body, model) => {
+        try {
+            const found = ids(JSON.parse(body));
+            return found.length === 0 ? undefined : found.includes(model);
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+const field = (value, key) => typeof value === "object" && value !== null ? value[key] : undefined;
+const google = {
+    url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
+    headers: (key) => ({ "x-goog-api-key": key }),
+    badKey: (status, body) => status === 400 && body.includes("API_KEY_INVALID"),
+    model: {
+        url: (model) => `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model.replace(/^models\//, ""))}`,
+    },
+};
 export const keyProbes = {
-    openrouter: { url: "https://openrouter.ai/api/v1/key", headers: bearer },
-    "openai-tts": { url: "https://api.openai.com/v1/models", headers: bearer },
-    "openai-image": { url: "https://api.openai.com/v1/models", headers: bearer },
-    "google-image": {
-        url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
-        headers: (key) => ({ "x-goog-api-key": key }),
-        badKey: (status, body) => status === 400 && body.includes("API_KEY_INVALID"),
+    openrouter: {
+        url: "https://openrouter.ai/api/v1/key",
+        headers: bearer,
+        model: {
+            url: () => "https://openrouter.ai/api/v1/models",
+            lists: listed((body) => {
+                const data = field(body, "data");
+                return Array.isArray(data) ? data.map((one) => field(one, "id")) : [];
+            }),
+        },
     },
+    "openai-tts": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
+    "openai-image": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
+    "google-image": google,
+    "google-tts": google,
     // fal.ai's model list answers without a key; its price lookup requires one.
     fal: {
         url: "https://api.fal.ai/v1/models/pricing?endpoint_id=fal-ai/flux/dev",
         headers: (key) => ({ Authorization: `Key ${key}` }),
+        model: {
+            url: (model) => `https://api.fal.ai/v1/models/pricing?endpoint_id=${encodeURIComponent(model)}`,
+        },
+    },
+    replicate: {
+        url: "https://api.replicate.com/v1/account",
+        headers: bearer,
+        // "owner/name", without a ":version".
+        model: {
+            url: (model) => `https://api.replicate.com/v1/models/${(model.split(":")[0] ?? model)
+                .split("/")
+                .map(encodeURIComponent)
+                .join("/")}`,
+        },
     },
-    replicate: { url: "https://api.replicate.com/v1/account", headers: bearer },
     elevenlabs: {
         url: "https://api.elevenlabs.io/v1/models",
         headers: (key) => ({ "xi-api-key": key }),
         badKey: (status, body) => status === 400 && body.includes("invalid_api_key"),
+        model: {
+            url: () => "https://api.elevenlabs.io/v1/models",
+            lists: listed((body) => Array.isArray(body) ? body.map((one) => field(one, "model_id")) : []),
+        },
     },
     cartesia: {
         url: "https://api.cartesia.ai/voices?limit=1",

package/dist/adapters/tts/gemini.js

@@ -0,0 +1,206 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { httpFailure, internalError, missingKey, noAudio, providerSaid, refreshList, unreadable, voiceFix, } from "../explain.js";
+import { retryAfter } from "../retry-after.js";
+// The HTTP gateway adapter for Gemini's speech generation (generateContent with an AUDIO
+// response, https://ai.google.dev/gemini-api/docs/speech-generation), billed to a Gemini API
+// key. One voice is `speechConfig.voiceConfig`; a conversation of exactly two voices is
+// `speechConfig.multiSpeakerVoiceConfig`, Gemini's native two-speaker narration. The answer is
+// raw 16-bit mono PCM (24 kHz), which the port cannot carry, so it is encoded to MP3 by the
+// injected encoder before it is handed back.
+export const geminiTtsBase = "https://generativelanguage.googleapis.com/v1beta";
+export const geminiTtsModel = "gemini-2.5-flash-preview-tts";
+// Offline choices only; the picker normally loads the provider catalogue.
+export const geminiTtsModels = [
+    { id: "gemini-3.1-flash-tts-preview", name: "Gemini 3.1 Flash TTS (preview)" },
+    { id: "gemini-2.5-flash-preview-tts", name: "Gemini 2.5 Flash TTS (preview)" },
+    { id: "gemini-2.5-pro-preview-tts", name: "Gemini 2.5 Pro TTS (preview)" },
+];
+// multiSpeakerVoiceConfig takes exactly two speakers.
+export const geminiDialogueVoices = 2;
+const defaultSampleRate = 24_000;
+const inlineData = z.object({ mimeType: z.string().nullish(), data: z.string().nullish() });
+const answer = z.object({
+    candidates: z
+        .array(z.object({
+        content: z
+            .object({ parts: z.array(z.object({ inlineData: inlineData.nullish() })).nullish() })
+            .nullish(),
+        finishReason: z.string().nullish(),
+    }))
+        .nullish(),
+    promptFeedback: z.object({ blockReason: z.string().nullish() }).nullish(),
+});
+const modelList = z.object({
+    models: z
+        .array(z.object({
+        name: z.string(),
+        displayName: z.string().nullish(),
+        supportedGenerationMethods: z.array(z.string()).nullish(),
+    }))
+        .nullish(),
+});
+const errorBody = z.object({
+    error: z.object({ message: z.string().nullish(), status: z.string().nullish() }),
+});
+export function geminiTts(deps) {
+    return {
+        id: "google-tts",
+        capabilities: { streams: false, dialogue: true },
+        models: async () => {
+            const response = await deps.fetch(`${geminiTtsBase}/models?pageSize=1000`, {
+                headers: { "x-goog-api-key": keyOf(deps) },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw await failure(response, undefined, refreshList);
+            const parsed = modelList.safeParse(safeJson(await response.text()));
+            if (!parsed.success)
+                throw providerError({ kind: "other", message: unreadable("Google") });
+            return (parsed.data.models ?? [])
+                .filter((model) => /-tts\b|tts-/.test(model.name) &&
+                (model.supportedGenerationMethods ?? ["generateContent"]).includes("generateContent"))
+                .map((model) => {
+                const id = model.name.replace(/^models\//, "");
+                return { id, name: model.displayName || id };
+            });
+        },
+        synthesize: async (req) => {
+            const model = req.model ?? geminiTtsModel;
+            const response = await deps.fetch(`${geminiTtsBase}/models/${encodeURIComponent(model)}:generateContent`, {
+                method: "POST",
+                signal: req.signal,
+                // The key rides Google's own header rather than the query string, which would put it
+                // in every proxy log on the way.
+                headers: { "x-goog-api-key": keyOf(deps), "Content-Type": "application/json" },
+                body: JSON.stringify(geminiSpeechBody(req)),
+            });
+            if (!response.ok)
+                throw await failure(response, req.voiceId);
+            const { pcm, sampleRate } = audioOf(await response.text());
+            const mp3 = await deps.toMp3(pcm, sampleRate, req.signal);
+            return { audio: streamOf(mp3), container: "mp3" };
+        },
+    };
+}
+// The request body. A dialogue of two voices names each voice as its speaker, since the
+// transcript's speaker names must match `speakerVoiceConfigs`; a dialogue whose lines all share
+// one voice is that voice reading the lines. More than two voices is a grouping bug upstream.
+export function geminiSpeechBody(req) {
+    const voices = [...new Set((req.dialogue ?? []).map((line) => line.voiceId))];
+    if (voices.length > geminiDialogueVoices)
+        throw providerError({
+            kind: "unsupported",
+            message: internalError(`a Gemini narration request had ${String(voices.length)} voices; Gemini takes at most two`),
+        });
+    const prebuilt = (voiceName) => ({ prebuiltVoiceConfig: { voiceName } });
+    const two = req.dialogue !== undefined && voices.length === geminiDialogueVoices;
+    const text = req.dialogue === undefined
+        ? req.text
+        : two
+            ? conversation(req.dialogue, voices)
+            : req.dialogue.map((line) => line.text).join("\n");
+    return {
+        contents: [{ parts: [{ text }] }],
+        generationConfig: {
+            responseModalities: ["AUDIO"],
+            speechConfig: two
+                ? {
+                    multiSpeakerVoiceConfig: {
+                        speakerVoiceConfigs: voices.map((voice) => ({
+                            speaker: voice,
+                            voiceConfig: prebuilt(voice),
+                        })),
+                    },
+                }
+                : { voiceConfig: prebuilt(req.dialogue?.[0]?.voiceId ?? req.voiceId) },
+        },
+    };
+}
+function conversation(lines, voices) {
+    return [
+        `TTS the following conversation between ${voices.join(" and ")}:`,
+        ...lines.map((line) => `${line.voiceId}: ${line.text.replace(/\s*\n\s*/g, " ")}`),
+    ].join("\n");
+}
+function audioOf(text) {
+    const parsed = answer.safeParse(safeJson(text));
+    if (!parsed.success)
+        throw providerError({ kind: "other", message: unreadable("Google") });
+    const blocked = parsed.data.promptFeedback?.blockReason;
+    if (blocked)
+        throw providerError({
+            kind: "refusal",
+            message: providerSaid("Google", "refused to speak this narration under its content rules", blocked, "Reword that part of the script or article, or choose another voice provider under Speakers (Edit project → Providers)."),
+        });
+    for (const candidate of parsed.data.candidates ?? [])
+        for (const part of candidate.content?.parts ?? []) {
+            const data = part.inlineData?.data;
+            if (data) {
+                const rate = /rate=(\d+)/.exec(part.inlineData?.mimeType ?? "")?.[1];
+                return {
+                    pcm: new Uint8Array(Buffer.from(data, "base64")),
+                    sampleRate: rate === undefined ? defaultSampleRate : Number(rate),
+                };
+            }
+        }
+    throw providerError({ kind: "other", message: noAudio("Google") });
+}
+function streamOf(bytes) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(bytes);
+            controller.close();
+        },
+    });
+}
+function keyOf(deps) {
+    // `missing_key`, not `auth`, because that rule makes it terminal.
+    const key = deps.key();
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: missingKey("Google") });
+    }
+    return key;
+}
+function kindOf(status) {
+    if (status === 401 || status === 403)
+        return "auth";
+    if (status === 429)
+        return "rate_limit";
+    if (status >= 500)
+        return "dropped";
+    return "other";
+}
+async function failure(response, voiceId, next) {
+    const text = await response.text().catch(() => "");
+    const parsed = errorBody.safeParse(safeJson(text));
+    // Through the redactor: an error body may quote the key back.
+    const detail = redact((parsed.success ? parsed.data.error.message : undefined) ??
+        (text.trim() || response.statusText));
+    // Google answers an unknown key with 400 API_KEY_INVALID rather than 401.
+    const badKey = response.status === 400 && text.includes("API_KEY_INVALID");
+    const status = badKey ? 401 : response.status;
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    return providerError({
+        kind: badKey ? "auth" : kindOf(response.status),
+        message: httpFailure({
+            provider: "Google",
+            status,
+            detail,
+            next,
+            ...(voiceId === undefined
+                ? {}
+                : { subject: `narration request for voice "${voiceId}"`, fix: voiceFix(voiceId) }),
+        }),
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/tts/pcm-mp3.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { providerError } from "../../kernel/ports/model.js";
+// Raw 16-bit mono PCM in on stdin, MP3 out on stdout, through the app's own ffmpeg. The bitrate
+// is the one the narration join re-encodes at (`slices/narration/concat.ts`).
+export function pcmToMp3Args(sampleRate) {
+    return [
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-f",
+        "s16le",
+        "-ar",
+        String(sampleRate),
+        "-ac",
+        "1",
+        "-i",
+        "pipe:0",
+        "-c:a",
+        "libmp3lame",
+        "-b:a",
+        "128k",
+        "-f",
+        "mp3",
+        "pipe:1",
+    ];
+}
+export function ffmpegPcmToMp3(bin) {
+    return (pcm, sampleRate, signal) => new Promise((resolve, reject) => {
+        const child = spawn(bin, pcmToMp3Args(sampleRate), {
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            signal,
+        });
+        const out = [];
+        let err = "";
+        child.stdout.on("data", (chunk) => out.push(chunk));
+        child.stderr.on("data", (chunk) => {
+            err = `${err}${chunk.toString("utf8")}`.slice(-2000);
+        });
+        child.on("error", (error) => {
+            reject(signal.aborted
+                ? error
+                : providerError({
+                    kind: "other",
+                    message: `Slopify could not turn Google's audio into MP3 because ffmpeg did not start (${error.message}). Restart Slopify; if it keeps happening, use Download diagnostics in Settings and report it.`,
+                }));
+        });
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve(new Uint8Array(Buffer.concat(out)));
+            else if (!signal.aborted)
+                reject(providerError({
+                    kind: "other",
+                    message: `Slopify could not turn Google's audio into MP3 (ffmpeg: ${err.trim() || `exit ${String(code)}`}). Use Try again; if it keeps happening, use Download diagnostics in Settings and report it.`,
+                }));
+        });
+        // A closed stdin (ffmpeg gave up early) is reported by the close handler.
+        child.stdin.on("error", () => { });
+        child.stdin.end(Buffer.from(pcm));
+    });
+}

package/dist/adapters/tts/system.js

@@ -0,0 +1,147 @@
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { providerError } from "../../kernel/ports/model.js";
+import { defaultSpeechVoice, noSpeechFix, primaryLanguage, } from "../../kernel/ports/system-speech.js";
+export const systemVoiceId = "system-voice";
+// Windows speaks through System.Speech. Every input arrives in an environment variable, so no
+// part of the text or the voice name is ever parsed as PowerShell.
+export const windowsSpeakScript = "Add-Type -AssemblyName System.Speech; $s = New-Object System.Speech.Synthesis.SpeechSynthesizer; try { $s.SelectVoice($env:SLOPIFY_SPEECH_VOICE); $s.SetOutputToWaveFile($env:SLOPIFY_SPEECH_OUT); $s.Speak([System.IO.File]::ReadAllText($env:SLOPIFY_SPEECH_TEXT, [System.Text.Encoding]::UTF8)) } finally { $s.Dispose() }";
+// The program's command for one request. Text goes through a file (or stdin for Piper, an
+// argument for Pico, which takes nothing else), so a line starting with "-" is never a flag.
+export function speakCommand(engine, voice, files, text, env) {
+    switch (engine.id) {
+        case "say":
+            return { binary: "say", args: ["-v", voice.id, "-o", files.out, "-f", files.text] };
+        case "sapi":
+            return {
+                binary: "powershell",
+                args: ["-NoProfile", "-NonInteractive", "-Command", windowsSpeakScript],
+                env: {
+                    ...env,
+                    SLOPIFY_SPEECH_VOICE: voice.id,
+                    SLOPIFY_SPEECH_OUT: files.out,
+                    SLOPIFY_SPEECH_TEXT: files.text,
+                },
+            };
+        case "piper":
+            return {
+                binary: "piper",
+                args: ["--model", voice.id, "--output_file", files.out],
+                stdin: text,
+            };
+        case "pico2wave":
+            return { binary: "pico2wave", args: ["-l", voice.id, "-w", files.out, "--", text] };
+        case "espeak-ng":
+        case "espeak":
+            return { binary: engine.id, args: ["-v", voice.id, "-w", files.out, "-f", files.text] };
+    }
+}
+export function systemTts(deps) {
+    const engineFor = async (model) => {
+        const found = await deps.detect();
+        const engine = model === undefined || model === ""
+            ? found.engines[0]
+            : found.engines.find((one) => one.id === model);
+        if (engine !== undefined)
+            return engine;
+        throw providerError({
+            kind: "unavailable",
+            message: found.engines.length === 0
+                ? (found.issue ?? `No speech program was found on this computer, ${noSpeechFix}`)
+                : `The speech program "${model}" chosen for this narration isn't on this computer any more. In the Edit tab, choose Edit project and pick another System voice model (${found.engines.map((one) => one.name).join(", ")}) under Providers, then use Continue the run.`,
+        });
+    };
+    return {
+        id: systemVoiceId,
+        capabilities: { streams: false },
+        models: async () => (await deps.detect()).engines.map((engine) => ({ id: engine.id, name: engine.name })),
+        voiceLanguages: async (voiceId) => {
+            try {
+                const found = await deps.detect();
+                for (const engine of found.engines) {
+                    const voice = engine.voices.find((one) => one.id === voiceId);
+                    const language = voice === undefined ? undefined : primaryLanguage(voice);
+                    if (language !== undefined)
+                        return [language];
+                }
+            }
+            catch {
+                // Never throws: an unknown answer is undefined.
+            }
+            return undefined;
+        },
+        synthesize: async (req) => {
+            const engine = await engineFor(req.model);
+            const voice = engine.voices.find((one) => one.id === req.voiceId) ??
+                (req.voiceId === "" || req.voiceId === "default" ? defaultSpeechVoice(engine) : undefined);
+            if (voice === undefined)
+                throw providerError({
+                    kind: "unsupported",
+                    message: `The system voice "${req.voiceId}" isn't installed for ${engine.name} on this computer. Pick one it has in Settings → Voices (Add voice, provider System voice), then choose it for this project and use Continue the run.`,
+                });
+            if (deps.ffmpeg === undefined)
+                throw providerError({
+                    kind: "unavailable",
+                    message: "Slopify's ffmpeg isn't ready, so the system voice's recording can't be converted. Restart Slopify and try again.",
+                });
+            const dir = await mkdtemp(join(deps.tempRoot, "slopify-speech-"));
+            try {
+                const files = {
+                    text: join(dir, "text.txt"),
+                    out: join(dir, engine.id === "say" ? "speech.aiff" : "speech.wav"),
+                };
+                await writeFile(files.text, req.text, "utf8");
+                await runToEnd(deps.run, speakCommand(engine, voice, files, req.text, deps.env), req.signal, engine.name);
+                const mp3 = join(dir, "speech.mp3");
+                await runToEnd(deps.run, {
+                    binary: deps.ffmpeg,
+                    args: [
+                        "-hide_banner",
+                        "-loglevel",
+                        "error",
+                        "-y",
+                        "-i",
+                        files.out,
+                        "-codec:a",
+                        "libmp3lame",
+                        "-q:a",
+                        "4",
+                        mp3,
+                    ],
+                }, req.signal, "ffmpeg");
+                const bytes = new Uint8Array(await readFile(mp3));
+                return { audio: streamOf(bytes), container: "mp3" };
+            }
+            finally {
+                await rm(dir, { recursive: true, force: true });
+            }
+        },
+    };
+}
+async function runToEnd(run, command, signal, label) {
+    const child = run(command.binary, command.args, signal, {
+        ...(command.stdin === undefined ? {} : { stdin: command.stdin }),
+        ...(command.env === undefined ? {} : { env: { ...command.env } }),
+    });
+    // Drained so a chatty program never blocks on a full pipe.
+    for await (const _ of child.stdout) {
+        // nothing to keep
+    }
+    const ended = await child.ended;
+    signal.throwIfAborted();
+    if (ended.error !== null || ended.code !== 0) {
+        const said = child.stderr().trim().split(/\r?\n/).slice(-3).join(" ");
+        throw providerError({
+            kind: "other",
+            message: `The system voice (${label}) couldn't make this narration${said === "" ? (ended.error === null ? "" : `: ${ended.error.message}`) : `: ${said}`}. Try another system voice in Settings → Voices, ${noSpeechFix}`,
+        });
+    }
+}
+function streamOf(bytes) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(bytes);
+            controller.close();
+        },
+    });
+}

package/dist/assets/models.yaml

@@ -14,6 +14,8 @@ providers:
     maxConcurrent: 3
   inworld:
     maxConcurrent: 5
+  google-tts:
+    maxConcurrent: 3
   fal:
     maxConcurrent: 3
   replicate:
@@ -435,3 +437,39 @@ tts:
     tts:
       maxCharacters: 4096
       streaming: true
+  - provider: google-tts
+    id: gemini-2.5-flash-preview-tts
+    name: Gemini 2.5 Flash TTS (preview)
+    source: https://ai.google.dev/gemini-api/docs/speech-generation
+    keywords:
+      - tts
+    pricing:
+      note: Billed per text token in and audio token out on your Gemini API key; estimate
+        unavailable.
+    tts:
+      maxCharacters: 4000
+      streaming: false
+  - provider: google-tts
+    id: gemini-2.5-pro-preview-tts
+    name: Gemini 2.5 Pro TTS (preview)
+    source: https://ai.google.dev/gemini-api/docs/speech-generation
+    keywords:
+      - tts
+    pricing:
+      note: Billed per text token in and audio token out on your Gemini API key; estimate
+        unavailable.
+    tts:
+      maxCharacters: 4000
+      streaming: false
+  - provider: google-tts
+    id: gemini-3.1-flash-tts-preview
+    name: Gemini 3.1 Flash TTS (preview)
+    source: https://ai.google.dev/gemini-api/docs/speech-generation
+    keywords:
+      - tts
+    pricing:
+      note: Billed per text token in and audio token out on your Gemini API key; estimate
+        unavailable.
+    tts:
+      maxCharacters: 4000
+      streaming: false