@gentbajko/slopify 2.0.1 → 2.0.3

package/dist/kernel/paths.js

@@ -19,3 +19,8 @@ export function ensureDirs(paths, options) {
         chmodSync(dir, options.mode);
     }
 }
+// The subtitle-timing model's cache. The app readies it at start and every captioned render
+// reads it, so both name it through here.
+export function subtitleModelDir(dataDir) {
+    return join(dataDir, "models", "english-subtitles");
+}

package/dist/kernel/ports/subtitles.js

@@ -1 +1,15 @@
-export {};
+// Where the audio stopped matching its transcript: seconds into the aligned file, the
+// transcript words it expected there and what the model heard instead (either may be empty).
+// The aligner throws it so the caller can say which part of the narration to redo.
+export class SubtitleMismatch extends Error {
+    at;
+    expected;
+    heard;
+    constructor(message, at, expected, heard) {
+        super(message);
+        this.at = at;
+        this.expected = expected;
+        this.heard = heard;
+        this.name = "SubtitleMismatch";
+    }
+}

package/dist/kernel/runner/attempt.js

@@ -100,8 +100,8 @@ function classify(error, expired, opts, limit) {
         return providerError({
             kind: "timeout",
             message: opts.streaming === true
-                ? `the provider sent nothing for ${seconds} s`
-                : `the provider did not answer within ${seconds} s`,
+                ? `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.`,
         });
     }
     if (isProviderError(error)) {
@@ -113,11 +113,35 @@ function classify(error, expired, opts, limit) {
             ...(error.fault.retryAfterMs === undefined ? {} : { retryAfterMs: error.fault.retryAfterMs }),
         });
     }
