@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/settings/first-run.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { readinessIsUsable } from "../../kernel/ports/model.js";
+import { keyedProviders, readSetting, writeSetting } from "./repo.js";
+// What a fresh Play form picks before the user picks anything. Written once, on the first
+// launch that finds a command-line tool, and read by Play for every new draft.
+const choiceSchema = z.object({ provider: z.string().min(1), model: z.string() }).strict();
+export const providerDefaultsSchema = z
+    .object({ llm: choiceSchema.optional(), images: choiceSchema.optional() })
+    .strict();
+export const providerDefaultsKey = "provider.defaults";
+const defaultsKey = providerDefaultsKey;
+const doneKey = "first-run.done";
+// The order a text tool is preferred in when several are found.
+const textPreference = ["claude-code", "codex", "gemini"];
+export function readProviderDefaults(db) {
+    const raw = readSetting(db, defaultsKey);
+    if (raw === undefined)
+        return {};
+    try {
+        const parsed = providerDefaultsSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function dismissFirstRun(db) {
+    writeSetting(db, doneKey, "1");
+}
+// First launch: find Claude Code, Codex and Gemini, pick the found ones as Play's defaults, and
+// say a video can be made without any API key. Later launches only report what was found.
+export async function firstRunStatus(deps, statuses) {
+    const detected = statuses
+        .filter((status) => status.readiness.kind === "cli")
+        .map((status) => {
+        const readiness = status.readiness;
+        if (readiness.kind !== "cli")
+            throw new Error("Expected a command-line provider.");
+        return {
+            id: status.id,
+            displayName: status.id === "codex-image" ? "Codex CLI (images)" : status.displayName,
+            installed: readiness.installed,
+            usable: readinessIsUsable(readiness),
+            ...(readiness.version === undefined ? {} : { version: readiness.version }),
+            ...(readiness.issue === undefined ? {} : { issue: readiness.issue }),
+        };
+    });
+    const firstRun = keyedProviders(deps.db).size === 0 && readSetting(deps.db, doneKey) === undefined;
+    let defaults = readProviderDefaults(deps.db);
+    const usable = new Set(detected.filter((cli) => cli.usable).map((cli) => cli.id));
+    const text = textPreference.find((id) => usable.has(id));
+    if (firstRun &&
+        readSetting(deps.db, defaultsKey) === undefined &&
+        (text !== undefined || usable.has("codex-image"))) {
+        defaults = {
+            ...(text === undefined
+                ? {}
+                : { llm: { provider: text, model: await firstModel(deps, text, "llm") } }),
+            ...(usable.has("codex-image")
+                ? {
+                    images: {
+                        provider: "codex-image",
+                        model: await firstModel(deps, "codex-image", "image"),
+                    },
+                }
+                : {}),
+        };
+        writeSetting(deps.db, defaultsKey, JSON.stringify(defaults));
+    }
+    const names = detected
+        .filter((cli) => cli.usable && cli.id !== "codex-image")
+        .map((cli) => cli.displayName);
+    return {
+        firstRun,
+        detected,
+        defaults,
+        message: !firstRun
+            ? null
+            : names.length > 0
+                ? "You can make a video now, no API keys needed."
+                : "No AI command-line tool was found on this computer.",
+        detail: !firstRun
+            ? null
+            : names.length > 0
+                ? `Slopify found ${list(names)} and picked ${names.length === 1 ? "it" : "them"} on Play. Narration still needs a voice provider key, or turn Audio off or upload your own. Keys are optional extras in Settings → Providers.`
+                : "Install Claude Code, Codex or Gemini CLI and sign in once in a terminal, then reload this page. Or paste an API key in Settings → Providers.",
+    };
+}
+async function firstModel(deps, provider, family) {
+    try {
+        return (await deps.modelsFor?.(provider, family))?.[0]?.id ?? "";
+    }
+    catch {
+        // The picker shows the tool's list once it answers; the provider is still chosen.
+        return "";
+    }
+}
+function list(names) {
+    return names.length <= 1
+        ? (names[0] ?? "")
+        : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}

package/dist/slices/settings/health.js

@@ -0,0 +1,190 @@
+import { choiceSites, retiredModelUsage, slotLabels, } from "../model-upkeep/usage.js";
+import { cliPathStatus } from "./cli-paths.js";
+import { keyGuides } from "./key-guides.js";
+import { testProviderKey } from "./key-test.js";
+import { isLocalCliProvider } from "./model.js";
+import { providerStatuses } from "./readiness.js";
+const signInCommand = {
+    "claude-code": "claude auth login",
+    codex: "codex login",
+    gemini: "gemini",
+};
+function loginSource(id) {
+    return id === "codex-image" ? "codex" : id;
+}
+// Where each provider's models are chosen, as "Text model in template “Weekly”".
+function uses(db) {
+    const found = new Map();
+    for (const site of choiceSites(db))
+        for (const [slot, choice] of Object.entries(site.choices)) {
+            if (choice === undefined || choice.provider === "" || choice.model.trim() === "")
+                continue;
+            // Images drawn by Codex use the image provider id; the text choice uses the CLI's own.
+            const list = found.get(choice.provider) ?? [];
+            list.push({
+                model: choice.model,
+                where: `${slotLabels[slot]} in ${site.kind} “${site.name}”`,
+            });
+            found.set(choice.provider, list);
+        }
+    return found;
+}
+function overall(checks, used, setUp) {
+    if (checks.some((check) => check.state === "problem"))
+        return "problem";
+    if (checks.some((check) => check.state === "warning"))
+        return "warning";
+    return setUp || used ? "ok" : "unused";
+}
+// "Check all" on Settings → Providers: each command-line tool found and signed in, each saved
+// key accepted by its provider, and each chosen model still offered.
+export async function checkProviderHealth(deps) {
+    const statuses = await providerStatuses(deps);
+    const inUse = uses(deps.db);
+    const catalogue = deps.catalogue?.();
+    const retired = catalogue === undefined ? [] : retiredModelUsage(deps.db, catalogue);
+    const providers = await Promise.all(statuses.map((status) => status.readiness.kind === "cli"
+        ? cliHealth(deps, status, inUse.get(status.id) ?? [])
+        : keyedHealth(deps, status, inUse.get(status.id) ?? [], retired)));
+    return { checkedAt: deps.clock.now().toISOString(), providers };
+}
+async function cliHealth(deps, status, used) {
+    const { readiness } = status;
+    if (readiness.kind !== "cli" || !isLocalCliProvider(status.id))
+        throw new Error("Expected a command-line provider.");
+    const name = status.displayName;
+    const command = status.cliPath?.command ?? loginSource(status.id);
+    const checks = [];
+    const base = { id: status.id, displayName: name, family: status.family };
+    if (!readiness.installed ||
+        readiness.issueKind === "missing" ||
+        readiness.issueKind === "bridge") {
+        checks.push({
+            label: "Installed",
+            state: used.length > 0 ? "problem" : "skipped",
+            detail: readiness.issue ??
+                `${name} was not found on this computer. Install it, sign in once in a terminal, then choose Check all again. If it is installed somewhere unusual, set its path in Settings → Providers.`,
+        });
+        return { ...base, state: used.length > 0 ? "problem" : "unused", checks };
+    }
+    checks.push({
+        label: "Installed",
+        state: readiness.issueKind === "version" ? "problem" : "ok",
+        detail: readiness.issueKind === "version"
+            ? (readiness.issue ?? `Update ${name}, then choose Check all again.`)
+            : `Found ${command}${readiness.version === undefined ? "" : ` (version ${readiness.version})`}.`,
+    });
+    const source = loginSource(status.id);
+    let login = "unknown";
+    if (status.cliPath?.managedOnHost === true && deps.hostCliStatus !== undefined) {
+        login = (await deps.hostCliStatus(status.id)).login;
+    }
+    else if (deps.login !== undefined && source !== "gemini") {
+        try {
+            login = await deps.login(cliPathStatus(deps.db, status.id).command, source, AbortSignal.timeout(15_000));
+        }
+        catch {
+            login = "unknown";
+        }
+    }
+    checks.push(login === "signed-in"
+        ? { label: "Signed in", state: "ok", detail: `${name} is signed in.` }
+        : login === "signed-out"
+            ? {
+                label: "Signed in",
+                state: "problem",
+                detail: `${name} is not signed in. Open a terminal on the computer running it, run "${signInCommand[source]}" and sign in, then choose Check all again.`,
+            }
+            : {
+                label: "Signed in",
+                state: "skipped",
+                detail: source === "gemini"
+                    ? `Gemini CLI has no sign-in check Slopify can ask. Run "gemini" in a terminal once to confirm it is signed in.`
+                    : `Slopify could not tell whether ${name} is signed in. Run "${signInCommand[source]}" in a terminal if runs fail with a sign-in error.`,
+            });
+    if (used.length > 0)
+        checks.push(await cliModels(deps, status, used));
+    return { ...base, state: overall(checks, used.length > 0, true), checks };
+}
+async function cliModels(deps, status, used) {
+    if (deps.modelsFor === undefined)
+        return {
+            label: "Chosen models",
+            state: "skipped",
+            detail: "The model list is not loaded yet.",
+        };
+    let offered;
+    try {
+        offered = await deps.modelsFor(status.id, status.family);
+    }
+    catch {
+        return {
+            label: "Chosen models",
+            state: "warning",
+            detail: `Slopify could not read ${status.displayName}'s model list, so it could not check the chosen models. Make sure it is signed in and up to date, then choose Check all again.`,
+        };
+    }
+    const ids = new Set(offered.map((model) => model.id));
+    const missing = used.filter((use) => !ids.has(use.model));
+    if (missing.length === 0)
+        return {
+            label: "Chosen models",
+            state: "ok",
+            detail: `Every chosen model (${[...new Set(used.map((use) => use.model))].join(", ")}) is available.`,
+        };
+    return {
+        label: "Chosen models",
+        state: "problem",
+        detail: `${status.displayName} does not offer ${describe(missing)}. Update ${status.displayName}, or pick another model there and save.`,
+    };
+}
+function describe(missing) {
+    const shown = missing.slice(0, 3).map((use) => `${use.model} (${use.where})`);
+    return missing.length > 3
+        ? `${shown.join("; ")} and ${missing.length - 3} more`
+        : shown.join("; ");
+}
+async function keyedHealth(deps, status, used, retired) {
+    const { readiness } = status;
+    const base = { id: status.id, displayName: status.displayName, family: status.family };
+    const guide = keyGuides[status.id];
+    const checks = [];
+    const hasKey = readiness.kind === "keyed" && readiness.hasKey;
+    if (!hasKey) {
+        checks.push({
+            label: "Key saved",
+            state: used.length > 0 ? "problem" : "skipped",
+            detail: `No key is saved.${used.length > 0 ? ` It is chosen for ${describe(used)}.` : ""} Make one at ${guide?.keyPage.url ?? "the provider's website"}, paste it in Settings → Providers → ${status.displayName} and choose Save.`,
+        });
+        return { ...base, state: used.length > 0 ? "problem" : "unused", checks };
+    }
+    const test = await testProviderKey(deps, status.id);
+    checks.push({
+        label: "Key valid",
+        state: test.ok
+            ? "ok"
+            : test.result === "rate-limited" ||
+                test.result === "provider-down" ||
+                test.result === "unreachable"
+                ? "warning"
+                : "problem",
+        detail: test.message,
+    });
+    const mine = retired.filter((usage) => usage.provider === status.id);
+    if (mine.length > 0)
+        checks.push({
+            label: "Chosen models",
+            state: "problem",
+            detail: `${describe(mine.map((usage) => ({
+                model: usage.model,
+                where: `${slotLabels[usage.slot]} in ${usage.kind} “${usage.name}”`,
+            })))} ${mine.length === 1 ? "is" : "are"} no longer offered. Use Switch in Settings → Models → Retired models in use.`,
+        });
+    else if (used.length > 0)
+        checks.push({
+            label: "Chosen models",
+            state: "ok",
+            detail: "Every chosen model is still offered.",
+        });
+    return { ...base, state: overall(checks, used.length > 0, true), checks };
+}

package/dist/slices/settings/key-guides.js

@@ -0,0 +1,128 @@
+const openAi = {
+    signUp: { label: "platform.openai.com/signup", url: "https://platform.openai.com/signup" },
+    keyPage: { label: "platform.openai.com/api-keys", url: "https://platform.openai.com/api-keys" },
+    billing: {
+        label: "Billing",
+        url: "https://platform.openai.com/settings/organization/billing/overview",
+    },
+    steps: [
+        "Sign up or sign in to the OpenAI platform.",
+        "Open Billing and buy prepaid credit (new accounts need at least $5 before any call works).",
+        "Open API keys, choose Create new secret key, and copy it (it is shown once).",
+        "Paste it here, choose Save, then Test.",
+    ],
+    permissions: "A key with All permissions works. A restricted key needs Models: Read (for Test) and Model capabilities: Request (for speech and images). GPT Image models may also need Verify Organization under Settings → Organization → General on the OpenAI platform.",
+    docs: {
+        label: "OpenAI API docs",
+        url: "https://developers.openai.com/api/docs/guides/error-codes",
+    },
+};
+export const keyGuides = {
+    openrouter: {
+        signUp: { label: "openrouter.ai/sign-up", url: "https://openrouter.ai/sign-up" },
+        keyPage: { label: "openrouter.ai/settings/keys", url: "https://openrouter.ai/settings/keys" },
+        billing: { label: "Credits", url: "https://openrouter.ai/settings/credits" },
+        steps: [
+            "Sign up at OpenRouter.",
+            "Open Credits and buy credit (paid models are charged from it; a negative balance stops even free models).",
+            "Open Keys, choose Create API key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Keys have no scopes. If you set a credit limit on the key, keep it above what a run costs.",
+        docs: { label: "OpenRouter docs", url: "https://openrouter.ai/docs/api-reference/limits" },
+    },
+    "openai-tts": openAi,
+    "openai-image": openAi,
+    "google-image": {
+        signUp: { label: "aistudio.google.com", url: "https://aistudio.google.com" },
+        keyPage: { label: "aistudio.google.com/apikey", url: "https://aistudio.google.com/apikey" },
+        billing: { label: "Projects → Set up billing", url: "https://aistudio.google.com/projects" },
+        steps: [
+            "Sign in to Google AI Studio with your Google account.",
+            "Open Projects and choose Set up billing next to your project: Gemini image models are not available on the free tier.",
+            "Open API keys, choose Create API key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Use a key made in AI Studio. An older Google Cloud key must be set to Restrict to Gemini API only, or Google rejects it.",
+        docs: { label: "Gemini API keys", url: "https://ai.google.dev/gemini-api/docs/api-key" },
+    },
+    fal: {
+        signUp: { label: "fal.ai/login", url: "https://fal.ai/login" },
+        keyPage: { label: "fal.ai/dashboard/keys", url: "https://fal.ai/dashboard/keys" },
+        billing: { label: "Billing", url: "https://fal.ai/dashboard/billing" },
+        steps: [
+            "Sign up at fal.ai.",
+            "Open Billing and buy credit: fal.ai is prepaid and locks the account when the balance runs out.",
+            "Open Keys, choose Add key with the API scope, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "The API scope is enough; Slopify does not need an ADMIN key.",
+        docs: {
+            label: "fal.ai authentication",
+            url: "https://fal.ai/docs/model-apis/authentication",
+        },
+    },
+    replicate: {
+        signUp: { label: "replicate.com/signin", url: "https://replicate.com/signin" },
+        keyPage: {
+            label: "replicate.com/account/api-tokens",
+            url: "https://replicate.com/account/api-tokens",
+        },
+        billing: { label: "Billing", url: "https://replicate.com/account/billing" },
+        steps: [
+            "Sign in to Replicate.",
+            "Open Billing and buy credit: Replicate needs credit up front before it runs paid models.",
+            "Open API tokens, create a token, and copy it (it starts with r8_).",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Tokens have no scopes.",
+        docs: { label: "Replicate billing", url: "https://replicate.com/docs/topics/billing" },
+    },
+    elevenlabs: {
+        signUp: { label: "elevenlabs.io/app/sign-up", url: "https://elevenlabs.io/app/sign-up" },
+        keyPage: {
+            label: "elevenlabs.io/app/developers/api-keys",
+            url: "https://elevenlabs.io/app/developers/api-keys",
+        },
+        steps: [
+            "Sign up at ElevenLabs.",
+            "Open Developers → API keys, choose Create key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "A restricted key needs Text to Speech access and Models read access (models_read) for Test; Voices read helps when picking voices. Remove any credit quota or IP allowlist that would block this computer.",
+        docs: {
+            label: "ElevenLabs API keys",
+            url: "https://elevenlabs.io/docs/api-reference/models/list",
+        },
+    },
+    cartesia: {
+        signUp: { label: "play.cartesia.ai/sign-up", url: "https://play.cartesia.ai/sign-up" },
+        keyPage: { label: "play.cartesia.ai/keys", url: "https://play.cartesia.ai/keys" },
+        steps: [
+            "Sign up at Cartesia (the free plan needs no card).",
+            "Open API Keys, create a key, and copy it (it starts with sk_car_).",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Keys have no scopes.",
+        docs: {
+            label: "Cartesia authentication",
+            url: "https://docs.cartesia.ai/get-started/authenticate-your-client-applications",
+        },
+    },
+    inworld: {
+        signUp: { label: "platform.inworld.ai/signup", url: "https://platform.inworld.ai/signup" },
+        keyPage: {
+            label: "platform.inworld.ai/api-keys",
+            url: "https://platform.inworld.ai/api-keys",
+        },
+        billing: { label: "Billing", url: "https://platform.inworld.ai/billing" },
+        steps: [
+            "Sign up at the Inworld platform.",
+            "Open API Keys and choose Generate new key (a Standard key, not Realtime-only).",
+            "Copy the Base64 credentials value exactly as shown, without encoding it again.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "A Standard key covers speech and reading voices. Realtime-only keys do not work.",
+        docs: { label: "Inworld API keys", url: "https://docs.inworld.ai/portal/api-keys" },
+    },
+};

package/dist/slices/settings/key-test.js

@@ -0,0 +1,85 @@
+import { keyGuides } from "./key-guides.js";
+import { providerById } from "./model.js";
+import { keyOf } from "./repo.js";
+// What the Test button found. `ok` is the only thing the screen needs to colour the line;
+// `message` says what happened and, when it failed, exactly what to do.
+export const keyTestResults = [
+    "valid",
+    "no-key",
+    "rejected",
+    "forbidden",
+    "no-credit",
+    "rate-limited",
+    "provider-down",
+    "unreachable",
+    "unexpected",
+];
+// The mapping from what came back to what the user reads. Pure, so every branch is tested
+// without a network.
+export function keyTestOutcome(provider, answer, checkedAt, badKey) {
+    const name = providerById(provider).displayName;
+    const guide = keyGuides[provider];
+    const keyPage = guide === undefined ? "the provider's website" : guide.keyPage.url;
+    const billing = guide?.billing?.url;
+    const place = `Settings → Providers → ${name}`;
+    const done = (result, message) => ({
+        provider,
+        result,
+        ok: result === "valid",
+        message,
+        checkedAt,
+    });
+    if ("failure" in answer) {
+        if (answer.failure === "no-key")
+            return done("no-key", `No ${name} key is saved yet. Make one at ${keyPage}, paste it in ${place} and choose Save, then Test.`);
+        return done("unreachable", answer.failure === "timeout"
+            ? `${name} did not answer within 15 seconds, so the key could not be checked. Check your internet connection, then choose Test again.`
+            : `Slopify could not reach ${name}, so the key could not be checked. Check your internet connection (and any firewall or proxy), then choose Test again.`);
+    }
+    const { status } = answer;
+    if (status >= 200 && status < 300)
+        return done("valid", provider === "openrouter"
+            ? `${name} accepted this key.`
+            : `${name} accepted this key. The account's credit is only checked when Slopify first generates with it.`);
+    if (status === 401 || badKey?.(status, answer.body ?? "") === true)
+        return done("rejected", `${name} did not accept this key (HTTP ${status}): it is mistyped, revoked or for another account. Make a new key at ${keyPage}, paste it in ${place}, choose Save, then Test again.`);
+    if (status === 402)
+        return done("no-credit", `${name} accepted the key but the account has no credit or payment method (HTTP 402). Add credit${billing === undefined ? " in your account" : ` at ${billing}`}, then choose Test again.`);
+    if (status === 403)
+        return done("forbidden", `${name} recognised the key but refused this request (HTTP 403). The key may be restricted, or the account may need verifying or billing set up. ${guide?.permissions ?? ""} Fix it at ${keyPage}, then choose Test again.`.replace(/\s+/g, " "));
+    if (status === 429)
+        return done("rate-limited", `${name} said "too many requests" (HTTP 429), so the key could not be checked just now. It is usually valid; wait a minute and choose Test again. If it keeps happening, check the account's limits and credit${billing === undefined ? "" : ` at ${billing}`}.`);
+    if (status >= 500)
+        return done("provider-down", `${name} had a problem on its side (HTTP ${status}), so the key could not be checked. Wait a few minutes and choose Test again.`);
+    return done("unexpected", `${name} answered the key check with HTTP ${status}, which Slopify did not expect. Check the key at ${keyPage}, then choose Test again; if it keeps happening, use Download diagnostics in Settings and report it.`);
+}
+// The Test button. The key is read for this one request, sent only to its own provider, and
+// never appears in the answer, a log line or an error.
+export async function testProviderKey(deps, provider) {
+    const at = () => deps.clock.now().toISOString();
+    const probe = Object.hasOwn(deps.probes, provider) ? deps.probes[provider] : undefined;
+    if (probe === undefined || providerById(provider).auth !== "key")
+        throw new Error(`${provider} has no key to test`);
+    const key = keyOf(deps.db, provider);
+    if (key === undefined)
+        return keyTestOutcome(provider, { failure: "no-key" }, at());
+    let status;
+    let body = "";
+    try {
+        const response = await deps.fetch(probe.url, {
+            headers: probe.headers(key),
+            signal: AbortSignal.timeout(15_000),
+            redirect: "error",
+        });
+        status = response.status;
+        // Only an error body is read, and only its start: enough for the provider's error code.
+        body = status >= 400 ? (await response.text()).slice(0, 4096) : "";
+        if (status < 400)
+            await response.body?.cancel().catch(() => { });
+    }
+    catch (error) {
+        const timeout = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+        return keyTestOutcome(provider, { failure: timeout ? "timeout" : "network" }, at());
+    }
+    return keyTestOutcome(provider, { status, body }, at(), probe.badKey);
+}

package/dist/slices/settings/model.js

@@ -1,4 +1,5 @@
 // The provider catalogue and the settings domain types.
+import { defaultLoudness } from "../loudness/model.js";
 // The three families are the three ports, so the set is named beside them.
 export { providerFamilies } from "../../kernel/ports/model.js";
 // The supported set. OpenAI ships two adapters with two ids, one per family:
@@ -22,6 +23,11 @@ export const providerIds = [
 export function isLocalCliProvider(id) {
     return id === "claude-code" || id === "codex" || id === "gemini" || id === "codex-image";
 }
+// How many calls to a command-line tool run at once. Each Codex image is its own job - its
+// own folder and thread - so four are drawn side by side; the text CLIs keep three.
+export function localCliConcurrency(id) {
+    return id === "codex-image" ? 4 : 3;
+}
 export const providers = [
     { id: "openrouter", family: "llm", displayName: "OpenRouter", auth: "key" },
     {
@@ -76,4 +82,8 @@ export function providerById(id) {
 }
 // The theme override the Appearance control writes.
 export const appearances = ["system", "light", "dark"];
-export const defaultSettings = { silenceGapSeconds: 3, appearance: "system" };
+export const defaultSettings = {
+    silenceGapSeconds: 3,
+    appearance: "system",
+    loudness: defaultLoudness,
+};

package/dist/slices/settings/playback.js

@@ -1,17 +1,25 @@
 import { z } from "zod";
 import { silenceGapSecondsMax } from "../admission/rules.js";
+import { loudnessFields } from "../loudness/model.js";
 import { appearances, defaultSettings } from "./model.js";
 import { readSetting, writeSetting } from "./repo.js";
 // The `settings` table is key/value, so each setting is its own row and a value the app
 // does not understand costs only that one setting.
 const silenceGapKey = "silenceGapSeconds";
 const appearanceKey = "appearance";
+const loudnessKey = "loudness";
 const silenceGapValue = z.number().int().min(0).max(silenceGapSecondsMax);
 const appearanceValue = z.enum(appearances);
+const loudnessValue = z.object({
+    enabled: z.boolean(),
+    videoLufs: z.number(),
+    audioFilesLufs: z.number(),
+});
 export function readSettings(deps) {
     return {
         silenceGapSeconds: parsed(deps, silenceGapKey, silenceGapValue, defaultSettings.silenceGapSeconds),
         appearance: parsed(deps, appearanceKey, appearanceValue, defaultSettings.appearance),
+        loudness: parsed(deps, loudnessKey, loudnessValue, defaultSettings.loudness),
     };
 }
 export function saveSettings(deps, settings) {
@@ -25,11 +33,18 @@ export function saveSettings(deps, settings) {
     if (!appearanceValue.safeParse(settings.appearance).success) {
         fields.push({ field: "appearance", message: "Choose System, Light or Dark." });
     }
+    if (!loudnessValue.safeParse(settings.loudness).success) {
+        fields.push({ field: "loudness", message: "Choose whether new runs level the volume." });
+    }
+    else {
+        fields.push(...loudnessFields(settings.loudness));
+    }
     if (fields.length > 0) {
         return { ok: false, fields };
     }
     writeSetting(deps.db, silenceGapKey, JSON.stringify(settings.silenceGapSeconds));
     writeSetting(deps.db, appearanceKey, JSON.stringify(settings.appearance));
+    writeSetting(deps.db, loudnessKey, JSON.stringify(settings.loudness));
     return { ok: true, settings };
 }
 // A stored value is JSON, and a hand-edited database is the only way it can be anything

package/dist/slices/settings/repo.js

@@ -10,7 +10,9 @@ const voiceRow = z.object({
     provider: z.enum(providerIds),
     name: z.string(),
     voice_id: z.string(),
+    languages_json: z.string().nullable(),
 });
+const languagesJson = z.array(z.string());
 const settingRow = z.object({ value: z.string() });
 export function upsertKey(db, provider, key, updatedAt) {
     db.prepare("INSERT INTO provider_keys (provider,key,updated_at,credential_generation) VALUES (?,?,?,?)" +
@@ -37,11 +39,16 @@ export function hasKey(db, provider) {
     return db.prepare("SELECT 1 FROM provider_keys WHERE provider = ?").get(provider) !== undefined;
 }
 export function insertVoice(db, voice) {
-    db.prepare("INSERT INTO voices (id, provider, name, voice_id) VALUES (?, ?, ?, ?)").run(voice.id, voice.provider, voice.name, voice.voiceId);
+    db.prepare("INSERT INTO voices (id, provider, name, voice_id, languages_json) VALUES (?, ?, ?, ?, ?)").run(voice.id, voice.provider, voice.name, voice.voiceId, voice.languages === undefined ? null : JSON.stringify(voice.languages));
+}
+export function updateVoiceLanguages(db, id, languages) {
+    return (Number(db
+        .prepare("UPDATE voices SET languages_json = ? WHERE id = ?")
+        .run(languages === undefined ? null : JSON.stringify(languages), id).changes) > 0);
 }
 export function listVoices(db) {
     return db
-        .prepare("SELECT id, provider, name, voice_id FROM voices ORDER BY provider, name, voice_id")
+        .prepare("SELECT id, provider, name, voice_id, languages_json FROM voices ORDER BY provider, name, voice_id")
         .all()
         .map((row) => toVoice(voiceRow.parse(row)));
 }
@@ -57,5 +64,12 @@ export function writeSetting(db, key, value) {
         " ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
 }
 function toVoice(row) {
-    return { id: row.id, provider: row.provider, name: row.name, voiceId: row.voice_id };
+    const languages = row.languages_json === null ? undefined : languagesJson.parse(JSON.parse(row.languages_json));
+    return {
+        id: row.id,
+        provider: row.provider,
+        name: row.name,
+        voiceId: row.voice_id,
+        ...(languages === undefined ? {} : { languages }),
+    };
 }