@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/slices/settings/models.js

@@ -0,0 +1,89 @@
+// These marketplaces host models with different input schemas. Discovery alone cannot
+// make an arbitrary endpoint compatible with our image request.
+export function allowsCustomModel(provider) {
+    return provider !== "fal" && provider !== "replicate";
+}
+const ttlMs = 5 * 60_000;
+const retryMs = 30_000;
+export function createModelCatalog(deps) {
+    const cache = new Map();
+    const pending = new Map();
+    const generations = new Map();
+    async function get(provider, family, refresh = false) {
+        const active = pending.get(provider);
+        if (active !== undefined)
+            return active;
+        const previous = cache.get(provider);
+        if (!refresh && previous !== undefined && previous.expires > deps.now())
+            return previous.value;
+        const generation = generations.get(provider) ?? 0;
+        const task = Promise.resolve()
+            .then(async () => {
+            let value;
+            let lifetime = ttlMs;
+            try {
+                const models = await deps.load(provider, family);
+                value = {
+                    models: uniqueModels(models),
+                    allowsCustom: allowsCustomModel(provider),
+                    ...catalogNotice(provider),
+                };
+            }
+            catch {
+                // A catalogue is metadata, not generation. Never expose an upstream response
+                // here: it can quote credentials that belong only inside its adapter.
+                deps.report(provider);
+                const saved = previous?.value.models;
+                value = {
+                    models: saved ?? deps.fallback(provider),
+                    ...catalogNotice(provider),
+                    allowsCustom: allowsCustomModel(provider),
+                    warning: saved === undefined
+                        ? "Could not load the model list. Showing bundled choices; refresh to try again."
+                        : "Could not refresh the model list. Showing the last loaded choices.",
+                };
+                lifetime = retryMs;
+            }
+            if ((generations.get(provider) ?? 0) === generation) {
+                cache.set(provider, { value, expires: deps.now() + lifetime });
+            }
+            return value;
+        })
+            .finally(() => {
+            if (pending.get(provider) === task)
+                pending.delete(provider);
+        });
+        pending.set(provider, task);
+        return task;
+    }
+    return {
+        get,
+        invalidate: (provider) => {
+            generations.set(provider, (generations.get(provider) ?? 0) + 1);
+            cache.delete(provider);
+            pending.delete(provider);
+        },
+    };
+}
+function uniqueModels(models) {
+    const seen = new Set();
+    return models.filter((model) => {
+        if (model.id.trim() === "" || seen.has(model.id))
+            return false;
+        seen.add(model.id);
+        return true;
+    });
+}
+function catalogNotice(provider) {
+    const notices = {
+        codex: "Models come from Codex's local catalogue. Open Codex to refresh that catalogue, then refresh this list.",
+        gemini: "Models and aliases come from the installed Gemini CLI. Update that CLI to discover newer models.",
+        "claude-code": "These aliases follow Claude Code's model families. You can also enter an exact model ID.",
+        inworld: "These are Inworld’s documented TTS models. You can also enter a compatible model ID.",
+        cartesia: "Cartesia has no model-list API. These are bundled compatible choices; you can enter a newer model ID.",
+        fal: "These models have input formats supported by Slopify's fal adapter.",
+        replicate: "These models have input formats supported by Slopify's Replicate adapter.",
+    };
+    const notice = Object.hasOwn(notices, provider) ? notices[provider] : undefined;
+    return notice === undefined ? {} : { notice };
+}

package/dist/slices/settings/readiness.js

@@ -1,19 +1,23 @@
+import { cliPathStatus } from "./cli-paths.js";
 import { cliReadiness } from "./cli-status.js";
 import { providers } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
 // a reason instead of hiding it. A keyed provider is ready when a key is stored; a CLI provider