+    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.`,
+        });
+    }
     return providerError({
         kind: "other",
         message: redact(error instanceof Error ? error.message : String(error)),
     });
 }
+// What the user calls the other end of each kind of call.
+const callee = {
+    llm: "AI model",
+    tts: "narration provider",
+    image: "image provider",
+};
+// Node's `fetch` rejects a request that never reached the server with this TypeError.
+function unreachable(error) {
+    return error instanceof TypeError && error.message === "fetch failed";
+}
+function causeCode(error) {
+    const cause = error.cause;
+    if (typeof cause !== "object" || cause === null || !("code" in cause))
+        return undefined;
+    return typeof cause.code === "string" && /^[A-Z_]+$/.test(cause.code) ? cause.code : undefined;
+}
 // The same milliseconds, measured two ways. `idle` restarts the count on every chunk, so a
 // stalled stream is cut off and a long answer is not. Cancel still wins.
 function deadline(clock, parent, ms, idle) {

package/dist/kernel/runner/index.js

@@ -1,4 +1,6 @@
+import { causedBy } from "../errors.js";
 import { derive, deps as graph, satisfied } from "./graph.js";
+import { progressGate } from "./progress.js";
 const pauseReason = new Error("paused by user");
 export function createRunner(deps) {
     const inflight = new Map();
@@ -60,6 +62,12 @@ export function createRunner(deps) {
         emitStage(stage, state, reason);
     };
     async function execute(stage, controller) {
+        const tag = (event) => ({
+            ...event,
+            revisionId: stage.work.revisionId,
+            workId: stage.work.workId,
+        });
+        const progress = progressGate((event) => deps.emit(stage.projectId, tag(event)));
         try {
             const run = deps.runs[stage.kind];
             if (run === undefined) {
@@ -76,16 +84,18 @@ export function createRunner(deps) {
                     deps.stages.maySubmit(stage.work, pieceId),
                 signal: controller.signal,
                 emit: (event) => {
-                    deps.emit(stage.projectId, {
-                        ...event,
-                        revisionId: stage.work.revisionId,
-                        workId: stage.work.workId,
-                    });
+                    if (event.type === "stage.progress")
+                        progress.offer(event);
+                    else
+                        deps.emit(stage.projectId, tag(event));
                 },
             });
+            progress.flush();
+            progress.close();
             conclude(stage, result === "held" ? "pending" : "done", null);
         }
         catch (error) {
+            progress.close();
             if (controller.signal.aborted) {
                 // A late rejection from the aborted call is how a stage learns it was canceled, so
                 // it is not logged as a fault.
@@ -96,7 +106,7 @@ export function createRunner(deps) {
             deps.log.write("error", "stage.failed", {
                 projectId: stage.projectId,
                 stage: stage.kind,
-                detail: reasonOf(error),
+                detail: causedBy(error),
             });
             conclude(stage, "failed", reasonOf(error));
         }

package/dist/kernel/runner/progress.js

@@ -0,0 +1,56 @@
+// The most progress a single stage invocation reports per second. A stage may call emit on
+// every chunk it reads (a 95 MB download is ~6,000 of them) and each report writes the
+// database and reaches every open page; nobody can read a meter faster than this.
+export const progressIntervalMs = 500;
+// Repeats of the last value are dropped. The first report of a window goes out at once and
+// the newest one offered inside it goes out when the window ends, so a meter never sits on
+// a stale value longer than one interval.
+export function progressGate(send, intervalMs = progressIntervalMs) {
+    let last;
+    let held;
+    let timer;
+    let closed = false;
+    const same = (a, b) => a !== undefined && a.current === b.current && a.total === b.total;
+    const deliver = (event) => {
+        last = event;
+        send(event);
+        timer = setTimeout(() => {
+            timer = undefined;
+            const next = held;
+            held = undefined;
+            if (next !== undefined && !closed && !same(last, next))
+                deliver(next);
+        }, intervalMs);
+        timer.unref?.();
+    };
+    return {
+        offer: (event) => {
+            if (closed)
+                return;
+            if (timer !== undefined) {
+                held = event;
+                return;
+            }
+            if (!same(last, event))
+                deliver(event);
+        },
+        flush: () => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            timer = undefined;
+            const next = held;
+            held = undefined;
+            if (next !== undefined && !closed && !same(last, next)) {
+                last = next;
+                send(next);
+            }
+        },
+        close: () => {
+            closed = true;
+            held = undefined;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}

package/dist/main.js

@@ -5,6 +5,7 @@ import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
 import { alignSubtitles } from "./adapters/alignment/index.js";
+import { prefetchModel } from "./adapters/alignment/prefetch.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { createHostCliClient } from "./adapters/host-cli/index.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
@@ -21,10 +22,11 @@ import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
 import { migrate } from "./kernel/db/migrate.js";
 import { transact } from "./kernel/db/tx.js";
+import { causedBy } from "./kernel/errors.js";
 import { ulidIds } from "./kernel/ids.js";
 import { acquireInstanceLock } from "./kernel/lock.js";
 import { openLog } from "./kernel/log.js";
-import { ensureDirs, layout } from "./kernel/paths.js";
+import { ensureDirs, layout, subtitleModelDir } from "./kernel/paths.js";
 import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
 import { createCheckpointAuthority, } from "./kernel/runner/checkpoint-authority.js";
 import { createRunner } from "./kernel/runner/index.js";
@@ -109,7 +111,7 @@ export function createScheduleTickLifecycle(deps) {
         },
     };
 }
-export async function boot(config) {
+export async function boot(config, options = {}) {
     const clock = systemClock;
     const ids = ulidIds;
     const paths = layout(config.dataDir);
@@ -117,7 +119,7 @@ export async function boot(config) {
     if (dockerState !== undefined &&
         (process.env.SLOPIFY_CONTAINER !== "1" ||
             dockerState !== "/opt/slopify-install/activation.json"))
-        throw new Error("Invalid managed Docker activation configuration.");
+        throw new Error("This container was started with Slopify's Docker settings in the wrong place (SLOPIFY_DOCKER_INSTALL_STATE). Start it with the launcher instead: npx @gentbajko/slopify --docker");
     const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
     const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
     ensureDirs(paths, { mode: 0o700 });
@@ -241,7 +243,7 @@ export async function boot(config) {
                 : !existsSync(oldEntry) || !existsSync(workerEntry)
                     ? "Run Slopify from its installed package to use in-app updates."
                     : npm === undefined
-                        ? "npm is unavailable. Install Node.js with npm to use in-app updates."
+                        ? "npm was not found, so in-app updates are off. Install Node.js with npm (https://nodejs.org), or update from the terminal: npx @gentbajko/slopify@latest"
                         : undefined,
             busy: () => updateDb.prepare("SELECT 1 FROM stages WHERE state = 'running' LIMIT 1").get() !==
                 undefined ||
@@ -364,6 +366,18 @@ export async function boot(config) {
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
         flusher.soon();
+        const modelPrefetch = new AbortController();
+        const prefetching = options.prefetchSubtitleModel
+            ? prefetchModel({
+                cacheDir: subtitleModelDir(paths.dataDir),
+                seed: options.subtitleModelSeed,
+                signal: modelPrefetch.signal,
+            }).then(() => log.write("info", "subtitle-model.ready"), (error) => {
+                // Not fatal: the first captioned render tries again and says why on its row.
+                if (!modelPrefetch.signal.aborted)
+                    log.write("warn", "subtitle-model.prefetch", { detail: causedBy(error) });
+            })
+            : Promise.resolve();
         const open = db;
         let stopping;
         let stopActivation = () => { };
@@ -376,6 +390,7 @@ export async function boot(config) {
                 const serverClose = beginServerClose(server);
                 stopActivation();
                 audioPreviews.close();
+                modelPrefetch.abort();
                 try {
                     // Admission closes before the listener. Requests already admitted keep the
                     // database until their response settles; anything racing shutdown receives 503.
@@ -394,6 +409,7 @@ export async function boot(config) {
                         // closes and fail to mark its batch delivered, which costs one re-send that
                         // the collector deduplicates by event id.
                         flusher.stop();
+                        await prefetching;
                         log.write("info", "shutdown");
                         open.close();
                         lock.release();

package/dist/slices/admission/rules.js

@@ -24,16 +24,16 @@ export function admit(input) {
     const draft = normaliseDraft(input.draft);
     const { sources } = draft;
     if (draft.title === "") {
-        fields.push({ field: "title", message: "A title is required." });
+        fields.push({ field: "title", message: "Enter a title for this video." });
     }
     else if (draft.title.length > titleMax) {
-        fields.push({ field: "title", message: `A title is at most ${titleMax} characters.` });
+        fields.push({ field: "title", message: `Keep the title to ${titleMax} characters or fewer.` });
     }
     for (const kind of stageKinds) {
         if (!allowedSources[kind].includes(sources[kind])) {
             fields.push({
                 field: `sources.${kind}`,
-                message: `The ${kind} stage cannot be set to ${sources[kind]}.`,
+                message: `"${sources[kind]}" is not an option for ${kind}. Reload the page and choose again.`,
             });
         }
     }
@@ -45,7 +45,7 @@ export function admit(input) {
         draft.outro?.mode === "llm" ||
         usesNarrationPreparation(draft);
     if (needsLlm && !chosen(draft.llm)) {
-        fields.push({ field: "llm", message: "Pick an LLM provider and model." });
+        fields.push({ field: "llm", message: "Choose a text (LLM) provider and model." });
     }
     if (sources.article === "generate" && blank(draft.articlePrompt)) {
         fields.push({ field: "articlePrompt", message: "Pick an article prompt." });
@@ -54,10 +54,10 @@ export function admit(input) {
     fields.push(...narrationPreparationFields(draft));
     if (sources.audio === "generate") {
         if (voiced === undefined || !chosen(voiced)) {
-            fields.push({ field: "audio", message: "Pick a narration provider and model." });
+            fields.push({ field: "audio", message: "Choose a narration provider and model." });
         }
         else if (voiced.voice.trim() === "") {
-            fields.push({ field: "audio.voice", message: "Pick a voice." });
+            fields.push({ field: "audio.voice", message: "Choose a voice for the narration." });
         }
     }
     if (sources.images === "generate") {
@@ -67,14 +67,17 @@ export function admit(input) {
         sources.thumbnail === "from_prompt" ||
         sources.thumbnail === "prompt_by_llm") &&
         !chosen(draft.images)) {
-        fields.push({ field: "images", message: "Pick an image provider and model." });
+        fields.push({ field: "images", message: "Choose an image provider and model." });
     }
     if ((sources.thumbnail === "from_prompt" || sources.thumbnail === "prompt_by_llm") &&
         blank(draft.thumbnailPrompt)) {
         fields.push({ field: "thumbnailPrompt", message: "Pick a thumbnail prompt." });
     }
     if (sources.audio === "off" && draft.subtitles !== undefined && draft.subtitles.mode !== "off") {
-        fields.push({ field: "subtitles.mode", message: "Subtitles need narration audio." });
+        fields.push({
+            field: "subtitles.mode",
+            message: "Subtitles need narration. Turn narration on, or turn subtitles off.",
+        });
     }
     checkProvided(draft, input.staged, fields);
     checkValues(draft, input.requiredSlots, fields);
@@ -83,7 +86,7 @@ export function admit(input) {
         draft.silenceGapSeconds > silenceGapSecondsMax) {
         fields.push({
             field: "silenceGapSeconds",
-            message: `The silence gap is between 0 and ${silenceGapSecondsMax} seconds.`,
+            message: `Enter a silence gap between 0 and ${silenceGapSecondsMax} seconds.`,
         });
     }
     return fields.length === 0 ? { ok: true, draft } : { ok: false, fields };
@@ -121,7 +124,10 @@ export function normaliseDraft(draft) {
 function checkImagePrompts(draft, fields) {
     if (draft.imagePrompts.length === 0) {
         // A run always has an image source.
-        fields.push({ field: "imagePrompts", message: "Tick at least one image prompt." });
+        fields.push({
+            field: "imagePrompts",
+            message: "Tick at least one image prompt, or turn images off.",
+        });
         return;
     }
     let total = 0;
@@ -135,14 +141,14 @@ function checkImagePrompts(draft, fields) {
             prompt.number > numberPerPromptMax) {
             fields.push({
                 field: `imagePrompts.${index}.number`,
-                message: `Number is between 1 and ${numberPerPromptMax}.`,
+                message: `Enter a whole number between 1 and ${numberPerPromptMax}.`,
             });
         }
     }
     if (total > imagesPerRunMax) {
         fields.push({
             field: "imagePrompts",
-            message: `A run makes at most ${imagesPerRunMax} images; this one asks for ${total}.`,
+            message: `A video can have at most ${imagesPerRunMax} images; these prompts ask for ${total}. Lower the numbers.`,
         });
     }
 }
@@ -168,11 +174,14 @@ function checkProvided(draft, staged, fields) {
         else if (ids.length > imagesPerRunMax) {
             fields.push({
                 field: "provided.images",
-                message: `A run holds at most ${imagesPerRunMax} images.`,
+                message: `A video can have at most ${imagesPerRunMax} images. Remove some.`,
             });
         }
         if (new Set(ids).size !== ids.length) {
-            fields.push({ field: "provided.images", message: "The same image was picked twice." });
+            fields.push({
+                field: "provided.images",
+                message: "The same image is picked twice. Remove the duplicate.",
+            });
         }
         for (const [index, id] of ids.entries()) {
             checkFile(staged, id, "images", `provided.images.${index}`, "Pick an image.", fields);
@@ -187,28 +196,31 @@ function checkFile(staged, id, kind, field, missing, fields) {
     }
     const file = staged.find((candidate) => candidate.id === id);
     if (file === undefined || file.stageKind !== kind) {
-        fields.push({ field, message: "That upload is no longer available; pick the file again." });
+        fields.push({ field, message: "That upload is no longer available. Choose the file again." });
         return;
     }
     if (file.state !== "staged") {
-        fields.push({ field, message: "This upload is still copying." });
+        fields.push({ field, message: "This file is still uploading. Wait for it to finish." });
     }
 }
 function checkValues(draft, requiredSlots, fields) {
     for (const name of requiredSlots) {
         const value = Object.hasOwn(draft.values, name) ? draft.values[name] : undefined;
         if (value === undefined || value === "") {
-            fields.push({ field: `values.${name}`, message: "This field is required." });
+            fields.push({ field: `values.${name}`, message: "Fill in this field." });
             continue;
         }
         if (value.length > valueMax) {
             fields.push({
                 field: `values.${name}`,
-                message: `A value is at most ${valueMax} characters.`,
+                message: `Keep this to ${valueMax} characters or fewer.`,
             });
         }
         if (/[\n\r]/.test(value)) {
-            fields.push({ field: `values.${name}`, message: "A value is a single line." });
+            fields.push({
+                field: `values.${name}`,
+                message: "Keep this to a single line, without line breaks.",
+            });
         }
     }
 }
@@ -224,7 +236,7 @@ export function narrationPreparationFields(draft) {
         ? [
             {
                 field: "narrationPrompt",
-                message: "Narration Preparation requires Inworld TTS-2. Choose that model or turn preparation Off.",
+                message: "Narration preparation only works with the Inworld TTS-2 model. Choose that model under Narration, or turn preparation Off.",
             },
         ]
         : [];

package/dist/slices/article/continuation.js

@@ -81,7 +81,9 @@ function truncated(answer) {
 }
 // Empty response → failed attempt.
 function written(answer) {
-    return answer.text.trim() === "" ? "the article answered with nothing" : undefined;
+    return answer.text.trim() === ""
+        ? "The AI model returned an empty article. Retry stage; if it keeps happening, choose a different model in Edit project → Providers."
+        : undefined;
 }
 function finished(answer) {
     const empty = written(answer);
@@ -89,6 +91,6 @@ function finished(answer) {
         return empty;
     }
     return truncated(answer)
-        ? `the article was still unfinished after ${String(continuationLimit)} continuations`
+        ? `The article was still unfinished after ${String(continuationLimit)} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Retry stage.`
         : undefined;
 }

package/dist/slices/article/plain.js

@@ -7,11 +7,11 @@ export function plainText(markdown) {
     const paragraphs = tree.children
         .map((node) => {
         if (node.type !== "paragraph")
-            throw new Error("Expected stripped prose paragraphs.");
+            throw new Error("Slopify hit an internal error (the article couldn't be turned into plain text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
         return node.children
             .map((child) => {
             if (child.type !== "text")
-                throw new Error("Expected stripped prose text.");
+                throw new Error("Slopify hit an internal error (the article couldn't be turned into plain text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
             return child.value;
         })
             .join("");

package/dist/slices/article/provided-entries.js

@@ -11,7 +11,7 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
     const { projectId } = audioContext.stage;
     const project = projectById(deps.db, projectId);
     if (!project)
-        throw new Error(`project ${projectId} has no row`);
+        throw new Error("This project no longer exists; it may have been deleted while it was running.");
     const { config } = project;
     if (config.sources.article !== "provide" || config.sources.audio !== "generate")
         return "done";
@@ -20,11 +20,11 @@ export async function prepareProvidedArticleSegments(deps, audioContext, provide
     audioContext.signal.throwIfAborted();
     const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
     if (!article)
-        throw new Error(`project ${projectId} has no article stage`);
+        throw new Error("Slopify hit an internal error (the project has no article stage). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
     const outputs = outputsOf(deps.db, projectId);
     const plain = outputs.find((output) => output.role === "article_txt");
     if (!plain)
-        throw new Error("the run has no provided article text");
+        throw new Error("The article text you provided is missing, so the intro and outro can't be written from it. Paste the article again in Edit project → Article, then Retry stage.");
     const narration = readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8");
     const saved = outputs.find((output) => output.stageKind === "article" && output.role === "instructions");
     let instructions = saved

package/dist/slices/article/run.js

@@ -13,14 +13,14 @@ export async function runArticle(deps, context, providers) {
     const { projectId } = context.stage;
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
-        throw new Error(`project ${projectId} has no row`);
+        throw new Error("This project no longer exists; it may have been deleted while it was running.");
     }
     const choice = project.config.llm;
     const articlePrompt = project.config.rendered.article;
     if (choice === undefined || articlePrompt === undefined) {
         // Admission refuses a run whose article is Generate without both, so
         // reaching here is a bug in admission rather than something the user did.
-        throw new Error("the run has no LLM provider or no rendered article prompt");
+        throw new Error("No AI model or article prompt is set for writing the article. Choose a model in Edit project → Providers and check Edit project → Prompts, then Retry stage.");
     }
     const notes = researchNotes(deps, projectId);
     const brief = { articlePrompt, ...(notes === undefined ? {} : { notes }) };

package/dist/slices/article/segments.js

@@ -7,12 +7,12 @@ export async function writeSegment(providers, choice, config, category, article,
         return { ok: true, value: undefined };
     const body = config.rendered[category];
     if (body === undefined)
-        throw new Error(`the run has no rendered ${category} text`);
+        throw new Error(`Slopify hit an internal error (the ${category} text was never filled in). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
     const common = { category, name: picked.name, mode: picked.mode };
     if (picked.mode === "text")
         return { ok: true, value: { ...common, text: body, tokens: noTokens } };
     if (choice === undefined)
