@gentbajko/slopify 0.5.1 → 0.6.1

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,88 @@
+// 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 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,,${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/model.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export const subtitleModes = ["off", "files", "burn-in"];
+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"),
+    fontSize: z.number().int().min(16).max(120).default(48),
+});
+export const defaultSubtitles = {
+    mode: "off",
+    language: "en",
+    fontId: "default",
+    fontSize: 48,
+};

package/dist/slices/subtitles/prepare.js

@@ -0,0 +1,162 @@
+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 }), { 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" });
 }

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

@@ -1,12 +1,18 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 import { transact } from "../../kernel/db/tx.js";
 import { setStageProgress } from "../admission/repo.js";
 import { outputPath } from "../storage/layout.js";
 import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
+import { subtitleRoles } from "../subtitles/prepare.js";
 import { runFfmpeg } from "./ffmpeg.js";
 const progressIntervalMs = 500;
-const renderRoles = ["video", "audio_export", "render_params"];
+const renderRoles = [
+    "video",
+    "audio_export",
+    "render_params",
+    ...subtitleRoles,
+];
 // Both local exports retain the previous finished asset until ffmpeg succeeds and
 // the abort check passes. The part file keeps its muxer's filename extension.
 export async function writeExport(deps, context, output) {
@@ -23,6 +29,7 @@ export async function writeExport(deps, context, output) {
         await runFfmpeg({
             bin: deps.ffmpeg,
             args: output.args(part),
+            cwd: output.subtitles?.directory,
             signal: context.signal,
             log: deps.log,
             onProgress: (elapsedMs) => {
@@ -31,7 +38,9 @@ export async function writeExport(deps, context, output) {
                     return;
                 }
                 announced = at;
-                const current = Math.min(elapsedMs, totalMs);
+                const current = output.subtitles === undefined
+                    ? Math.min(elapsedMs, totalMs)
+                    : Math.round((0.35 + 0.65 * Math.min(elapsedMs / totalMs, 1)) * totalMs);
                 setStageProgress(deps.db, context.stage.id, current, totalMs);
                 context.emit({
                     type: "stage.progress",
@@ -51,26 +60,82 @@ export async function writeExport(deps, context, output) {
         // A partial render file is discarded, never kept or served. Only the part file: the
         // previous export is a finished output and stays downloadable.
         rmSync(part, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
         throw error;
     }
-    // The swap. Everything below replaces the previous render, and nothing above it could.
-    renameSync(part, target);
     const params = outputPath(deps.paths, projectId, "render.json");
-    writeFileSync(params, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
-    // No version history. The files were written under the names the previous render
-    // already used, so replacing the rows that named them is all that is left to do. In one
-    // transaction, or a crash between the delete and the insert would leave the finished
-    // export with no row and the boot reconcile would collect it. Read back rather than
-    // reused from above: the rows are what a download resolves.
-    transact(deps.db, () => {
-        for (const previous of outputsOf(deps.db, projectId)) {
-            if (renderRoles.includes(previous.role)) {
-                deleteOutput(deps.db, previous.id);
+    const previousOutputs = outputsOf(deps.db, projectId);
+    const replaced = [];
+    const paramsPart = outputPath(deps.paths, projectId, "render.part.json");
+    let committed = false;
+    try {
+        writeFileSync(paramsPart, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
+        // The DB commit can fail after ffmpeg succeeds. Keep rollback copies until all
+        // media, caption and font rows commit, so a failed export keeps its old playback.
+        for (const path of [target, params]) {
+            const saved = { path, backup: `${path}.previous`, existed: existsSync(path), swapped: false };
+            if (saved.existed)
+                copyFileSync(path, saved.backup);
+            replaced.push(saved);
+        }
+        for (const saved of replaced) {
+            renameSync(saved.path === target ? part : paramsPart, saved.path);
+            saved.swapped = true;
+        }
+        transact(deps.db, () => {
+            for (const previous of previousOutputs) {
+                if (renderRoles.includes(previous.role))
+                    deleteOutput(deps.db, previous.id);
             }
+            store(deps, projectId, "render_params", "render.json", null);
+            store(deps, projectId, output.role, output.filename, totalMs, {
+                subtitlesMode: output.subtitles === undefined ? "off" : output.subtitles.burnIn ? "burn-in" : "files",
+            });
+            for (const asset of output.subtitles?.assets ?? [])
+                store(deps, projectId, asset.role, asset.path, null);
+        });
+        committed = true;
+    }
+    catch (error) {
+        for (const saved of replaced) {
+            if (!saved.swapped)
+                continue;
+            if (saved.existed)
+                renameSync(saved.backup, saved.path);
+            else
+                rmSync(saved.path, { force: true });
+            saved.swapped = false;
         }
-        store(deps, projectId, "render_params", "render.json", null);
-        store(deps, projectId, output.role, output.filename, totalMs);
-    });
+        rmSync(part, { force: true });
+        rmSync(paramsPart, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        for (const saved of replaced) {
+            if (!committed && saved.swapped)
+                continue;
+            try {
+                rmSync(saved.backup, { force: true });
+            }
+            catch {
+                /* A retained backup is collected at the next boot. */
+            }
+        }
+    }
+    const kept = new Set(outputsOf(deps.db, projectId).map((one) => one.path));
+    for (const previous of previousOutputs) {
+        if (renderRoles.includes(previous.role) && !kept.has(previous.path)) {
+            try {
+                rmSync(outputPath(deps.paths, projectId, previous.path), { force: true });
+            }
+            catch {
+                /* Boot reconciliation collects a file that could not be removed. */
+            }
+        }
+    }
     // Written as well as emitted: a page opened after the render reads the row, and the
     // throttled in-flight writes would have left it frozen short of the end.
     setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
@@ -82,7 +147,7 @@ export async function writeExport(deps, context, output) {
         total: totalMs,
     });
 }
-function store(deps, projectId, role, path, durationMs) {
+function store(deps, projectId, role, path, durationMs, meta = {}) {
     insertOutput(deps.db, {
         id: deps.ids.next(),
         projectId,
@@ -92,7 +157,7 @@ function store(deps, projectId, role, path, durationMs) {
         originalFilename: null,
         bytes: statSync(outputPath(deps.paths, projectId, path)).size,
         durationMs,
-        meta: {},
+        meta,
         createdAt: deps.clock.now().toISOString(),
     });
 }