-// when its binary answers. Readiness is computed per request and nothing about a CLI is stored.
+// when its binary answers. Readiness is computed per request using the latest saved executable override.
 export async function providerStatuses(deps) {
     const keyed = keyedProviders(deps.db);
-    return await Promise.all(providers.map(async (provider) => ({
-        id: provider.id,
-        family: provider.family,
-        displayName: provider.displayName,
-        readiness: provider.auth === "cli"
-            ? await cliReadiness(deps.probe, provider)
-            : keyedReadiness(keyed, provider.id),
-    })));
+    return await Promise.all(providers.map(async (provider) => {
+        const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
+        if (provider.auth !== "cli")
+            return { ...base, readiness: keyedReadiness(keyed, provider.id) };
+        const cliPath = cliPathStatus(deps.db, provider.id);
+        return {
+            ...base,
+            cliPath,
+            readiness: await cliReadiness(deps.probe, { ...provider, binary: cliPath.command }),
+        };
+    }));
 }
 function keyedReadiness(keyed, id) {
     return { kind: "keyed", hasKey: keyed.has(id) };

package/dist/slices/storage/downloads.js

@@ -19,6 +19,8 @@ const contentTypes = {
     ".ogg": "audio/ogg",
     ".opus": "audio/opus",
     ".mp4": "video/mp4",
+    ".srt": "application/x-subrip; charset=utf-8",
+    ".vtt": "text/vtt; charset=utf-8",
 };
 // Leaves room for "-<asset>.<ext>" inside a 255-byte filename, and keeps a download
 // folder readable when a title runs to the 200 characters the schema allows.

package/dist/slices/storage/layout.js

@@ -34,6 +34,16 @@ export function outputFileName(role, index, extension, stageKind) {
             return "sources.txt";
         case "glossary":
             return "glossary.txt";
+        case "subtitles_srt":
+            return "subtitles.srt";
+        case "subtitles_vtt":
+            return "subtitles.vtt";
+        case "subtitle_words":
+            return "subtitles.json";
+        case "subtitle_ass":
+            return "subtitles.ass";
+        case "subtitle_font":
+            return `subtitle-font${extension}`;
         case "render_params":
             return "render.json";
         case "instructions":

package/dist/slices/storage/model.js

@@ -16,6 +16,11 @@ export const outputRoles = [
     "thumbnail",
     "video",
     "render_params",
+    "subtitles_srt",
+    "subtitles_vtt",
+    "subtitle_words",
+    "subtitle_ass",
+    "subtitle_font",
     "instructions",
 ];
 export const stagedFileStates = ["copying", "staged"];

package/dist/slices/storage/repo.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 const metaSchema = z.object({
+    subtitlesMode: z.enum(["off", "files", "burn-in"]).optional(),
     promptName: z.string().optional(),
     prompt: z.string().optional(),
     index: z.number().optional(),

package/dist/slices/subtitles/captions.js

@@ -0,0 +1,91 @@
+import { subtitlePlacement } from "./layout.js";
+// Keep spoken spelling and punctuation. Word times come only from acoustic alignment.
+export function captionCues(words) {
+    const cues = [];
+    let pending = [];
+    let previousEnd = 0;
+    const flush = () => {
+        const first = pending[0];
+        const last = pending.at(-1);
+        if (first !== undefined && last !== undefined) {
+            cues.push({
+                start: first.start,
+                end: last.end,
+                text: wrap(pending.map((word) => word.text)),
+            });
+        }
+        pending = [];
+    };
+    for (const word of words) {
+        if (!Number.isFinite(word.start) ||
+            !Number.isFinite(word.end) ||
+            word.start < previousEnd - 0.001 ||
+            word.end <= word.start) {
+            throw new Error("The subtitle word timing is invalid; regenerate alignment.");
+        }
+        const first = pending[0];
+        if (first !== undefined &&
+            (word.start - previousEnd > 0.7 ||
+                word.end - first.start > 5 ||
+                wrap([...pending.map((one) => one.text), word.text]).split("\n").length > 2)) {
+            flush();
+        }
+        pending.push({ ...word, text: word.text.replace(/\s+/g, " ").trim() });
+        previousEnd = word.end;
+        if (/[.!?]["'’”)]*$/.test(word.text))
+            flush();
+    }
+    flush();
+    return cues;
+}
+function wrap(words) {
+    const lines = [];
+    let line = "";
+    for (const word of words) {
+        if (line !== "" && line.length + word.length + 1 > 42) {
+            lines.push(line);
+            line = "";
+        }
+        line = line === "" ? word : `${line} ${word}`;
+    }
+    if (line !== "")
+        lines.push(line);
+    return lines.join("\n");
+}
+export function serializeSrt(cues) {
+    return cues
+        .map((cue, index) => `${index + 1}\n${stamp(cue.start, ",")} --> ${stamp(cue.end, ",")}\n${markup(cue.text)}\n`)
+        .join("\n");
+}
+export function serializeVtt(cues) {
+    return `WEBVTT\n\n${cues.map((cue) => `${stamp(cue.start, ".")} --> ${stamp(cue.end, ".")}\n${markup(cue.text)}\n`).join("\n")}`;
+}
+export function serializeAss(cues, style) {
+    const name = style.fontName.replace(/[\p{Cc},]/gu, " ").trim();
+    const placement = subtitlePlacement(style.position ?? "bottom", style.height);
+    const position = `{\\an${placement.alignment}\\pos(${style.width / 2},${placement.y})}`;
+    const header = `[Script Info]\nScriptType: v4.00+\nPlayResX: ${style.width}\nPlayResY: ${style.height}\nWrapStyle: 0\nScaledBorderAndShadow: yes\n\n[V4+ Styles]\nFormat: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\nStyle: Default,${name},${style.fontSize},&H00FFFFFF,&H00FFFFFF,&H00101010,&H80000000,0,0,0,0,100,100,0,0,1,2.5,1,2,60,60,60,1\n\n[Events]\nFormat: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n`;
+    return (header +
+        cues
+            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${position}${assText(cue.text)}\n`)
+            .join(""));
+}
+function markup(text) {
+    return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function assText(text) {
+    // Full-width alternatives stay visible and cannot open an ASS override or escape.
+    return text
+        .replaceAll("\\", "＼")
+        .replaceAll("{", "｛")
+        .replaceAll("}", "｝")
+        .replaceAll("\n", "\\N");
+}
+function stamp(seconds, separator) {
+    const ms = Math.max(0, Math.round(seconds * 1000));
+    return `${String(Math.floor(ms / 3_600_000)).padStart(2, "0")}:${String(Math.floor(ms / 60_000) % 60).padStart(2, "0")}:${String(Math.floor(ms / 1000) % 60).padStart(2, "0")}${separator}${String(ms % 1000).padStart(3, "0")}`;
+}
+function assStamp(seconds) {
+    const cs = Math.max(0, Math.round(seconds * 100));
+    return `${Math.floor(cs / 360_000)}:${String(Math.floor(cs / 6000) % 60).padStart(2, "0")}:${String(Math.floor(cs / 100) % 60).padStart(2, "0")}.${String(cs % 100).padStart(2, "0")}`;
+}

package/dist/slices/subtitles/layout.js

@@ -0,0 +1,19 @@
+export function subtitleFrame(format) {
+    return format === "9:16" ? { width: 1080, height: 1920 } : { width: 1920, height: 1080 };
+}
+// ASS and the browser preview share anchors. Edge positions keep the existing
+// 60-pixel safe margin; interior positions center both single and multiline cues.
+export function subtitlePlacement(position, height) {
+    switch (position) {
+        case "top":
+            return { y: 60, alignment: 8, translateY: 0 };
+        case "upper-middle":
+            return { y: height / 4, alignment: 5, translateY: -50 };
+        case "center":
+            return { y: height / 2, alignment: 5, translateY: -50 };
+        case "lower-middle":
+            return { y: (height * 3) / 4, alignment: 5, translateY: -50 };
+        case "bottom":
+            return { y: height - 60, alignment: 2, translateY: -100 };
+    }
+}

package/dist/slices/subtitles/model.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export const subtitleModes = ["off", "files", "burn-in"];
+export const subtitlePositions = [
+    "top",
+    "upper-middle",
+    "center",
+    "lower-middle",
+    "bottom",
+];
+export const subtitleConfigSchema = z.object({
+    mode: z.enum(subtitleModes),
+    language: z.literal("en").default("en"),
+    fontId: z
+        .string()
+        .max(160)
+        .regex(/^[A-Za-z0-9_-]+$/)
+        .default("default"),
+    position: z.enum(subtitlePositions).default("bottom"),
+    fontSize: z.number().int().min(16).max(120).default(48),
+});
+export const defaultSubtitles = {
+    mode: "off",
+    language: "en",
+    fontId: "default",
+    fontSize: 48,
+    position: "bottom",
+};

package/dist/slices/subtitles/prepare.js

@@ -0,0 +1,167 @@
+import { createHash } from "node:crypto";
+import { copyFileSync, createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { z } from "zod";
+import { projectById, setStageProgress } from "../admission/repo.js";
+import { resolveFont } from "../fonts/index.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { captionCues, serializeAss, serializeSrt, serializeVtt } from "./captions.js";
+import { defaultSubtitles } from "./model.js";
+import { spokenText } from "./transcript.js";
+export const subtitleRoles = [
+    "subtitles_srt",
+    "subtitles_vtt",
+    "subtitle_words",
+    "subtitle_ass",
+    "subtitle_font",
+];
+const wordSchema = z.object({
+    text: z.string(),
+    start: z.number().nonnegative(),
+    end: z.number().positive(),
+    confidence: z.number().optional(),
+});
+const fontSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    assName: z.string(),
+    extension: z.enum([".ttf", ".otf", ".ttc"]),
+});
+const cacheSchema = z.object({ key: z.string(), words: z.array(wordSchema), font: fontSchema });
+// Preparation writes into a new directory; only writeExport commits its output rows.
+// The old caption files/font/timing stay usable if alignment or rendering fails.
+export async function prepareSubtitles(deps, context, audio, frame) {
+    const { projectId } = context.stage;
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        throw new Error("The project no longer exists.");
+    const config = project.config.subtitles ?? defaultSubtitles;
+    if (config.mode === "off")
+        return undefined;
+    if (audio.length === 0)
+        throw new Error("Subtitles need narration audio.");
+    const outputs = outputsOf(deps.db, projectId);
+    const segments = audio.map((segment) => ({
+        ...segment,
+        text: segment.kind === "gap" ? "" : spokenText(deps, projectId, segment.kind, outputs),
+    }));
+    const key = await timingKey(segments, context.signal);
+    const cache = readCache(deps, projectId, outputs);
+    const dir = projectDir(deps.paths, projectId);
+    const directory = mkdtempSync(join(dir, "captions-"));
+    try {
+        const font = await snapshotFont(deps, projectId, outputs, config.fontId, cache, directory);
+        const words = cache?.key === key ? cache.words : await alignSegments(deps, context, segments);
+        context.signal.throwIfAborted();
+        const cues = captionCues(words);
+        if (cues.length === 0)
+            throw new Error("No spoken words could be aligned. Check that the English article matches the audio.");
+        writeFileSync(join(directory, "subtitles.srt"), serializeSrt(cues), { mode: 0o600 });
+        writeFileSync(join(directory, "subtitles.vtt"), serializeVtt(cues), { mode: 0o600 });
+        writeFileSync(join(directory, "subtitles.ass"), serializeAss(cues, {
+            ...frame,
+            fontSize: config.fontSize,
+            fontName: font.assName,
+            position: config.position,
+        }), { mode: 0o600 });
+        writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font }), {
+            mode: 0o600,
+        });
+        const files = [
+            ["subtitles_srt", "subtitles.srt"],
+            ["subtitles_vtt", "subtitles.vtt"],
+            ["subtitle_words", "subtitles.json"],
+            ["subtitle_ass", "subtitles.ass"],
+            ["subtitle_font", `fonts/selected${font.extension}`],
+        ];
+        return {
+            directory,
+            burnIn: config.mode === "burn-in" && project.config.sources.video !== "off",
+            assets: files.map(([role, path]) => ({
+                role,
+                path: relative(dir, join(directory, path)).split(sep).join("/"),
+            })),
+        };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function timingKey(segments, signal) {
+    // Bump when alignment normalization/model changes. Hash file contents, not timestamps.
+    const hash = createHash("sha256").update("wav2vec2-en-a19f851-v1");
+    for (const segment of segments) {
+        signal.throwIfAborted();
+        hash.update(JSON.stringify({ kind: segment.kind, seconds: segment.seconds, text: segment.text }));
+        if (segment.path !== null) {
+            const stream = createReadStream(segment.path, { signal });
+            for await (const chunk of stream)
+                hash.update(chunk);
+        }
+    }
+    return hash.digest("hex");
+}
+async function alignSegments(deps, context, segments) {
+    if (deps.alignSubtitles === undefined)
+        throw new Error("Local subtitle alignment is unavailable in this build.");
+    const words = [];
+    const total = segments.reduce((sum, segment) => sum + segment.seconds, 0);
+    let offset = 0;
+    for (const segment of segments) {
+        context.signal.throwIfAborted();
+        if (segment.path !== null) {
+            const aligned = await deps.alignSubtitles({
+                audioPath: segment.path,
+                text: segment.text,
+                cacheDir: join(deps.paths.dataDir, "models", "english-subtitles"),
+                ffmpeg: deps.ffmpeg,
+                signal: context.signal,
+                onProgress: (current, maximum) => {
+                    const progress = Math.round((35 * (offset + segment.seconds * (maximum > 0 ? current / maximum : 0))) / total);
+                    setStageProgress(deps.db, context.stage.id, progress, 100);
+                    context.emit({
+                        type: "stage.progress",
+                        projectId: context.stage.projectId,
+                        stage: "video",
+                        current: progress,
+                        total: 100,
+                    });
+                },
+            });
+            for (const word of aligned) {
+                if (word.end > segment.seconds + 0.1)
+                    throw new Error("Subtitle timing exceeds the narration duration.");
+                words.push({
+                    ...word,
+                    start: word.start + offset,
+                    end: Math.min(word.end, segment.seconds) + offset,
+                });
+            }
+        }
+        offset += segment.seconds;
+    }
+    return words;
+}
+function readCache(deps, projectId, outputs) {
+    const output = outputs.find((one) => one.role === "subtitle_words");
+    if (output === undefined)
+        return undefined;
+    try {
+        return cacheSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, projectId, output.path), "utf8")));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function snapshotFont(deps, projectId, outputs, id, cache, directory) {
+    const previous = outputs.find((one) => one.role === "subtitle_font");
+    const previousPath = previous === undefined ? undefined : outputPath(deps.paths, projectId, previous.path);
+    const saved = cache?.font.id === id && previousPath !== undefined && existsSync(previousPath)
+        ? { ...cache.font, path: previousPath }
+        : await resolveFont(deps.paths, id);
+    mkdirSync(join(directory, "fonts"), { mode: 0o700 });
+    copyFileSync(saved.path, join(directory, "fonts", `selected${saved.extension}`));
+    return { id: saved.id, name: saved.name, assName: saved.assName, extension: saved.extension };
+}

package/dist/slices/subtitles/transcript.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import { piecesOf } from "../../kernel/runner/piece-repo.js";
+import { stagesOf } from "../admission/repo.js";
+import { outputPath } from "../storage/layout.js";
+const textPayload = z.object({ text: z.string(), category: z.string().optional() });
+export function spokenText(deps, projectId, kind, outputs) {
+    const stages = stagesOf(deps.db, projectId);
+    if (kind === "body") {
+        const audio = stages.find((stage) => stage.kind === "audio");
+        if (audio?.source === "generate") {
+            const chunks = piecesOf(deps.db, audio.id, "chunk");
+            if (chunks.length > 0)
+                return chunks.map((piece) => payload(piece.payload).text).join("\n");
+        }
+        const article = outputs.find((output) => output.role === "article_txt");
+        if (article !== undefined)
+            return readFileSync(outputPath(deps.paths, projectId, article.path), "utf8");
+    }
+    else {
+        const article = stages.find((stage) => stage.kind === "article");
+        if (article !== undefined) {
+            const segment = piecesOf(deps.db, article.id, "segment")
+                .map((piece) => payload(piece.payload))
+                .find((piece) => piece.category === kind);
+            if (segment !== undefined)
+                return segment.text;
+        }
+    }
+    throw new Error(`The saved ${kind} narration text is missing. Subtitles need the text spoken in the audio.`);
+}
+function payload(raw) {
+    return textPayload.parse(JSON.parse(raw ?? "null"));
+}

package/dist/slices/video/audio-export.js

@@ -1,6 +1,7 @@
 import { relative } from "node:path";
 import { projectDir } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
+import { prepareSubtitles } from "../subtitles/prepare.js";
 import { audioInputs } from "./audio-inputs.js";
 import { audioTimeline } from "./plan.js";
 import { writeExport } from "./write-export.js";
@@ -23,12 +24,14 @@ export async function exportAudioWav(deps, context, gapSeconds) {
         })),
         output: "audio.wav",
     };
+    const subtitles = await prepareSubtitles(deps, context, audio, { width: 1920, height: 1080 });
     await writeExport(deps, context, {
         role: "audio_export",
         filename: "audio.wav",
         partName: "audio.part.wav",
         totalSeconds,
         record: plan,
+        subtitles,
         args: (part) => audioExportArgs(audio, part),
     });
 }

package/dist/slices/video/ffmpeg.js

@@ -1,11 +1,12 @@
 import { spawn } from "node:child_process";
+import { isAbsolute, resolve as resolvePath } from "node:path";
 import { zoomBy, zoomFrom, zoomTo } from "./plan.js";
 // Hand-rolled per the standards: the filtergraph is the load-bearing part of this slice
 // and a wrapper would hide it. Every value goes into an argument array, never a shell
 // string, so a title or a filename cannot become a command.
 // zoompan works on a still that has been pre-scaled, because it steps the zoom in
 // sub-pixel increments and a source at output resolution visibly jitters where the zoom is
-// meant to be smooth and linear. Four times the frame is enough at 115%.
+// meant to be smooth and linear. Four times the frame is enough at 122.5%.
 const prescale = 4;
 const sampleRate = 44100;
 const channelLayout = "stereo";
@@ -26,7 +27,7 @@ export function resolveFfmpeg(env, bundled) {
     throw new Error("No ffmpeg binary is available. Slopify ships one through ffmpeg-static; if this " +
         "platform has no build, point SLOPIFY_FFMPEG at an ffmpeg executable.");
 }
-export function renderArgs(plan) {
+export function renderArgs(plan, burnSubtitles = false) {
     const inputs = [];
     for (const slot of plan.images) {
         inputs.push("-i", slot.path);
@@ -52,7 +53,7 @@ export function renderArgs(plan) {
         "-y",
         ...inputs,
         "-filter_complex",
-        filterGraph(plan, audioAt),
+        filterGraph(plan, audioAt, burnSubtitles),
         "-map",
         "[v]",
         ...(plan.audio.length > 0 ? ["-map", "[a]"] : []),
@@ -66,7 +67,7 @@ export function renderArgs(plan) {
         plan.output,
     ];
 }
-function filterGraph(plan, audioAt) {
+function filterGraph(plan, audioAt, burnSubtitles) {
     const chains = [];
     const wide = plan.width * prescale;
     const tall = plan.height * prescale;
@@ -78,7 +79,9 @@ function filterGraph(plan, audioAt) {
             `x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':` +
             `s=${plan.width}x${plan.height}:fps=${plan.fps},setsar=1[v${at}]`);
     });
-    chains.push(`${plan.images.map((_slot, at) => `[v${at}]`).join("")}concat=n=${plan.images.length}:v=1:a=0[v]`);
+    chains.push(`${plan.images.map((_slot, at) => `[v${at}]`).join("")}concat=n=${plan.images.length}:v=1:a=0${burnSubtitles ? "[uncaptioned]" : "[v]"}`);
+    if (burnSubtitles)
+        chains.push("[uncaptioned]ass=filename=subtitles.ass:fontsdir=fonts[v]");
     audioAt.forEach((input, at) => {
         // The segments come from different files and the silence from lavfi, so they are
         // brought to one format before concat, which refuses to join mismatched streams.
@@ -89,7 +92,7 @@ function filterGraph(plan, audioAt) {
     }
     return chains.join(";");
 }
-// Odd images 100% → 115%, even images 115% → 100%, linear over the slot. `on` is
+// Odd images 100% → 122.5%, even images 122.5% → 100%, linear over the slot. `on` is
 // zoompan's output frame counter, 0 to d-1, and a one-frame slot has no span to divide
 // by, so it holds the zoom it starts at.
 function zoomExpression(slot) {
@@ -120,9 +123,13 @@ export function runFfmpeg(run) {
             reject(new Error("the render was canceled before it started"));
             return;
         }
-        const child = spawn(run.bin, [...run.args], {
+        // Subtitle filters use their own working directory. An explicit relative binary
+        // still resolves from the app launch directory, where boot verified it.
+        const executable = !isAbsolute(run.bin) && /[\\/]/.test(run.bin) ? resolvePath(run.bin) : run.bin;
+        const child = spawn(executable, [...run.args], {
             stdio: ["ignore", "pipe", "pipe"],
             windowsHide: true,
+            ...(run.cwd === undefined ? {} : { cwd: run.cwd }),
         });
         const errors = [];
         let pending = "";

package/dist/slices/video/plan.js

@@ -4,12 +4,12 @@ const frames = {
     "16:9": { width: 1920, height: 1080 },
     "9:16": { width: 1080, height: 1920 },
 };
-// 100% → 115%, linear, centred, alternating per image. The three are written out
+// 100% → 122.5%, linear, centred, alternating per image. The three are written out
 // rather than derived from one another, because they are formatted into an ffmpeg
-// expression and 1.15 - 1 is not 0.15 in binary floating point.
+// expression and 1.225 - 1 is not 0.225 in binary floating point.
 export const zoomFrom = 1;
-export const zoomTo = 1.15;
-export const zoomBy = 0.15;
+export const zoomTo = 1.225;
+export const zoomBy = 0.225;
 export function planRender(input) {
     if (input.images.length === 0) {
         // Admission permits Video only with an image source, so an empty set is a bug upstream.

package/dist/slices/video/run.js

@@ -2,6 +2,7 @@ import { relative } from "node:path";
 import { projectById } from "../admission/repo.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { outputsOf } from "../storage/repo.js";
+import { prepareSubtitles } from "../subtitles/prepare.js";
 import { exportAudioWav } from "./audio-export.js";
 import { audioInputs } from "./audio-inputs.js";
 import { renderArgs } from "./ffmpeg.js";
@@ -30,13 +31,15 @@ export async function renderVideo(deps, context) {
         images: slideshow(outputs).map((output) => outputPath(deps.paths, projectId, output.path)),
         output: outputPath(deps.paths, projectId, "video.mp4"),
     });
+    const subtitles = await prepareSubtitles(deps, context, plan.audio, plan);
     await writeExport(deps, context, {
         role: "video",
         filename: "video.mp4",
         partName: "video.part.mp4",
         totalSeconds: plan.totalSeconds,
-        record: recorded(plan, dir),
-        args: (part) => renderArgs({ ...plan, output: part }),
+        record: { ...recorded(plan, dir), subtitles: project.config.subtitles ?? null },
+        subtitles,
+        args: (part) => renderArgs({ ...plan, output: part }, subtitles?.burnIn),
     });
     deps.count("stage.completed", { stage: "video" });
 }