@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/kernel/ports/system-speech.js

@@ -0,0 +1,203 @@
+// The speech a computer already has, found when asked: macOS's `say`, Windows' built-in
+// System.Speech through PowerShell, and on Linux Piper, SVOX Pico, eSpeak NG or eSpeak, best
+// first. No key and no charge. It lives in the kernel because the settings slice (readiness)
+// and the TTS adapter both read it, and neither may import the other.
+export const speechEngineIds = [
+    "say",
+    "sapi",
+    "piper",
+    "pico2wave",
+    "espeak-ng",
+    "espeak",
+];
+export const speechEngineNames = {
+    say: "macOS voices",
+    sapi: "Windows voices",
+    piper: "Piper",
+    pico2wave: "SVOX Pico",
+    "espeak-ng": "eSpeak NG",
+    espeak: "eSpeak",
+};
+const probeTimeoutMs = 15_000;
+// Windows lists the enabled voices as "name<TAB>culture" lines.
+export const windowsVoiceListScript = "Add-Type -AssemblyName System.Speech; $s = New-Object System.Speech.Synthesis.SpeechSynthesizer; foreach ($v in $s.GetInstalledVoices()) { if ($v.Enabled) { Write-Output ($v.VoiceInfo.Name + [char]9 + $v.VoiceInfo.Culture.Name) } }; $s.Dispose()";
+// SVOX Pico ships exactly these six.
+const picoVoices = [
+    { id: "en-US", name: "English (US)", language: "en-US" },
+    { id: "en-GB", name: "English (UK)", language: "en-GB" },
+    { id: "de-DE", name: "German", language: "de-DE" },
+    { id: "es-ES", name: "Spanish", language: "es-ES" },
+    { id: "fr-FR", name: "French", language: "fr-FR" },
+    { id: "it-IT", name: "Italian", language: "it-IT" },
+];
+export const noSpeechFix = "or add an ElevenLabs or OpenAI key in Settings → Providers for a better voice.";
+export async function detectSpeech(given, host) {
+    // A probe that throws (a host bridge that cannot run local programs) found nothing.
+    const probe = (binary, args, timeoutMs) => Promise.resolve()
+        .then(() => given(binary, args, timeoutMs))
+        .catch(() => ({ ran: false, stdout: "" }));
+    const engines = [];
+    const add = (id, voices) => {
+        if (voices.length > 0)
+            engines.push({ id, name: speechEngineNames[id], voices });
+    };
+    if (host.platform === "darwin") {
+        const listed = await probe("say", ["-v", "?"], probeTimeoutMs);
+        if (listed.ran)
+            add("say", parseSayVoices(listed.stdout));
+        return engines.length > 0
+            ? { engines }
+            : {
+                engines,
+                issue: `macOS's speech command (say) didn't answer, so the system voice can't narrate. Check that /usr/bin/say runs in Terminal, ${noSpeechFix}`,
+            };
+    }
+    if (host.platform === "win32") {
+        const listed = await probe("powershell", ["-NoProfile", "-NonInteractive", "-Command", windowsVoiceListScript], probeTimeoutMs);
+        if (listed.ran)
+            add("sapi", parseWindowsVoices(listed.stdout));
+        return engines.length > 0
+            ? { engines }
+            : {
+                engines,
+                issue: `Windows' built-in speech didn't answer through PowerShell, or no voice is installed. Add a voice in Windows Settings → Time & language → Speech, ${noSpeechFix}`,
+            };
+    }
+    const piperModels = piperVoices(host.env);
+    const [piper, pico, espeakNg, espeak] = await Promise.all([
+        // Without a voice model Piper can't speak, so it isn't even asked.
+        piperModels.length > 0 ? isPiperTts(probe) : Promise.resolve(false),
+        onPath(probe, "pico2wave"),
+        probe("espeak-ng", ["--voices"], probeTimeoutMs),
+        probe("espeak", ["--voices"], probeTimeoutMs),
+    ]);
+    if (piper)
+        add("piper", piperModels);
+    if (pico)
+        add("pico2wave", picoVoices);
+    if (espeakNg.ran)
+        add("espeak-ng", parseEspeakVoices(espeakNg.stdout));
+    if (espeak.ran)
+        add("espeak", parseEspeakVoices(espeak.stdout));
+    if (engines.length > 0)
+        return { engines };
+    return {
+        engines,
+        issue: host.env.SLOPIFY_CONTAINER === "1"
+            ? `Slopify runs in Docker and this image has no speech program, so the system voice can't narrate. Update the image (docker compose pull, then docker compose up -d), ${noSpeechFix}`
+            : `No speech program was found on this computer, so the system voice can't narrate. Install espeak-ng (for example sudo apt install espeak-ng, sudo pacman -S espeak-ng or sudo dnf install espeak-ng) and reload Settings → Providers, ${noSpeechFix}`,
+    };
+}
+async function onPath(probe, binary) {
+    // `command -v` answers for a program on PATH without running it: Pico and Piper have no
+    // harmless flag that exits cleanly.
+    return (await probe("sh", ["-c", 'command -v "$1"', "sh", binary], probeTimeoutMs)).ran;
+}
+// `piper` on PATH is not always Piper the voice engine: libratbag's mouse settings app has the
+// same name (/usr/bin/piper on many desktops). The engine is told apart by its help, which names
+// --model and an output option (the C++ build prints it on stderr, hence 2>&1), or failing that
+// by a version line that names piper-tts. Anything else, or no answer, is not Piper.
+async function isPiperTts(probe) {
+    const ask = (flag) => probe("sh", ["-c", '"$1" "$2" 2>&1; exit 0', "sh", "piper", flag], probeTimeoutMs);
+    const help = await ask("--help");
+    if (help.ran && isPiperTtsHelp(help.stdout))
+        return true;
+    const version = await ask("--version");
+    return version.ran && isPiperTtsVersion(version.stdout);
+}
+export function isPiperTtsHelp(text) {
+    return /--model\b/.test(text) && /--output[-_](?:file|dir|raw)\b/.test(text);
+}
+export function isPiperTtsVersion(text) {
+    return /\bpiper[-_ ]tts\b/i.test(text);
+}
+// Piper needs a voice model file; SLOPIFY_PIPER_VOICES lists them (.onnx paths, separated like
+// PATH). Without one, Piper can't speak and is left out.
+export function piperVoices(env) {
+    return (env.SLOPIFY_PIPER_VOICES ?? "")
+        .split(":")
+        .map((path) => path.trim())
+        .filter((path) => path.endsWith(".onnx"))
+        .map((path) => {
+        const name = (path.split("/").pop() ?? path).replace(/\.onnx$/, "");
+        const language = /^([a-z]{2,3}_[A-Z]{2})/.exec(name)?.[1];
+        return { id: path, name, ...(language === undefined ? {} : { language }) };
+    });
+}
+// `say -v ?`: "Samantha            en_US    # Hello! My name is Samantha." A name may carry
+// single spaces and brackets ("Eddy (English (US))"), so the language is the anchor.
+export function parseSayVoices(stdout) {
+    const voices = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = /^(.+?)\s+([a-z]{2,3}[_-][A-Za-z0-9_-]+)\s+#/.exec(line);
+        if (match?.[1] === undefined || match[2] === undefined)
+            continue;
+        const name = match[1].trim();
+        if (!voices.some((voice) => voice.id === name))
+            voices.push({ id: name, name, language: match[2] });
+    }
+    return voices;
+}
+export function parseWindowsVoices(stdout) {
+    const voices = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const [name, culture] = line.split("\t").map((part) => part.trim());
+        if (name === undefined || name === "" || voices.some((voice) => voice.id === name))
+            continue;
+        voices.push({
+            id: name,
+            name: name.replace(/^Microsoft\s+/, "").replace(/\s+Desktop$/, ""),
+            ...(culture === undefined || culture === "" ? {} : { language: culture }),
+        });
+    }
+    return voices;
+}
+// `espeak-ng --voices`: a header, then " 5  en-us  --/M  English_(America)  gmw/en-US ...".
+export function parseEspeakVoices(stdout) {
+    const voices = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 4 || !/^\d+$/.test(parts[0] ?? ""))
+            continue;
+        const [, language, , name] = parts;
+        if (language === undefined || name === undefined)
+            continue;
+        if (voices.some((voice) => voice.id === language))
+            continue;
+        voices.push({ id: language, name: name.replace(/_/g, " "), language });
+    }
+    return voices;
+}
+// The voice a first short uses when none is saved: an English one, American first.
+export function defaultSpeechVoice(engine) {
+    const english = (voice, tag) => tag.test(voice.language ?? voice.id);
+    return (engine.voices.find((voice) => voice.name === "Samantha") ??
+        engine.voices.find((voice) => english(voice, /^en[-_]us$/i)) ??
+        engine.voices.find((voice) => english(voice, /^en\b|^en[-_]/i)) ??
+        engine.voices[0]);
+}
+// The primary language subtag ("en" from "en_US"), as Settings → Voices records it.
+export function primaryLanguage(voice) {
+    const tag = /^([a-z]{2,3})(?:[-_]|$)/i.exec(voice.language ?? "")?.[1];
+    return tag?.toLowerCase();
+}
+// One look per minute: readiness is asked on every Settings and Play load, and starting four
+// processes each time is wasted work for something that changes when a program is installed.
+const cacheMs = 60_000;
+const cached = new WeakMap();
+export function detectSpeechCached(probe, host) {
+    const now = performance.now();
+    const key = [
+        host.platform,
+        host.env.SLOPIFY_CONTAINER ?? "",
+        host.env.SLOPIFY_PIPER_VOICES ?? "",
+    ].join("\n");
+    const byHost = cached.get(probe) ?? new Map();
+    cached.set(probe, byHost);
+    const hit = byHost.get(key);
+    if (hit !== undefined && now - hit.at < cacheMs)
+        return hit.found;
+    const found = detectSpeech(probe, host);
+    byHost.set(key, { at: now, found });
+    return found;
+}

