@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/style-preview/render.js

@@ -0,0 +1,148 @@
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { defaultMotionStyle, defaultZoomPercent } from "../admission/rules.js";
+import { isMissingFont, resolveBoldFont, resolveFont } from "../fonts/index.js";
+import { renderShort } from "../shorts/render.js";
+import { serializeAss } from "../subtitles/captions.js";
+import { subtitleFrame } from "../subtitles/layout.js";
+import { planRender } from "../video/plan.js";
+import { renderSlideshow } from "../video/slideshow.js";
+import { bundledSampleAssets, sampleNarrationSeconds } from "./narration.js";
+import { stylePreviewSeconds } from "./schema.js";
+import { previewCues, previewWords } from "./settings.js";
+export class StylePreviewError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+// ceiling: small enough to render in a few seconds on a laptop, big enough to judge a font.
+// The short side is 270 px; the captions' script keeps its full-size frame and libass scales
+// it, so a caption sits exactly where it would in the real video.
+const previewFrame = {
+    "16:9": { width: 480, height: 270 },
+    "9:16": { width: 270, height: 480 },
+};
+const shotSeconds = stylePreviewSeconds / 3;
+const chapterTitle = "Chapter one";
+export function ffmpegStylePreview(deps) {
+    const assets = deps.assets ?? bundledSampleAssets();
+    return async (settings, output, signal, picture) => {
+        try {
+            // A real picture is shown for all three shots: the motion, the Look and the captions read
+            // on it, and the transition and chapter card still show at the cuts.
+            const images = picture !== undefined
+                ? [picture, picture, picture]
+                : settings.format === "9:16"
+                    ? assets.tall
+                    : assets.wide;
+            if (settings.short !== undefined)
+                await renderShortPreview(deps, settings, settings.short, assets, images, output, signal);
+            else
+                await renderPreview(deps, settings, assets, images, output, signal);
+        }
+        catch (error) {
+            throw explained(deps.log, error);
+        }
+    };
+}
+async function renderPreview(deps, settings, assets, images, output, signal) {
+    mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+    const workspace = mkdtempSync(join(deps.dir, "work-"));
+    try {
+        const cardFont = settings.chapterCard === null
+            ? undefined
+            : await resolveFont(deps.paths, settings.chapterCard.fontId);
+        const plan = planRender({
+            format: settings.format,
+            gapSeconds: 0,
+            edgeSeconds: 0,
+            imageSeconds: shotSeconds,
+            zoomPercent: defaultZoomPercent,
+            motionStyle: defaultMotionStyle,
+            images,
+            output,
+            edit: {
+                ...(settings.transition === null ? {} : { transition: settings.transition }),
+                look: settings.look,
+                ...(cardFont === undefined
+                    ? {}
+                    : {
+                        cards: {
+                            // On the cut into the second still, so the transition and the card both show.
+                            chapters: [{ title: chapterTitle, start: shotSeconds }],
+                            font: { path: cardFont.path, name: cardFont.assName },
+                        },
+                    }),
+            },
+        });
+        const edit = {
+            ...plan.editList,
+            ...previewFrame[settings.format],
+            audio: [{ kind: "body", path: assets.narration, seconds: plan.totalSeconds }],
+        };
+        const captions = settings.captions;
+        if (captions !== null) {
+            const font = await resolveFont(deps.paths, captions.fontId);
+            mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
+            copyFileSync(font.path, join(workspace, "fonts", `selected${font.extension}`));
+            writeFileSync(join(workspace, "subtitles.ass"), serializeAss(previewCues(captions.text), {
+                ...subtitleFrame(settings.format),
+                fontName: font.assName,
+                fontSize: captions.fontSize,
+                position: captions.position,
+            }), { mode: 0o600 });
+        }
+        await renderSlideshow({
+            bin: deps.ffmpeg,
+            edit,
+            output,
+            burnSubtitles: captions !== null,
+            cwd: workspace,
+            scratch: workspace,
+            signal,
+            log: deps.log,
+            onProgress: () => { },
+        });
+    }
+    finally {
+        rmSync(workspace, { recursive: true, force: true });
+    }
+}
+// The Shorts layout, drawn at the preview's size: the same audio cut, image timing, captions
+// and headline a short gets, from the sample narration.
+async function renderShortPreview(deps, settings, short, assets, images, output, signal) {
+    mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+    await renderShort({
+        bin: deps.ffmpeg,
+        timeline: [{ kind: "body", path: assets.narration, seconds: sampleNarrationSeconds }],
+        start: 0,
+        end: sampleNarrationSeconds,
+        images,
+        imageSeconds: shotSeconds,
+        motionStyle: defaultMotionStyle,
+        zoomPercent: defaultZoomPercent,
+        words: previewWords(short.text),
+        font: await resolveBoldFont(deps.paths, short.fontId),
+        ...(short.title === null ? {} : { title: short.title }),
+        speed: short.speed,
+        frame: previewFrame[settings.format],
+        output,
+        scratch: deps.dir,
+        signal,
+        log: deps.log,
+        onProgress: () => { },
+    });
+}
+function explained(log, error) {
+    if (error instanceof StylePreviewError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    if (isMissingFont(error))
+        return new StylePreviewError("font-missing", "The style preview couldn't render because the chosen caption font is no longer available; it may have been uninstalled or deleted. Choose another font under Subtitles, then press Render again.");
+    if (message.startsWith("Slopify could not start ffmpeg") || /\bENOENT\b/.test(message))
+        return new StylePreviewError("ffmpeg-missing", "The style preview couldn't render because ffmpeg wasn't found. Install ffmpeg, or use the Docker image, then press Render again.");
+    log.write("error", "style-preview.render", { detail: message });
+    return new StylePreviewError("render-failed", "The style preview couldn't render because ffmpeg stopped with an error. Press Render again; if it fails again, use Download diagnostics in Settings and report it.");
+}

package/dist/slices/style-preview/schema.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { formats } from "../../kernel/pipeline.js";
+import { videoEditSchema } from "../admission/schema.js";
+import { subtitleModes, subtitlePositions } from "../subtitles/model.js";
+// "See it before you make it": a few seconds rendered by the real renderer with a project's
+// caption and Look settings, on the bundled sample's images and narration. Browser-safe, so
+// Play and Edit project read the same request and reply shapes the server checks.
+// How long the preview runs: three images of two seconds, so a transition and a chapter
+// card both show, under six seconds of the sample narration.
+export const stylePreviewSeconds = 6;
+export const stylePreviewTextMax = 200;
+// The sample text Play starts with. It, or no text, captions the sample narration with its own
+// words; any other text is spread over the stretches the narration speaks.
+export const defaultPreviewText = "Every story begins with a word.";
+export const shortTitlePreviewMax = 100;
+// A picture the preview is drawn on instead of the sample stills: the establishing image a
+// draft uploaded (its staged file), one a project already has (its output), or a channel cast
+// member's picture (by content hash). One the server can no longer find falls back to the
+// stills rather than failing the preview.
+export const stylePreviewImageSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("upload"), stagedFileId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/) }),
+    z.object({ kind: z.literal("output"), outputId: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/) }),
+    z.object({ kind: z.literal("picture"), sha256: z.string().regex(/^[a-f0-9]{64}$/) }),
+]);
+export const stylePreviewRequestSchema = z.object({
+    format: z.enum(formats),
+    subtitles: z.object({
+        mode: z.enum(subtitleModes),
+        fontId: z
+            .string()
+            .max(160)
+            .regex(/^[A-Za-z0-9_-]+$/),
+        fontSize: z.number().finite().min(16).max(120),
+        position: z.enum(subtitlePositions),
+    }),
+    videoEdit: videoEditSchema.optional(),
+    previewText: z.string().max(stylePreviewTextMax).optional(),
+    image: stylePreviewImageSchema.optional(),
+    // The Shorts layout instead of the video's: 9:16 through the Shorts renderer, with its
+    // big word-by-word captions in the caption font, the title as a headline when it is on,
+    // and the clips' speed. The caption size, position and the Look don't apply to a short.
+    shorts: z
+        .object({
+        titleOnScreen: z.boolean(),
+        speed: z.number().finite().min(1).max(1.25).optional(),
+        // The headline; absent or blank shows the sample's title.
+        title: z.string().max(shortTitlePreviewMax).optional(),
+    })
+        .optional(),
+    // Render again even when this exact preview is already saved.
+    force: z.boolean().optional(),
+});
+export const stylePreviewReplySchema = z.object({
+    hash: z.string().regex(/^[a-f0-9]{64}$/),
+    // GET it for the mp4; its query changes whenever the file is rendered again.
+    url: z.string().min(1),
+    cached: z.boolean(),
+    seconds: z.number().positive(),
+});

