@gentbajko/slopify 2.5.0 → 3.0.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/inworld-async.js

@@ -23,7 +23,7 @@ export async function* inworldAsync(deps, request, key) {
     if (saved === undefined && request.text.length > 100_000) {
         throw providerError({
             kind: "unsupported",
-            message: "This narration part is longer than the 100,000 characters Inworld takes at once (10,000 on On-Demand accounts). Set Chunking to Paragraph in the Providers section of Edit project, then use Retry stage.",
+            message: "This narration part is longer than the 100,000 characters Inworld takes at once (10,000 on On-Demand accounts). Set Chunking to Paragraph in the Providers section of Edit project, then use Try again.",
         });
     }
     const headers = { Authorization: `Basic ${key}`, "Content-Type": "application/json" };
@@ -68,7 +68,9 @@ export async function* inworldAsync(deps, request, key) {
                             ? "rate_limit"
                             : code === 3 || code === 5 || code === 9
                                 ? "unsupported"
-                                : "other",
+                                : code === 14
+                                    ? "dropped"
+                                    : "other",
                     message: streamFailure(code, clean(message ?? "", key), request.voiceId),
                 });
             }
@@ -141,7 +143,9 @@ async function check(response, key, voiceId) {
                 ? "rate_limit"
                 : response.status === 400 || response.status === 404
                     ? "unsupported"
-                    : "other",
+                    : response.status >= 500
+                        ? "dropped"
+                        : "other",
         message: httpFailure({
             provider: "Inworld",
             status: response.status,
@@ -160,7 +164,7 @@ function clean(message, key) {
 function downloadFailed(status) {
     return providerError({
         kind: "other",
-        message: `Inworld made the narration, but Slopify could not download it${status}. Check your internet connection, then use Retry stage.`,
+        message: `Inworld made the narration, but Slopify could not download it${status}. Check your internet connection, then use Try again.`,
     });
 }
 function unreadableAnswer() {
@@ -177,5 +181,5 @@ export function streamFailure(code, detail, voiceId) {
         return httpFailure({ provider: "Inworld", status: 429, detail, label });
     if (code === 3 || code === 5 || code === 9)
         return providerSaid("Inworld", "could not narrate this text", detail, voiceFix(voiceId));
-    return providerSaid("Inworld", "stopped before the narration was finished", detail, "This is usually temporary: wait a few minutes, then use Retry stage.");
+    return providerSaid("Inworld", "stopped before the narration was finished", detail, "This is usually temporary: wait a few minutes, then use Try again.");
 }

package/dist/adapters/tts/inworld.js

@@ -4,6 +4,7 @@ import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noAudio, unreadable, voiceFix } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { inworldAsync, streamFailure } from "./inworld-async.js";
+import { inworldLanguages, lookUp } from "./voice-languages.js";
 export const inworldModels = [
     { id: "inworld-tts-2", name: "Realtime TTS-2" },
     { id: "inworld-tts-2-flash", name: "Realtime TTS-2 Flash" },
@@ -16,6 +17,15 @@ export function inworldTts(deps) {
     return {
         id: "inworld",
         capabilities: { streams: true },
+        voiceLanguages: async (voiceId, signal) => {
+            const key = deps
+                .key()
+                ?.trim()
+                .replace(/^Basic\s+/i, "");
+            if (!key)
+                return undefined;
+            return inworldLanguages(await lookUp(deps.fetch, `https://api.inworld.ai/voices/v1/voices/${encodeURIComponent(voiceId)}`, { Authorization: `Basic ${key}` }, signal));
+        },
         models: async () => inworldModels,
         synthesize: async (request) => {
             const key = deps
@@ -59,7 +69,7 @@ async function* synthesizeRequest(deps, request, key) {
     if (request.text.trim().length === 0)
         throw providerError({
             kind: "unsupported",
-            message: "Inworld was sent an empty piece of narration. Check the article has text in the Article section of Edit project, then use Retry stage.",
+            message: "Inworld was sent an empty piece of narration. Check the article has text in the Article section of Edit project, then use Try again.",
         });
     if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
         yield* inworldAsync(deps, request, key);
@@ -93,7 +103,9 @@ async function* synthesizeRequest(deps, request, key) {
                     ? "rate_limit"
                     : response.status === 400 || response.status === 404
                         ? "unsupported"
-                        : "other",
+                        : response.status >= 500
+                            ? "dropped"
+                            : "other",
             message: clean(httpFailure({
                 provider: "Inworld",
                 status: response.status,
@@ -128,7 +140,9 @@ async function* synthesizeRequest(deps, request, key) {
                         ? "rate_limit"
                         : code === 3 || code === 5
                             ? "unsupported"
-                            : "other",
+                            : code === 14
+                                ? "dropped"
+                                : "other",
                 message: streamFailure(code, clean(message ?? "", key), request.voiceId),
             });
         }

package/dist/adapters/tts/openai.js

@@ -95,6 +95,9 @@ function kindOf(status) {
     }
     // ceiling: as in the OpenRouter adapter, a 400 is retried three more times because the
     // port's error contract has no terminal kind for a request that cannot be repaired.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
     return "other";
 }
 async function failure(response, voiceId, next) {

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/adapters/tts/voice-languages.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+// What each provider's voice API says a voice speaks, reduced to lower-case primary language
+// subtags ("es-MX" and "ES_MX" are both "es"). Undefined when the provider said nothing
+// usable: an unknown voice speaks every language as far as the app is concerned.
+export function primaryLanguages(values) {
+    const codes = values.flatMap((value) => {
+        const code = value?.trim().split(/[-_]/)[0]?.toLowerCase();
+        return code !== undefined && /^[a-z]{2,3}$/.test(code) ? [code] : [];
+    });
+    return codes.length === 0 ? undefined : [...new Set(codes)];
+}
+// Asks once, briefly: the answer only fills a hint in Settings → Voices, so a slow or failed
+// lookup is simply no answer.
+export async function lookUp(fetcher, url, headers, signal) {
+    try {
+        const response = await fetcher(url, {
+            headers,
+            signal: AbortSignal.any([signal, AbortSignal.timeout(8000)]),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return undefined;
+        }
+        return await response.json();
+    }
+    catch {
+        signal.throwIfAborted();
+        return undefined;
+    }
+}
+// GET /v1/voices/{id}: `verified_languages[].language` (or `.locale`), and the older
+// `labels.language` and `fine_tuning.language`.
+const elevenLabsVoice = z.object({
+    verified_languages: z
+        .array(z.object({ language: z.string().nullish(), locale: z.string().nullish() }))
+        .nullish(),
+    labels: z.object({ language: z.string().nullish() }).partial().nullish(),
+    fine_tuning: z.object({ language: z.string().nullish() }).partial().nullish(),
+});
+export function elevenLabsLanguages(body) {
+    const parsed = elevenLabsVoice.safeParse(body);
+    if (!parsed.success)
+        return undefined;
+    return primaryLanguages([
+        ...(parsed.data.verified_languages ?? []).flatMap((one) => [one.language, one.locale]),
+        parsed.data.labels?.language,
+        parsed.data.fine_tuning?.language,
+    ]);
+}
+// GET /voices/{id}: `language` (ISO 639-1) and `accents[].locale`.
+const cartesiaVoice = z.object({
+    language: z.string().nullish(),
+    accents: z.array(z.object({ locale: z.string().nullish() })).nullish(),
+});
+export function cartesiaLanguages(body) {
+    const parsed = cartesiaVoice.safeParse(body);
+    if (!parsed.success)
+        return undefined;
+    return primaryLanguages([
+        parsed.data.language,
+        ...(parsed.data.accents ?? []).map((one) => one.locale),
+    ]);
+}
+// GET /voices/v1/voices/{id}: `languageCode` ("en-US"), `langCode` ("EN_US") and, for a
+// multilingual voice, `promptLanguages`.
+const inworldVoice = z.object({
+    languageCode: z.string().nullish(),
+    langCode: z.string().nullish(),
+    promptLanguages: z.array(z.string()).nullish(),
+});
+export function inworldLanguages(body) {
+    const parsed = inworldVoice.safeParse(typeof body === "object" && body !== null && "voice" in body ? body.voice : body);
+    if (!parsed.success)
+        return undefined;
+    return primaryLanguages([
+        parsed.data.languageCode,
+        parsed.data.langCode,
+        ...(parsed.data.promptLanguages ?? []),
+    ]);
+}