@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/tutorials/library.js

@@ -0,0 +1,185 @@
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pageTitleOf, tutorialHeadings, tutorialPageIdPattern } from "./anchors.js";
+// dist/tutorials when running the build; the repository's docs/wiki when running from source
+// (tests, `tsx`).
+export function bundledTutorialsDir() {
+    const candidates = ["../../tutorials/", "../../../../../docs/wiki/"].map((path) => fileURLToPath(new URL(path, import.meta.url)));
+    return candidates.find((dir) => existsSync(join(dir, "Home.md"))) ?? candidates[0];
+}
+export class TutorialsMissing extends Error {
+}
+// `[Title](Page-Name)` links of the sidebar, under its `**Group**` lines. The first link
+// before any group is the home page.
+export function parseSidebar(markdown, titleOf = () => undefined) {
+    const groups = [];
+    let home;
+    for (const line of markdown.replace(/\r\n?/g, "\n").split("\n")) {
+        const group = /^\s*\*\*([^*[\]]+)\*\*\s*$/.exec(line);
+        if (group !== null) {
+            groups.push({ title: (group[1] ?? "").trim(), pages: [] });
+            continue;
+        }
+        for (const link of line.matchAll(/\[([^\]]+)\]\(([^)#\s]+)\)/g)) {
+            const id = link[2] ?? "";
+            if (!tutorialPageIdPattern.test(id))
+                continue;
+            const page = { id, title: (link[1] ?? titleOf(id) ?? pageTitleOf(id)).trim() };
+            const last = groups[groups.length - 1];
+            if (last === undefined)
+                home ??= page;
+            else
+                last.pages.push(page);
+        }
+    }
+    return { home, groups: groups.filter((group) => group.pages.length > 0) };
+}
+// Reads every page once; they never change while the app runs.
+export async function loadTutorials(dir) {
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw new TutorialsMissing("This copy of Slopify has no tutorials: its docs/wiki folder is missing. Reinstall Slopify (or run npm run build) and reload the page.");
+        throw error;
+    }
+    const pages = new Map();
+    for (const name of names.sort()) {
+        const id = name.replace(/\.md$/, "");
+        if (!name.endsWith(".md") || !tutorialPageIdPattern.test(id))
+            continue;
+        pages.set(id, await readFile(join(dir, name), "utf8"));
+    }
+    if (!pages.has("Home"))
+        throw new TutorialsMissing("This copy of Slopify has damaged tutorials: docs/wiki/Home.md is missing. Reinstall Slopify (or run npm run build) and reload the page.");
+    const extra = async (name) => readFile(join(dir, name), "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    });
+    const sidebar = parseSidebar(await extra("_Sidebar.md"));
+    const groups = sidebar.groups
+        .map((group) => ({ ...group, pages: group.pages.filter((page) => pages.has(page.id)) }))
+        .filter((group) => group.pages.length > 0);
+    const listed = new Map();
+    const home = sidebar.home ?? { id: "Home", title: "Home" };
+    listed.set(home.id, home);
+    for (const group of groups)
+        for (const page of group.pages)
+            listed.set(page.id, page);
+    for (const id of pages.keys())
+        if (!listed.has(id))
+            listed.set(id, { id, title: pageTitleOf(id) });
+    return {
+        index: {
+            home,
+            groups,
+            pages: [...listed.values()],
+            footer: (await extra("_Footer.md")).trim(),
+        },
+        pages,
+    };
+}
+// Plain words of a Markdown line: links become their text, marks and tables' pipes go.
+function plain(markdown) {
+    return markdown
+        .replace(/^\s*\|?\s*:?-{3,}[-|: ]*$/gm, "")
+        .replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/[`*_>|]/g, " ")
+        .replace(/^\s*(?:[-+]|\d+\.)\s+/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function sectionsOf(markdown) {
+    const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+    const headings = tutorialHeadings(markdown);
+    const sections = [];
+    const first = headings[0]?.line ?? lines.length;
+    sections.push({ anchor: "", heading: undefined, text: plain(lines.slice(0, first).join("\n")) });
+    for (const [at, heading] of headings.entries()) {
+        const end = headings[at + 1]?.line ?? lines.length;
+        sections.push({
+            anchor: heading.anchor,
+            heading: heading.text,
+            text: plain(lines.slice(heading.line + 1, end).join("\n")),
+        });
+    }
+    return sections.filter((section) => section.heading !== undefined || section.text !== "");
+}
+function snippetOf(text, term) {
+    const at = term === "" ? -1 : text.toLowerCase().indexOf(term);
+    if (at < 0)
+        return text.length > 180 ? `${text.slice(0, 177).trimEnd()}…` : text;
+    // Whole words at both ends.
+    const from = Math.max(0, at - 60);
+    const start = from === 0 ? 0 : text.indexOf(" ", from) + 1 || from;
+    const to = Math.min(text.length, at + term.length + 120);
+    const end = to === text.length ? to : text.lastIndexOf(" ", to) > at ? text.lastIndexOf(" ", to) : to;
+    return `${start > 0 ? "…" : ""}${text.slice(start, end).trim()}${end < text.length ? "…" : ""}`;
+}
+// The sections that hold every word typed, best first: a word in the page's title or the
+// section's heading counts more than one in its text. The first heading (the page's own
+// title) stands for the page.
+export function searchTutorials(book, query, limit = 30) {
+    const terms = query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((term) => term.trim())
+        .filter((term) => term.length > 0)
+        .slice(0, 8);
+    if (terms.length === 0)
+        return [];
+    const titles = new Map(book.index.pages.map((page) => [page.id, page.title]));
+    const scored = [];
+    let order = 0;
+    for (const summary of book.index.pages) {
+        const markdown = book.pages.get(summary.id);
+        if (markdown === undefined)
+            continue;
+        const pageTitle = titles.get(summary.id) ?? pageTitleOf(summary.id);
+        for (const section of sectionsOf(markdown)) {
+            order += 1;
+            const heading = (section.heading ?? "").toLowerCase();
+            const text = section.text.toLowerCase();
+            const title = pageTitle.toLowerCase();
+            let score = 0;
+            let all = true;
+            let own = false;
+            for (const term of terms) {
+                const inHeading = heading.includes(term);
+                const inTitle = title.includes(term);
+                const inText = text.includes(term);
+                if (!inHeading && !inText && !inTitle) {
+                    all = false;
+                    break;
+                }
+                own ||= inHeading || inText;
+                score += (inHeading ? 6 : 0) + (inTitle ? 3 : 0) + (inText ? 1 : 0);
+            }
+            // A word only in the page's title would list every section of the page.
+            if (!all || !own)
+                continue;
+            if (heading === query.trim().toLowerCase())
+                score += 10;
+            scored.push({
+                hit: {
+                    page: summary.id,
+                    pageTitle,
+                    anchor: section.anchor,
+                    heading: section.heading,
+                    snippet: snippetOf(section.text, terms.find((term) => text.includes(term)) ?? ""),
+                },
+                score,
+                order,
+            });
+        }
+    }
+    return scored
+        .sort((a, b) => b.score - a.score || a.order - b.order)
+        .slice(0, limit)
+        .map(({ hit }) => hit);
+}

package/dist/slices/uploads/repo.js

@@ -0,0 +1,20 @@
+export function markUploaded(db, projectId, uploaded, at) {
+    if (db.prepare("SELECT 1 FROM projects WHERE id=?").get(projectId) === undefined)
+        return { ok: false, reason: "not-found" };
+    if (!uploaded) {
+        db.prepare("DELETE FROM project_uploads WHERE project_id=?").run(projectId);
+        return { ok: true, uploadedAt: null };
+    }
+    // Marking twice keeps the first time: it is when the video went up.
+    db.prepare("INSERT INTO project_uploads(project_id,uploaded_at) VALUES (?,?) ON CONFLICT(project_id) DO NOTHING").run(projectId, at);
+    const row = db
+        .prepare("SELECT uploaded_at FROM project_uploads WHERE project_id=?")
+        .get(projectId);
+    return { ok: true, uploadedAt: typeof row?.uploaded_at === "string" ? row.uploaded_at : at };
+}
+export function uploadedProjects(db) {
+    return new Map(db
+        .prepare("SELECT project_id, uploaded_at FROM project_uploads")
+        .all()
+        .map((row) => [String(row.project_id), String(row.uploaded_at)]));
+}

package/dist/slices/video/ambient-bed-schema.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { ambientBedSources, builtInBeds } from "./ambient-bed.js";
+// The ambient bed as a run's config and a channel's brand kit hold it. The ranges are
+// `ambient-bed.ts`'s, checked by admission and the channel page, not the schema's.
+const numbers = {
+    levelDb: z.number(),
+    fadeInSeconds: z.number(),
+    tailSeconds: z.number(),
+};
+export const ambientBedSchema = z
+    .object({ source: z.enum(ambientBedSources), ...numbers })
+    .strict();
+export const channelAmbientBedSchema = z
+    .object({ source: z.enum(builtInBeds), ...numbers })
+    .strict();

package/dist/slices/video/ambient-bed.js

@@ -0,0 +1,95 @@
+// An ambient sound bed under the long video: rain, fire or wind that ffmpeg makes itself from
+// noise (no downloads, no bundled recordings), or the user's own audio file. It plays under the
+// whole narration, ducked whenever the voice speaks, fades in at the start, and keeps playing
+// for a fade-out tail after the narration ends, which lengthens the video when the tail is
+// longer than the silence already there (`plan.ts`). Only the long video gets it: the shorts
+// have their own background music, and the audio-only WAV export stays the narration alone.
+// Browser-safe: Play, the channel page and the review summary read these names and limits too.
+//
+// A run without one has no `ambientBed` at all, and the render recipe leaves it out of the
+// fingerprint then, so no video made before it existed turns outdated.
+export const builtInBeds = ["rain", "fire", "wind"];
+export const ambientBedSources = [...builtInBeds, "upload"];
+export const ambientBedLabels = {
+    rain: "Rain",
+    fire: "Fireplace",
+    wind: "Wind",
+    upload: "My own file",
+};
+// ceiling: below -40 dB the bed is inaudible under a voice; above -6 dB it competes with it.
+export const ambientLevelMin = -40;
+export const ambientLevelMax = -6;
+export const ambientFadeMax = 30;
+export const ambientTailMax = 30;
+export const defaultAmbientBed = {
+    levelDb: -18,
+    fadeInSeconds: 3,
+    tailSeconds: 6,
+};
+// Whether the run's long video gets the bed: it is set, the video renders and there is a
+// narration to lie under. A short-only run (`admission/short-mode.ts`) renders through the
+// Shorts renderer and has no bed.
+export function usesAmbientBed(config) {
+    return (config.ambientBed !== undefined &&
+        config.mode !== "short" &&
+        config.sources.video === "generate" &&
+        config.sources.audio !== "off");
+}
+// The words a problem with one of the settings is said in; shared by admission, Play's draft
+// conversion and the channel page.
+export function ambientBedProblems(bed) {
+    const problems = [];
+    if (!ambientBedSources.includes(bed.source))
+        problems.push({
+            field: "source",
+            message: "Choose Rain, Fireplace, Wind or My own file for the ambient sound.",
+        });
+    if (!(Number.isInteger(bed.levelDb) &&
+        bed.levelDb >= ambientLevelMin &&
+        bed.levelDb <= ambientLevelMax))
+        problems.push({
+            field: "level",
+            message: `Enter an ambient sound level between ${String(ambientLevelMin)} and ${String(ambientLevelMax)} dB, in whole dB.`,
+        });
+    if (!halfSteps(bed.fadeInSeconds, ambientFadeMax))
+        problems.push({
+            field: "fadeIn",
+            message: `Enter a fade-in between 0 and ${String(ambientFadeMax)} seconds, in steps of 0.5.`,
+        });
+    if (!halfSteps(bed.tailSeconds, ambientTailMax))
+        problems.push({
+            field: "tail",
+            message: `Enter a tail between 0 and ${String(ambientTailMax)} seconds, in steps of 0.5.`,
+        });
+    return problems;
+}
+function halfSteps(value, max) {
+    return Number.isInteger(value * 2) && value >= 0 && value <= max;
+}
+// How much longer the video runs with the bed: the tail plays over the silence already after
+// the narration (`edgeSilenceSeconds`) and only the rest is added.
+export function ambientTailExtension(config, edgeSilenceSeconds) {
+    if (!usesAmbientBed(config) || config.ambientBed === undefined)
+        return 0;
+    return Math.max(0, config.ambientBed.tailSeconds - edgeSilenceSeconds);
+}
+export function ambientBedFormOf(bed) {
+    return {
+        source: bed.source,
+        level: String(bed.levelDb),
+        fadeIn: String(bed.fadeInSeconds),
+        tail: String(bed.tailSeconds),
+    };
+}
+// The settings a form asks for, numbers as typed (NaN for a blank one), or undefined for none.
+export function ambientBedOfForm(form) {
+    if (form === undefined || form.source === "none")
+        return undefined;
+    const number = (raw) => (raw.trim() === "" ? Number.NaN : Number(raw));
+    return {
+        source: form.source,
+        levelDb: number(form.level),
+        fadeInSeconds: number(form.fadeIn),
+        tailSeconds: number(form.tail),
+    };
+}

package/dist/slices/video/ambient-mix.js

@@ -0,0 +1,72 @@
+// How the join mixes the ambient bed under the narration (`ffmpeg.ts`). Every value goes into
+// an argument array, never a shell string.
+//
+// The built-in beds are shaped noise, made by ffmpeg's own anoisesrc with a fixed seed, so the
+// same settings always render the same sound and nothing is downloaded or shipped:
+// - rain: pink noise with the rumble and the fizz filtered off, a steady patter;
+// - wind: brown noise kept low, swelling and dropping in slow gusts;
+// - fire: a low brown-noise roar that flickers, with sparse velvet-noise crackle over it.
+// Each is levelled to about -20 dBFS RMS before the bed's own level, so 0 dB is roughly as loud
+// as a narration and the three sit alike at the same setting.
+//
+// The ducking is a sidechain compressor keyed by the narration itself, the Shorts' music does
+// the same (`shorts/render.ts`): it follows the voice as it is, needs no word timing (which a
+// run without captions, chapters or shorts never makes), and dips under an intro or outro too.
+// ceiling: it dips once the voice passes about -34 dBFS, by up to 8:1, over 40 ms, and comes
+// back over 900 ms after the voice stops: slower than the shorts' music, so a bed under a long
+// narration settles rather than swelling in every pause between sentences.
+const duck = "threshold=0.02:ratio=8:attack=40:release=900:makeup=1";
+const presets = {
+    rain: [{ source: "anoisesrc=c=pink:a=1:seed=17", filters: "highpass=f=600,lowpass=f=9000" }],
+    wind: [
+        {
+            source: "anoisesrc=c=brown:a=1:seed=29",
+            filters: "highpass=f=60,lowpass=f=500,tremolo=f=0.15:d=0.6,volume=-1dB",
+        },
+    ],
+    fire: [
+        {
+            source: "anoisesrc=c=brown:a=1:seed=41",
+            filters: "highpass=f=80,lowpass=f=800,tremolo=f=6:d=0.25,volume=-3dB",
+        },
+        {
+            source: "anoisesrc=c=velvet:a=1:seed=43",
+            filters: "highpass=f=1500,lowpass=f=6000,volume=-22dB",
+        },
+    ],
+};
+// The inputs the bed adds after the join's own, for `seconds` of video.
+export function bedInputs(bed, seconds, sampleRate) {
+    if (bed.source.kind === "file")
+        // Looped endlessly and cut to the video, so a file shorter than the video plays again.
+        return ["-stream_loop", "-1", "-i", bed.source.path];
+    return presets[bed.source.preset].flatMap((layer) => [
+        "-f",
+        "lavfi",
+        "-t",
+        seconds.toFixed(6),
+        "-i",
+        `${layer.source}:r=${String(sampleRate)}`,
+    ]);
+}
+// The chains that turn the join's narration `voice` into `out` with the bed under it; `first`
+// is the index of the bed's first input.
+export function bedChains(bed, first, seconds, format, voice, out) {
+    const chains = [];
+    const layers = bed.source.kind === "file" ? [{ filters: "" }] : presets[bed.source.preset];
+    layers.forEach((layer, at) => {
+        chains.push(`[${String(first + at)}:a]${layer.filters === "" ? "" : `${layer.filters},`}${format},atrim=end=${seconds.toFixed(6)},asetpts=PTS-STARTPTS[bed${String(at)}]`);
+    });
+    const joined = layers.length === 1
+        ? "[bed0]anull"
+        : `${layers.map((_layer, at) => `[bed${String(at)}]`).join("")}amix=inputs=${String(layers.length)}:duration=first:normalize=0`;
+    const fadeIn = bed.fadeInSeconds > 0 ? `,afade=t=in:st=0:d=${bed.fadeInSeconds.toFixed(3)}` : "";
+    // A tail of 0 still fades, over a moment, rather than cutting off mid-sound.
+    const fadeOut = `,afade=t=out:st=${bed.fadeOutAt.toFixed(6)}:d=${Math.max(0.25, bed.fadeOutSeconds).toFixed(3)}`;
+    chains.push(`${joined},volume=${String(bed.levelDb)}dB${fadeIn}${fadeOut}[bed]`);
+    chains.push(`${voice}asplit=2[voice][key]`);
+    chains.push(`[bed][key]sidechaincompress=${duck}[ducked]`);
+    // The narration keeps its level; `normalize=0` stops amix halving both.
+    chains.push(`[voice][ducked]amix=inputs=2:duration=first:dropout_transition=0:normalize=0${out}`);
+    return chains;
+}

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

@@ -5,9 +5,9 @@ export async function audioInputs(deps, projectId, outputs, signal) {
     const dir = projectDir(deps.paths, projectId);
     const body = await audio(deps, outputs, "audio_body", dir, signal);
     if (!body)
-        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Retry stage.");
+        throw new Error("The video has no narration audio to play. Let the Narration stage finish, then Try again.");
     if (body.seconds <= 0)
-        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Retry stage.");
+        throw new Error("The narration audio contains no sound; the file may be damaged or empty. Regenerate the narration (or upload a different audio file in Edit project → Narration), then Try again.");
     const intro = await audio(deps, outputs, "audio_intro", dir, signal);
     const outro = await audio(deps, outputs, "audio_outro", dir, signal);
     return { body, intro, outro };

package/dist/slices/video/cards.js

@@ -1,3 +1,4 @@
+import { assColour } from "../subtitles/captions.js";
 // Chapter cards as an ASS script the clips draw with libass, the renderer the captions use,
 // so a card is set in the subtitle font without a font-rendering filter of its own (this
 // ffmpeg has none). Each card is centred, well above where captions sit by default, and fades
@@ -5,7 +6,9 @@
 // clip's first frame (`offset`), since a clip's frames count from zero.
 // ceiling: the owner's eye. The fades take 0.4 s each of the card's 2.5 s.
 const fadeMs = 400;
-export function cardsAss(edit, cards, fontName, offset = 0) {
+export function cardsAss(edit, cards, fontName, offset = 0, 
+// #RRGGBB from the brand kit; absent is white.
+color) {
     const { width, height, fps } = edit;
     // The title is sized from the frame's short side, so a vertical video's card fits too. At
     // 8% it read as a caption rather than a chapter title; 11% and bold gives it presence.
@@ -24,7 +27,7 @@ export function cardsAss(edit, cards, fontName, offset = 0) {
         "[V4+ Styles]",
         "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
         // White bold text, the soft outline, no offset shadow, centred (alignment 5), letter-spaced.
-        `Style: Card,${fontName.replace(/,/g, " ")},${String(size)},&H00FFFFFF,&H00FFFFFF,&H60000000,&H00000000,-1,0,0,0,100,100,${String(Math.round(size / 12))},0,1,${String(outline)},0,5,${String(Math.round(width * 0.1))},${String(Math.round(width * 0.1))},0,1`,
+        `Style: Card,${fontName.replace(/,/g, " ")},${String(size)},${assColour(color, "&H00FFFFFF")},${assColour(color, "&H00FFFFFF")},&H60000000,&H00000000,-1,0,0,0,100,100,${String(Math.round(size / 12))},0,1,${String(outline)},0,5,${String(Math.round(width * 0.1))},${String(Math.round(width * 0.1))},0,1`,
         "",
         "[Events]",
         "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",

package/dist/slices/video/edit-list.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { builtInBeds } from "./ambient-bed.js";
 import { atmospheres, colorGrades, lookLevels, } from "./edit-settings.js";
 // The edit list is the whole video as data: what plays, for how many frames, how it moves,
 // and the audio under it. Planning (`plan.ts`) writes one and the renderer (`ffmpeg.ts`,
@@ -28,6 +29,9 @@ export function withPaths(edit, map) {
         ...(edit.cardFont === undefined
             ? {}
             : { cardFont: { ...edit.cardFont, path: map(edit.cardFont.path) } }),
+        ...(edit.bed?.source.kind === "file"
+            ? { bed: { ...edit.bed, source: { kind: "file", path: map(edit.bed.source.path) } } }
+            : {}),
     };
 }
 const share = z.number().min(0).max(1);
@@ -88,6 +92,23 @@ const editListSchema = z
         .object({ path: z.string().min(1), name: z.string().min(1) })
         .strict()
         .optional(),
+    cardColor: z
+        .string()
+        .regex(/^#[0-9A-Fa-f]{6}$/)
+        .optional(),
+    bed: z
+        .object({
+        source: z.discriminatedUnion("kind", [
+            z.object({ kind: z.literal("noise"), preset: z.enum(builtInBeds) }).strict(),
+            z.object({ kind: z.literal("file"), path: z.string().min(1) }).strict(),
+        ]),
+        levelDb: z.number(),
+        fadeInSeconds: z.number().nonnegative(),
+        fadeOutAt: z.number().nonnegative(),
+        fadeOutSeconds: z.number().nonnegative(),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 // Reads a recorded edit list back. Strict, so a list written by a newer Slopify, with a
@@ -95,9 +116,9 @@ const editListSchema = z
 export function readEditList(value) {
     const version = typeof value === "object" && value !== null && "version" in value ? value.version : undefined;
     if (version !== editListVersion)
-        throw new Error(`This video's edit list is version ${String(version)}, and this Slopify reads version ${editListVersion}. Update Slopify, or use Re-run section on Video to plan it again.`);
+        throw new Error(`This video's edit list is version ${String(version)}, and this Slopify reads version ${editListVersion}. Update Slopify, or use More → Render the video again in the Video section to plan it again.`);
     const parsed = editListSchema.safeParse(value);
     if (!parsed.success)
-        throw new Error(`This video's edit list is damaged (${parsed.error.issues[0]?.path.join(".") || "the list"}: ${parsed.error.issues[0]?.message ?? "not readable"}). Use Re-run section on Video to plan it again.`);
+        throw new Error(`This video's edit list is damaged (${parsed.error.issues[0]?.path.join(".") || "the list"}: ${parsed.error.issues[0]?.message ?? "not readable"}). Use More → Render the video again in the Video section to plan it again.`);
     return parsed.data;
 }

package/dist/slices/video/edit-settings.js

@@ -1,3 +1,4 @@
+import { wordTimingUnavailable } from "../../kernel/ports/languages.js";
 // How the Video stage edits the slideshow beyond seconds per image, zoom and motion: where the
 // cuts fall, how one shot hands over to the next, the Look (vignette, grain, colour, an
 // atmosphere overlay and chapter cards), and which images come to life as short clips.
@@ -49,6 +50,8 @@ export const animatePrompt = "Subtle cinematic motion: a slow, steady camera pus
 export const cutFloorShare = 0.4;
 // How long a chapter card stays on screen, fades included.
 export const chapterCardSeconds = 2.5;
+// How long the brand kit's end screen card stays on screen at the end of the video.
+export const endScreenSeconds = 5;
 export const cutModeLabels = {
     interval: "Every N seconds",
     narration: "Follow the narration",
@@ -87,12 +90,14 @@ export const animateModeLabels = {
 export function videoEditOf(config) {
     return config.videoEdit ?? legacyVideoEdit;
 }
-// Following the narration needs narration to follow and a video to cut; otherwise the video
-// falls back to Every N seconds, which is also what its fingerprint says.
+// Following the narration needs narration to follow, a video to cut and word timing in the
+// project language (`wordTimingUnavailable`); otherwise the video falls back to Every N
+// seconds, which is also what its fingerprint says.
 export function usesNarrationCuts(config) {
     return (videoEditOf(config).cuts === "narration" &&
         config.sources.audio !== "off" &&
-        config.sources.video === "generate");
+        config.sources.video === "generate" &&
+        wordTimingUnavailable(config.language) === undefined);
 }
 // Chapter cards are placed from the narration's word timing, so they need narration too.
 export function usesChapterCards(config) {
@@ -111,6 +116,11 @@ export function usesAnimation(config) {
 // know which images open a chapter.
 export function editNeedsTiming(config) {
     return (usesNarrationCuts(config) ||
+        // "Show tables and figures on screen" places each card where its description is spoken.
+        (config.showFigures === true &&
+            config.audio?.describeFigures === true &&
+            config.sources.audio === "generate" &&
+            config.sources.video === "generate") ||
         usesChapterCards(config) ||
         (usesAnimation(config) && videoEditOf(config).animate === "chapters"));
 }

package/dist/slices/video/ffmpeg.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { isAbsolute, resolve as resolvePath } from "node:path";
+import { bedChains, bedInputs } from "./ambient-mix.js";
 import { gradeFilter, lookChain, lookEncoding, placed } from "./look.js";
 import { decimal, zoomRange } from "./plan.js";
 import { segments, transitionHalves } from "./transitions.js";
@@ -43,7 +44,7 @@ export function slideshowClips(edit) {
             named.set(key, name);
             const shot = edit.shots[segment.kind === "shot" ? segment.shot : segment.to];
             if (shot === undefined)
-                throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
             clips.push({ name, segment, shot, frames: segment.count });
         }
         return name;
@@ -92,7 +93,7 @@ cardsFile = "cards.ass") {
     const chains = [];
     const picture = (shot, from, label) => {
         if (shot === undefined)
-            throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use Re-run section on Video; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error("Slopify hit an internal error (the video's edit list lost a shot). Use More → Render the video again in the Video section; if it happens again, use Download diagnostics in Settings and report it.");
         const at = inputs.filter((one) => one === "-i").length;
         const built = pictureChain(edit, shot, from, segment.count, at, label, gradeFilter(edit.look));
         inputs.push(...built.inputs);
@@ -207,11 +208,13 @@ function seconds6(value) {
 export function concatList(order) {
     return `ffconcat version 1.0\n${order.map((name) => `file ${name}`).join("\n")}\n`;
 }
-export function joinArgs(edit, output, list, burnSubtitles = false) {
-    const inputs = ["-f", "concat", "-i", list];
+// The video's sound: the narration's segments and silences joined, with the ambient bed under
+// them when there is one, as the inputs from `first` on and the chains ending in `[a]`.
+function audioMix(edit, first) {
+    const inputs = [];
     const audioAt = [];
     for (const segment of edit.audio) {
-        audioAt.push(1 + audioAt.length);
+        audioAt.push(first + audioAt.length);
         if (segment.path === null) {
             inputs.push("-f", "lavfi", "-t", seconds(segment.seconds), "-i", `anullsrc=r=${sampleRate}:cl=${channelLayout}`);
             continue;
@@ -219,15 +222,65 @@ export function joinArgs(edit, output, list, burnSubtitles = false) {
         inputs.push("-i", segment.path);
     }
     const chains = [];
-    if (burnSubtitles)
-        chains.push("[0:v]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.
         chains.push(`[${input}:a]aformat=sample_fmts=fltp:sample_rates=${sampleRate}:channel_layouts=${channelLayout}[a${at}]`);
     });
+    // The ambient bed lies under the joined narration, ducked by it (`ambient-mix.ts`); without
+    // one the arguments are the ones every video was joined with.
+    const bed = audioAt.length > 0 ? edit.bed : undefined;
     if (audioAt.length > 0) {
-        chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1[a]`);
+        chains.push(`${audioAt.map((_input, at) => `[a${at}]`).join("")}concat=n=${audioAt.length}:v=0:a=1${bed === undefined ? "[a]" : "[narration]"}`);
+    }
+    if (bed !== undefined) {
+        const total = edit.audio.reduce((sum, segment) => sum + segment.seconds, 0);
+        inputs.push(...bedInputs(bed, total, sampleRate));
+        chains.push(...bedChains(bed, first + audioAt.length, total, `aformat=sample_fmts=fltp:sample_rates=${sampleRate}:channel_layouts=${channelLayout}`, "[narration]", "[a]"));
+    }
+    return { inputs, chains };
+}
+// The video's sound alone, as a WAV: what Level the volume masters before the join plays it
+// (`slideshow.ts`).
+export function audioMixArgs(edit, output) {
+    const mix = audioMix(edit, 0);
+    return [
+        ...progressArgs,
+        ...mix.inputs,
+        "-filter_complex",
+        mix.chains.join(";"),
+        "-map",
+        "[a]",
+        "-c:a",
+        "pcm_s16le",
+        "-f",
+        "wav",
+        output,
+    ];
+}
+export function joinArgs(edit, output, list, burnSubtitles = false, portraits = []) {
+    const mix = audioMix(edit, 1);
+    const inputs = ["-f", "concat", "-i", list, ...mix.inputs];
+    const chains = [];
+    const overlaid = burnSubtitles && portraits.length > 0;
+    if (burnSubtitles && !overlaid)
+        chains.push("[0:v]ass=filename=subtitles.ass:fontsdir=fonts[v]");
+    chains.push(...mix.chains);
+    // The portraits go in after every other input and under the captions, so the panel's lit
+    // outline is drawn over them; a video without any is joined exactly as before. A still
+    // image is one frame, which overlay holds to the end (`eof_action=repeat`).
+    if (overlaid) {
+        let first = inputs.filter((value) => value === "-i").length;
+        let source = "[0:v]";
+        const video = [];
+        portraits.forEach((portrait, at) => {
+            inputs.push("-i", portrait.path);
+            const size = String(portrait.size);
+            video.push(`[${String(first)}:v]scale=${size}:${size}:force_original_aspect_ratio=increase,crop=${size}:${size},setsar=1[pic${String(at)}]`, `${source}[pic${String(at)}]overlay=x=${String(portrait.x)}:y=${String(portrait.y)}:eof_action=repeat[panel${String(at)}]`);
+            source = `[panel${String(at)}]`;
+            first += 1;
+        });
+        chains.unshift(...video, `${source}ass=filename=subtitles.ass:fontsdir=fonts[v]`);
     }
     return [
         ...progressArgs,
@@ -359,6 +412,7 @@ export function runFfmpeg(run) {
         child.stderr.setEncoding("utf8");
         child.stderr.on("data", (chunk) => {
             guarded("video.stderr.read", () => {
+                run.onStderr?.(chunk);
                 for (const line of chunk.split("\n")) {
                     if (line.trim() !== "") {
                         errors.push(line.trim());
@@ -436,5 +490,5 @@ function failure(code, signal, errors) {
     const said = errors.length === 0
         ? `ffmpeg ${ended} and wrote nothing to its error stream`
         : `ffmpeg ${ended}: ${errors.join(" / ")}`;
-    return `The audio/video export failed (${said}). Retry stage; if it fails again, make sure your disk has free space (see Settings → Backup & storage), then use Download diagnostics in Settings and report it.`;
+    return `The audio/video export failed (${said}). Try again; if it fails again, make sure your disk has free space (see Settings → Backup & storage), then use Download diagnostics in Settings and report it.`;
 }