package/dist/slices/style-preview/service.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { normalizeStylePreview, previewSeconds, stylePreviewHash } from "./settings.js";
+// Rendered previews are kept in the data folder by the hash of their settings, so a setting
+// changed back, or the same style in another project, plays at once. `force` renders again
+// anyway. Requests for a preview already being rendered wait for that render instead of
+// starting a second one.
+export function stylePreviewDir(dataDir) {
+    return join(dataDir, "cache", "style-preview");
+}
+const hashPattern = /^[a-f0-9]{64}$/;
+export function createStylePreviews(deps) {
+    const inflight = new Map();
+    const pathOf = (hash) => join(deps.dir, `${hash}.mp4`);
+    const file = (hash) => {
+        if (!hashPattern.test(hash))
+            return undefined;
+        try {
+            const stats = statSync(pathOf(hash));
+            return stats.isFile() && stats.size > 0
+                ? { path: pathOf(hash), bytes: stats.size, version: Math.round(stats.mtimeMs) }
+                : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const run = async (hash, settings, picture) => {
+        mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
+        const work = `${hash}.${randomUUID()}`;
+        const part = join(deps.dir, `${work}.part.mp4`);
+        // The picture is copied beside the render for its length only, so nothing but the
+        // finished previews is kept.
+        const still = picture === undefined ? undefined : join(deps.dir, `${work}.still${picture.extension}`);
+        try {
+            if (still !== undefined && picture !== undefined)
+                writeFileSync(still, picture.bytes, { mode: 0o600 });
+            await deps.render(settings, part, AbortSignal.timeout(deps.timeoutMs ?? 120_000), still);
+            renameSync(part, pathOf(hash));
+        }
+        finally {
+            rmSync(part, { force: true });
+            if (still !== undefined)
+                rmSync(still, { force: true });
+        }
+        prune(deps);
+        const saved = file(hash);
+        if (saved === undefined)
+            throw new Error("The style preview render finished without writing its video.");
+        return { hash, cached: false, seconds: previewSeconds(settings), version: saved.version };
+    };
+    return {
+        file,
+        render: (request) => {
+            const picture = request.image === undefined ? undefined : deps.pictures?.(request.image);
+            const settings = normalizeStylePreview(request, picture?.sha256);
+            const hash = stylePreviewHash(settings);
+            const running = inflight.get(hash);
+            if (running !== undefined)
+                return running;
+            const saved = request.force === true ? undefined : file(hash);
+            if (saved !== undefined)
+                return Promise.resolve({
+                    hash,
+                    cached: true,
+                    seconds: previewSeconds(settings),
+                    version: saved.version,
+                });
+            const started = run(hash, settings, picture).finally(() => {
+                inflight.delete(hash);
+            });
+            inflight.set(hash, started);
+            return started;
+        },
+    };
+}
+function prune(deps) {
+    try {
+        const kept = readdirSync(deps.dir)
+            .filter((name) => /^[a-f0-9]{64}\.mp4$/.test(name))
+            .map((name) => ({ name, at: statSync(join(deps.dir, name)).mtimeMs }))
+            .toSorted((left, right) => right.at - left.at);
+        for (const old of kept.slice(deps.keep ?? 200))
+            rmSync(join(deps.dir, old.name), { force: true });
+    }
+    catch (error) {
+        deps.log.write("warn", "style-preview.prune", {
+            detail: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/dist/slices/style-preview/settings.js

@@ -0,0 +1,139 @@
+import { createHash } from "node:crypto";
+import { captionCues } from "../subtitles/captions.js";
+import { legacyVideoEdit, transitionSecondsMax, transitionSecondsMin, videoEditOf, } from "../video/edit-settings.js";
+import { sampleNarrationText, sampleNarrationWords, sampleShortTitle } from "./narration.js";
+import { defaultPreviewText, stylePreviewSeconds } from "./schema.js";
+export function normalizeStylePreview(request, 
+// The sha256 of the picture the server found for request.image, if it found one.
+image) {
+    const edit = videoEditOf(request);
+    const { subtitles } = request;
+    const typed = (request.previewText ?? "").replace(/\s+/g, " ").trim();
+    const text = typed === "" || typed === defaultPreviewText ? sampleNarrationText : typed;
+    const shorts = request.shorts;
+    if (shorts !== undefined) {
+        const title = shorts.title?.replace(/\s+/g, " ").trim() ?? "";
+        const none = videoEditOf({ videoEdit: legacyVideoEdit });
+        return {
+            version: 2,
+            format: "9:16",
+            captions: null,
+            look: {
+                vignette: none.vignette,
+                grain: none.grain,
+                grade: none.grade,
+                atmosphere: none.atmosphere,
+            },
+            transition: null,
+            chapterCard: null,
+            short: {
+                fontId: subtitles.fontId,
+                text,
+                title: shorts.titleOnScreen ? (title === "" ? sampleShortTitle : title) : null,
+                speed: Math.round(Math.min(1.25, Math.max(1, shorts.speed ?? 1)) * 100) / 100,
+            },
+            ...(image === undefined ? {} : { image }),
+        };
+    }
+    return {
+        version: 2,
+        format: request.format,
+        captions: subtitles.mode === "burn-in"
+            ? {
+                fontId: subtitles.fontId,
+                fontSize: Math.round(subtitles.fontSize),
+                position: subtitles.position,
+                text,
+            }
+            : null,
+        look: {
+            vignette: edit.vignette,
+            grain: edit.grain,
+            grade: edit.grade,
+            atmosphere: edit.atmosphere,
+        },
+        transition: edit.transition === "cut"
+            ? null
+            : {
+                kind: edit.transition,
+                // Tenths, within the range the project editor offers.
+                seconds: Math.round(Math.min(transitionSecondsMax, Math.max(transitionSecondsMin, Number.isFinite(edit.transitionSeconds) ? edit.transitionSeconds : 0.6)) * 10) / 10,
+            },
+        chapterCard: edit.chapterCards ? { fontId: subtitles.fontId } : null,
+        ...(image === undefined ? {} : { image }),
+    };
+}
+// JSON with every object's keys in order, so equal settings always hash alike.
+export function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(",")}]`;
+    if (value !== null && typeof value === "object")
+        return `{${Object.entries(value)
+            .filter(([, one]) => one !== undefined)
+            .toSorted(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+            .map(([key, one]) => `${JSON.stringify(key)}:${stableJson(one)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function stylePreviewHash(settings) {
+    return createHash("sha256").update(stableJson(settings)).digest("hex");
+}
+// How long the rendered preview runs: a Shorts preview at a higher speed is shorter.
+export function previewSeconds(settings) {
+    return settings.short === undefined
+        ? stylePreviewSeconds
+        : round(stylePreviewSeconds / settings.short.speed);
+}
+// ceiling: a pause this long between two words of the sample narration starts a new phrase,
+// the same pause `captionCues` starts a new cue at.
+const phraseGap = 0.7;
+// The caption text as timed words. The sample narration's own text is its word timing as it
+// was aligned; any other text is spread over the stretches the narration speaks, each phrase
+// taking a share of the words by its length, the words of each evenly spaced. `captionCues`
+// and the Shorts captions then group and wrap them exactly as they do real narration.
+export function previewWords(text, narration = sampleNarrationWords) {
+    const words = text.split(/\s+/).filter((word) => word !== "");
+    if (words.length === 0)
+        return [];
+    if (words.join(" ") === narration.map((word) => word.text).join(" "))
+        return narration;
+    const phrases = [];
+    for (const word of narration) {
+        const last = phrases.at(-1);
+        if (last !== undefined && word.start - last.end < phraseGap)
+            last.end = word.end;
+        else
+            phrases.push({ start: word.start, end: word.end });
+    }
+    if (phrases.length === 0)
+        phrases.push({ start: 0.4, end: stylePreviewSeconds - 0.4 });
+    const spoken = phrases.reduce((sum, phrase) => sum + (phrase.end - phrase.start), 0);
+    const timed = [];
+    let used = 0;
+    let before = 0;
+    for (const [at, phrase] of phrases.entries()) {
+        before += phrase.end - phrase.start;
+        // The words up to the end of this phrase, by its share of the speech; the last takes
+        // what is left, and none is left empty while words remain.
+        const upTo = at === phrases.length - 1
+            ? words.length
+            : Math.min(words.length - (phrases.length - 1 - at), Math.max(used + 1, Math.round((words.length * before) / spoken)));
+        const chunk = words.slice(used, Math.max(used, upTo));
+        used += chunk.length;
+        const each = (phrase.end - phrase.start) / Math.max(1, chunk.length);
+        chunk.forEach((word, index) => {
+            timed.push({
+                text: word,
+                start: round(phrase.start + index * each),
+                end: round(phrase.start + (index + 1) * each),
+            });
+        });
+    }
+    return timed;
+}
+export function previewCues(text) {
+    return captionCues(previewWords(text));
+}
+function round(value) {
+    return Math.round(value * 1000) / 1000;
+}

package/dist/slices/subtitles/captions.js

@@ -1,5 +1,7 @@
+import { assInlineColour } from "../voices/palette.js";
 import { subtitlePlacement } from "./layout.js";
-// Keep spoken spelling and punctuation. Word times come only from acoustic alignment.
+// Keep spoken spelling and punctuation. Word times come only from acoustic alignment. A cue
+// never holds two speakers' words.
 export function captionCues(words) {
     const cues = [];
     let pending = [];
@@ -12,6 +14,7 @@ export function captionCues(words) {
                 start: first.start,
                 end: last.end,
                 text: wrap(pending.map((word) => word.text)),
+                ...(first.speaker === undefined ? {} : { speaker: first.speaker }),
             });
         }
         pending = [];
@@ -21,11 +24,12 @@ export function captionCues(words) {
             !Number.isFinite(word.end) ||
             word.start < previousEnd - 0.001 ||
             word.end <= word.start) {
-            throw new Error("The saved caption timing is damaged. Use Re-run section on Video to time them again, then Retry stage.");
+            throw new Error("The saved caption timing is damaged. Use More → Render the video again in the Video section to time them again, then Try again.");
         }
         const first = pending[0];
         if (first !== undefined &&
             (word.start - previousEnd > 0.7 ||
+                word.speaker !== first.speaker ||
                 word.end - first.start > 5 ||
                 wrap([...pending.map((one) => one.text), word.text]).split("\n").length > 2)) {
             flush();
@@ -52,23 +56,44 @@ function wrap(words) {
         lines.push(line);
     return lines.join("\n");
 }
-export function serializeSrt(cues) {
+export function serializeSrt(cues, speakers) {
     return cues
-        .map((cue, index) => `${index + 1}\n${stamp(cue.start, ",")} --> ${stamp(cue.end, ",")}\n${markup(cue.text)}\n`)
+        .map((cue, index) => `${index + 1}\n${stamp(cue.start, ",")} --> ${stamp(cue.end, ",")}\n${markup(`${nameTag(cue, speakers)}${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")}`;
+// WebVTT names the speaker in its own voice span, which players can show or style.
+export function serializeVtt(cues, speakers) {
+    return `WEBVTT\n\n${cues.map((cue) => `${stamp(cue.start, ".")} --> ${stamp(cue.end, ".")}\n${voiceSpan(cue, speakers)}${markup(cue.text)}\n`).join("\n")}`;
+}
+function styleOf(cue, speakers) {
+    return cue.speaker === undefined ? undefined : speakers?.styles[cue.speaker];
+}
+function nameTag(cue, speakers) {
+    const style = styleOf(cue, speakers);
+    return style !== undefined && speakers?.nameTags === true ? `${style.name}: ` : "";
+}
+function voiceSpan(cue, speakers) {
+    const style = styleOf(cue, speakers);
+    return style === undefined ? "" : `<v ${style.name.replace(/[<>&]/g, "")}>`;
+}
+// The speaker's colour, and their name in bold ahead of the words when name tags are on.
+function speakerAss(cue, speakers) {
+    const style = styleOf(cue, speakers);
+    if (style === undefined)
+        return "";
+    const colour = `{\\1c${assInlineColour(style.colour)}}`;
+    return speakers?.nameTags === true ? `${colour}{\\b1}${assText(style.name)}:{\\b0} ` : colour;
 }
 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`;
+    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},${assColour(style.color, "&H00FFFFFF")},${assColour(style.color, "&H00FFFFFF")},${assColour(style.outlineColor, "&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(""));
+            .map((cue) => `Dialogue: 0,${assStamp(cue.start)},${assStamp(cue.end)},Default,,0,0,0,,${position}${speakerAss(cue, style.speakers)}${assText(cue.text)}\n`)
+            .join("") +
+        (style.overlay ?? []).map((line) => `${line}\n`).join(""));
 }
 function markup(text) {
     return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -89,3 +114,11 @@ 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")}`;
 }
+// ASS colours are &HAABBGGRR, alpha 00 being opaque.
+export function assColour(hex, fallback) {
+    const match = hex === undefined ? null : /^#([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/.exec(hex);
+    if (match === null)
+        return fallback;
+    const [, r, g, b] = match;
+    return `&H00${(b ?? "").toUpperCase()}${(g ?? "").toUpperCase()}${(r ?? "").toUpperCase()}`;
+}

package/dist/slices/subtitles/model.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { languageInfo } from "../../kernel/ports/languages.js";
 export const subtitleModes = ["off", "files", "burn-in"];
 export const subtitlePositions = [
     "top",
@@ -17,6 +18,16 @@ export const subtitleConfigSchema = z.object({
         .default("default"),
     position: z.enum(subtitlePositions).default("bottom"),
     fontSize: z.number().int().min(16).max(120).default(48),
+    // #RRGGBB, from the channel's brand kit. Absent is white text with a dark outline, as
+    // every caption before them.
+    color: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
+    outlineColor: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
 });
 export const defaultSubtitles = {
     mode: "off",
@@ -25,3 +36,14 @@ export const defaultSubtitles = {
     fontSize: 48,
     position: "bottom",
 };
+// The word-timing operation of a project language, which is part of the timing's fingerprint:
+// English keeps the operation it always had, so no English project is re-timed; the other
+// languages each name the model (or the sentence fallback) that times them.
+export const timingOperations = {
+    english: "wav2vec2-en-a19f851-v2-omissions",
+    multilingual: "wav2vec2-xlsr56-2d48b01-v1",
+    sentences: "sentence-timing-v1",
+};
+export function timingOperation(language) {
+    return timingOperations[languageInfo(language).timing];
+}