-        throw new Error(`the ${category} has no LLM provider or model`);
+        throw new Error(`No AI model is set for writing the ${category}. Choose one in Edit project → Providers, then Retry stage.`);
     const messages = segmentMessages(body, config, article);
     sent.push({ label: category === "intro" ? "Intro" : "Outro", messages });
     const answer = await providers.llm({
@@ -20,7 +20,9 @@ export async function writeSegment(providers, choice, config, category, article,
         model: choice.model,
         ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
         messages,
-        check: (given) => given.text.trim() === "" ? `the ${category} answered with nothing` : undefined,
+        check: (given) => given.text.trim() === ""
+            ? `The AI model returned an empty ${category}. Retry stage; if it keeps happening, choose a different model in Edit project → Providers.`
+            : undefined,
     });
     if (!answer.ok)
         return answer;

package/dist/slices/control/providers.js

@@ -25,7 +25,7 @@ export const providerChangesSchema = z
         .optional(),
 })
     .strict()
-    .refine((value) => Object.keys(value).length > 0, "Pick at least one provider to update.");
+    .refine((value) => Object.keys(value).length > 0, "Change at least one provider before saving.");
 export function validateLocalProviderChanges(changes, current) {
     const fields = [];
     const families = { llm: "llm", audio: "tts", images: "image" };
@@ -35,7 +35,10 @@ export function validateLocalProviderChanges(changes, current) {
             continue;
         const provider = current.providers.find((one) => one.id === picked.provider && one.family === families[key]);
         if (provider === undefined) {
-            fields.push({ field: key, message: "Choose a provider for this kind of generation." });
+            fields.push({
+                field: key,
+                message: "This provider cannot do this kind of work. Choose another provider.",
+            });
             continue;
         }
         const usable = readinessIsUsable(provider.readiness);
@@ -43,14 +46,18 @@ export function validateLocalProviderChanges(changes, current) {
             fields.push({
                 field: key,
                 message: provider.readiness.kind === "cli"
-                    ? (provider.readiness.issue ?? "Install and sign in to this CLI first.")
-                    : "Save this provider's API key in Settings first.",
+                    ? (provider.readiness.issue ??
+                        "Install this command-line tool on your computer and sign in to it, then try again.")
+                    : "Add this provider's API key in Settings → Providers first.",
             });
         }
     }
     if (changes.audio !== undefined &&
         !current.voices.some((voice) => voice.provider === changes.audio?.provider && voice.voiceId === changes.audio.voice)) {
-        fields.push({ field: "audio.voice", message: "Choose a saved voice for this provider." });
+        fields.push({
+            field: "audio.voice",
+            message: "Choose one of your saved voices for this provider. Add voices in Settings → Voices.",
+        });
     }
     return fields;
 }