package/dist/kernel/runner/attempt.js

@@ -14,15 +14,18 @@ export const timeoutMs = {
     video: 900_000,
 };
 // A refusal and an unsupported capability are the provider's final answer; retrying only
-// spends the user's money again. The third is a key removed mid-run, which leaves nothing
-// to call with. A key the provider rejected is different: that is an `auth` failure,
-// retried like any other.
+// spends the user's money again. A key the provider rejected, or one removed mid-run, needs
+// the user in Settings before any call can succeed.
 const terminalKinds = [
     "refusal",
     "unsupported",
+    "auth",
     "missing_key",
     "unavailable",
 ];
+// A Retry-After longer than this is not slept through with the stage holding its provider
+// slot: the call fails here and the runner's persisted wait (`retry-policy.ts`) takes over.
+export const inCallRetryAfterCeilingMs = 60_000;
 export async function attempt(ctx, call, opts) {
     ctx.signal.throwIfAborted();
     const limit = opts.timeoutMs ?? timeoutMs[opts.kind];
@@ -84,7 +87,12 @@ export async function attempt(ctx, call, opts) {
             stage: ctx.stage,
             detail: `${opts.kind} attempt ${n} of ${attemptLimit} failed (${failure.fault.kind}): ${failure.message}`,
         });
-        if (terminalKinds.includes(failure.fault.kind) || n >= attemptLimit) {
+        // A used-up plan allowance is not retried here: the call waits for the reset outside the
+        // provider queue (providers.ts), so a waiting stage holds no slot other work needs.
+        if (terminalKinds.includes(failure.fault.kind) ||
+            failure.fault.planLimit !== undefined ||
+            n >= attemptLimit ||
+            (failure.fault.retryAfterMs ?? 0) > inCallRetryAfterCeilingMs) {
             throw failure;
         }
         // A 429 that names a Retry-After replaces the fixed wait with the provider's.
@@ -102,8 +110,8 @@ function classify(error, expired, opts, limit) {
         return providerError({
             kind: "timeout",
             message: opts.streaming === true
-                ? `The ${callee[opts.kind]} sent nothing for ${seconds} seconds, so Slopify stopped waiting. It may be overloaded: wait a few minutes, then use Retry stage.`
-                : `The ${callee[opts.kind]} did not answer within ${seconds} seconds. It may be overloaded: wait a few minutes, then use Retry stage, or choose another model in the Providers section of Edit project.`,
+                ? `The ${callee[opts.kind]} sent nothing for ${seconds} seconds, so Slopify stopped waiting. It may be overloaded: wait a few minutes, then use Try again.`
+                : `The ${callee[opts.kind]} did not answer within ${seconds} seconds. It may be overloaded: wait a few minutes, then use Try again, or choose another model in the Providers section of Edit project.`,
         });
     }
     if (isProviderError(error)) {
@@ -113,14 +121,15 @@ function classify(error, expired, opts, limit) {
             kind: error.fault.kind,
             message: redact(error.message),
             ...(error.fault.retryAfterMs === undefined ? {} : { retryAfterMs: error.fault.retryAfterMs }),
+            ...(error.fault.planLimit === undefined ? {} : { planLimit: error.fault.planLimit }),
         });
     }
     if (unreachable(error)) {
         // `fetch` names only itself; the cause's code (ENOTFOUND, ECONNREFUSED) is the clue.
         const code = causeCode(error);
         return providerError({
-            kind: "other",
-            message: `Slopify could not reach the ${callee[opts.kind]} over the internet${code === undefined ? "" : ` (${code})`}. Check your internet connection, firewall or VPN, then use Retry stage.`,
+            kind: "dropped",
+            message: `Slopify could not reach the ${callee[opts.kind]} over the internet${code === undefined ? "" : ` (${code})`}. Check your internet connection, firewall or VPN, then use Try again.`,
         });
     }
     return providerError({

package/dist/kernel/runner/audition.js

@@ -0,0 +1,36 @@
+import { attempt } from "./attempt.js";
+const unrecorded = {
+    start: () => "audition",
+    end: () => { },
+};
+export function auditionVoice(deps, call, signal) {
+    const port = deps.registry.tts(call.provider);
+    return attempt({
+        work: {
+            projectId: "audition",
+            revisionId: "audition",
+            workId: "audition",
+            stageId: "audition",
+            kind: "audio",
+            fingerprint: "audition",
+        },
+        maySubmit: () => true,
+        clock: deps.clock,
+        log: deps.log,
+        attempts: unrecorded,
+        projectId: "audition",
+        stage: "audio",
+        stageId: "audition",
+        signal,
+    }, async (inner, progress) => {
+        const spoken = await port.synthesize({
+            model: call.model,
+            voiceId: call.voiceId,
+            text: call.text,
+            signal: inner,
+            onActivity: progress,
+        });
+        const bytes = new Uint8Array(await new Response(spoken.audio).arrayBuffer());
+        return { bytes, container: spoken.container };
+    }, { kind: "tts", streaming: port.capabilities.streams });
+}

package/dist/kernel/runner/graph.js

@@ -1,33 +1,55 @@
 // Images use saved prompts and can run immediately. A thumbnail's source and an
 // audio-only export narrow these dependencies through dependenciesOf(). The document is
 // laid out from the article alone, with the thumbnail as its cover when there is one, so it
-// runs beside narration and images rather than after them.
+// runs beside narration and images rather than after them. The video never reads the
+// thumbnail, so a thumbnail that fails does not hold the video back; neither does it hold
+// the document back (see `optionalDeps`).
 export const deps = {
     research: [],
     article: ["research"],
     audio: ["article"],
     images: [],
     thumbnail: ["article"],
-    video: ["article", "audio", "images", "thumbnail"],
+    video: ["article", "audio", "images"],
     document: ["article", "thumbnail"],
 };
+// Dependencies a stage waits for but can do without: the document takes the thumbnail as its
+// cover when there is one. A thumbnail that failed or was canceled releases the document,
+// which is then laid out with no cover, instead of holding it back with it. Making the
+// thumbnail again still redoes the document (reruns/cascade.ts follows `deps`), so it gets
+// its cover then.
+export const optionalDeps = {
+    document: ["thumbnail"],
+};
 // `provided` and `skipped` release a dependency exactly as `done` does.
 export function satisfied(state) {
     return state === "done" || state === "provided" || state === "skipped";
 }
+// Whether `dependency`, in `state`, lets `kind` start.
+export function releases(kind, dependency, state) {
+    if (satisfied(state))
+        return true;
+    return ((state === "failed" || state === "canceled") &&
+        (optionalDeps[kind]?.includes(dependency) ?? false));
+}
+// What a run is for, in order: the first of these the run asks for is the one that has to be
+// there for the run to count as finished. Anything else failing leaves it done with
+// problems rather than failed.
+const headline = ["video", "audio", "article"];
 // Stage state is derived; an explicit persisted pause takes precedence while calls
-// drain. Completed independent images do not imply that a run was canceled.
+// drain. Completed independent images do not imply that a run was canceled. A stage
+// waiting out a rate limit is still part of a run in progress.
 export function derive(stages, paused = false) {
     if (paused)
         return "paused";
-    if (stages.some((stage) => stage.state === "running")) {
+    if (stages.some((stage) => stage.state === "running" || waiting(stage))) {
         return "running";
     }
     if (stages.some((stage) => stage.state === "canceled")) {
         return "canceled";
     }
     if (stages.some((stage) => stage.state === "failed")) {
-        return "failed";
+        return headlineMade(stages) ? "partial" : "failed";
     }
     if (stages.length > 0 && stages.every((stage) => satisfied(stage.state))) {
         return "done";
@@ -35,6 +57,19 @@ export function derive(stages, paused = false) {
     // Includes a run created but not yet claimed and unfinished work after restart.
     return "pending";
 }
+function waiting(stage) {
+    return stage.state === "pending" && stage.retryAt !== undefined && stage.retryAt !== null;
+}
+function headlineMade(stages) {
+    for (const kind of headline) {
+        const stage = stages.find((one) => one.kind === kind);
+        if (stage === undefined || stage.state === "skipped")
+            continue;
+        // A file the user supplied is not something this run made.
+        return stage.state === "done";
+    }
+    return false;
+}
 export function dependenciesOf(kind, sources) {
     if (kind === "thumbnail" && sources.thumbnail === "from_prompt")
         return [];

package/dist/kernel/runner/index.js

@@ -1,6 +1,7 @@
 import { causedBy } from "../errors.js";
-import { derive, deps as graph, satisfied } from "./graph.js";
+import { derive, deps as graph, releases } from "./graph.js";
 import { progressGate } from "./progress.js";
+import { faultOf } from "./retry-policy.js";
 const pauseReason = new Error("paused by user");
 export function createRunner(deps) {
     const inflight = new Map();
@@ -15,7 +16,7 @@ export function createRunner(deps) {
     const stopped = new Set();
     let count = 0;
     let shuttingDown = false;
-    const emitStage = (stage, state, reason) => {
+    const emitStage = (stage, state, reason, detail = {}) => {
         deps.emit(stage.projectId, {
             type: "stage.state",
             revisionId: stage.work.revisionId,
@@ -24,6 +25,8 @@ export function createRunner(deps) {
             stage: stage.kind,
             state,
             ...(reason === null ? {} : { failureReason: reason }),
+            ...(detail.retryAt === undefined ? {} : { retryAt: detail.retryAt }),
+            ...(detail.failureKind === undefined ? {} : { failureKind: detail.failureKind }),
         });
     };
     // The global tally counts projects with a stage in flight, read off the in-flight set
@@ -46,9 +49,9 @@ export function createRunner(deps) {
         announced.set(projectId, state);
         deps.emit(projectId, { type: "project.state", projectId, state });
     };
-    const conclude = (stage, state, reason) => {
+    const conclude = (stage, state, reason, kind) => {
         try {
-            deps.stages.finish(stage.work, state, reason);
+            deps.stages.finish(stage.work, state, reason, kind ?? null);
         }
         catch (error) {
             // The row stays `running` when the write fails. The event still goes out, and the
@@ -59,7 +62,31 @@ export function createRunner(deps) {
                 detail: reasonOf(error),
             });
         }
-        emitStage(stage, state, reason);
+        emitStage(stage, state, reason, { failureKind: kind });
+    };
+    // False when the failure is to be shown now.
+    const deferred = (stage, fault, reason) => {
+        let at;
+        try {
+            at = deps.stages.waitToRetry?.(stage.work, fault, reason);
+        }
+        catch (error) {
+            deps.log.write("error", "stage.retry", {
+                projectId: stage.projectId,
+                stage: stage.kind,
+                detail: reasonOf(error),
+            });
+            return false;
+        }
+        if (at === undefined)
+            return false;
+        deps.log.write("warn", "stage.retry", {
+            projectId: stage.projectId,
+            stage: stage.kind,
+            detail: `waiting until ${at} to run again after ${fault?.kind ?? "a failure"}: ${reason}`,
+        });
+        emitStage(stage, "pending", reason, { retryAt: at, failureKind: fault?.kind });
+        return true;
     };
     async function execute(stage, controller) {
         const tag = (event) => ({
@@ -103,12 +130,15 @@ export function createRunner(deps) {
                 conclude(stage, paused ? "pending" : "canceled", paused ? null : "canceled by user");
                 return;
             }
+            const fault = faultOf(error);
+            if (deferred(stage, fault, reasonOf(error)))
+                return;
             deps.log.write("error", "stage.failed", {
                 projectId: stage.projectId,
                 stage: stage.kind,
                 detail: causedBy(error),
             });
-            conclude(stage, "failed", reasonOf(error));
+            conclude(stage, "failed", reasonOf(error), fault?.kind);
         }
     }
     function start(stage) {
@@ -160,9 +190,9 @@ export function createRunner(deps) {
     }
     function startEligible(projectId) {
         const stages = deps.stages.stagesOf(projectId);
-        const satisfiedKind = (kind) => {
+        const releasesKind = (dependent) => (kind) => {
             const matches = stages.filter((stage) => stage.kind === kind);
-            return matches.length > 0 && matches.every((stage) => satisfied(stage.state));
+            return (matches.length > 0 && matches.every((stage) => releases(dependent, kind, stage.state)));
         };
         for (const stage of stages) {
             if (stage.state !== "pending" || inflight.has(stage.work.workId)) {
@@ -170,7 +200,7 @@ export function createRunner(deps) {
             }
             const dependencies = deps.stages.dependenciesOf?.(projectId, stage.kind) ?? graph[stage.kind];
             if (deps.stages.ready === undefined
-                ? !dependencies.every(satisfiedKind)
+                ? !dependencies.every(releasesKind(stage.kind))
                 : !deps.stages.ready(stage.work)) {
                 continue;
             }

package/dist/kernel/runner/meter.js

@@ -0,0 +1 @@
+export {};