@@ -67,10 +74,16 @@ export async function validateProviderChanges(changes, current) {
             continue;
         const result = await checkRuntimeModel(current.modelsFor, picked.provider, families[key], picked.model, picked.thinking);
         if (result === "missing") {
-            fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });
+            fields.push({
+                field: `${key}.model`,
+                message: "This provider does not offer that model. Choose another model.",
+            });
         }
         else if (result === "thinking") {
-            fields.push({ field: `${key}.thinking`, message: "Choose a supported thinking setting." });
+            fields.push({
+                field: `${key}.thinking`,
+                message: "This model does not support that thinking setting. Choose another.",
+            });
         }
     }
     return fields;

package/dist/slices/fonts/catalog.js

@@ -31,7 +31,7 @@ export async function resolveFont(paths, id) {
     return font;
 }
 export function missingFont() {
-    return new Error("The selected font is no longer available. Choose another font.", {
+    return new Error("The chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font in Edit project → Subtitles, then try again.", {
         cause: "font-not-found",
     });
 }

package/dist/slices/fonts/upload.js

@@ -27,7 +27,7 @@ export async function uploadFont(paths, input) {
     const root = join(paths.dataDir, "fonts");
     await mkdir(root, { recursive: true, mode: 0o700 });
     if (!(await lstat(root)).isDirectory())
-        throw new Error("The font storage directory is unavailable.");
+        throw new Error(`Slopify can't save uploaded fonts because ${root} is not a folder. Move or rename that file, then upload the font again.`);
     const temporary = join(root, `.upload-${randomUUID()}`);
     try {
         await writeFile(temporary, input.content, { mode: 0o600, flag: "wx" });