@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/rebuild/runtime-export-edit.js

@@ -1,13 +1,15 @@
 import { readFileSync } from "node:fs";
 import { extname } from "node:path";
 import { z } from "zod";
-import { usesYoutubeDescription } from "../admission/rules.js";
+import { usesFigureCards, usesYoutubeDescription } from "../admission/rules.js";
+import { captionFont, captionFontDeps } from "../fonts/coverage.js";
 import { resolveFont } from "../fonts/index.js";
 import { outputPath } from "../storage/layout.js";
 import { headingChapters } from "../video/chapters.js";
 import { sentenceCutPoints } from "../video/cuts.js";
 import { usesChapterCards, usesNarrationCuts, videoEditOf, } from "../video/edit-settings.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
+import { passageSpans } from "../video/figure-spans.js";
 import { wordsSchema } from "./runtime-subtitles.js";
 // The containers an uploaded clip may come in; anything else in the images is a still.
 const clipExtensions = new Set([".mp4", ".mov", ".m4v", ".webm", ".mkv"]);
@@ -39,23 +41,31 @@ export async function exportEdit(deps, context, view, images) {
             .safeParse(JSON.parse(row.piece.payload ?? "null"));
         return parsed.success ? [parsed.data.fallback] : [];
     });
-    if (config.videoEdit === undefined)
+    const endScreen = config.endScreen?.text.trim() ?? "";
+    const figures = usesFigureCards(config) ? figureShots(deps, context, view) : [];
+    const withFigures = figures.length === 0 ? {} : { figures };
+    if (config.videoEdit === undefined) {
+        const titles = endScreen === "" ? undefined : await titleFont(deps, config);
         return {
-            edit: clips.some((clip) => clip !== undefined) ? { clips } : undefined,
+            edit: titles !== undefined
+                ? { clips, cards: { chapters: [], ...titles, endScreen }, ...withFigures }
+                : clips.some((clip) => clip !== undefined) || figures.length > 0
+                    ? { clips, ...withFigures }
+                    : undefined,
             warnings,
             settings: undefined,
         };
+    }
     const settings = videoEditOf(config);
     const cuts = usesNarrationCuts(config);
     const cards = usesChapterCards(config);
     const words = cuts || cards ? timingWords(deps, context, view) : [];
     const chapters = cuts || cards ? chaptersOf(view, config, words) : [];
-    const font = cards
-        ? await resolveFont(deps.paths, config.subtitles?.fontId ?? "default")
-        : undefined;
+    const titles = cards || endScreen !== "" ? await titleFont(deps, config) : undefined;
     return {
         edit: {
             clips,
+            ...withFigures,
             ...(cuts
                 ? {
                     narration: {
@@ -73,22 +83,40 @@ export async function exportEdit(deps, context, view, images) {
                 grade: settings.grade,
                 atmosphere: settings.atmosphere,
             },
-            ...(font === undefined
+            ...(titles === undefined
                 ? {}
-                : { cards: { chapters, font: { path: font.path, name: font.assName } } }),
+                : {
+                    cards: {
+                        chapters: cards ? chapters : [],
+                        ...titles,
+                        ...(endScreen === "" ? {} : { endScreen }),
+                    },
+                }),
         },
         warnings,
         settings,
     };
 }
-function timingWords(deps, context, view) {
+// The cards' font and colour: the brand kit's title style, else the caption font in white.
+async function titleFont(deps, config) {
+    const fontId = config.titleStyle?.fontId ?? config.subtitles?.fontId ?? "default";
+    // Chapter titles are in the project language too, so they need its letters.
+    const font = config.language === undefined || config.language === "en"
+        ? await resolveFont(deps.paths, fontId)
+        : await captionFont(captionFontDeps(deps.paths), fontId, config.language);
+    return {
+        font: { path: font.path, name: font.assName },
+        ...(config.titleStyle?.color === undefined ? {} : { color: config.titleStyle.color }),
+    };
+}
+export function timingWords(deps, context, view) {
     const timing = view.outputs.find((row) => row.selected &&
         row.available &&
         row.state === "ready" &&
         row.workKey === "subtitles:timing" &&
         row.output.role === "subtitle_words");
     if (timing === undefined)
-        throw new Error("The narration's word timing, which the video's cuts and chapter cards follow, is missing. Use Re-run section on Video, then Retry stage.");
+        throw new Error("The narration's word timing, which the video's cuts and chapter cards follow, is missing. Use More → Render the video again in the Video section, then Try again.");
     return wordsSchema.parse(JSON.parse(readFileSync(outputPath(deps.paths, context.work.projectId, timing.output.path), "utf8"))).words;
 }
 // The YouTube description's chapters when that step runs, the article's headings otherwise.
@@ -114,6 +142,37 @@ async function clipSeconds(deps, context, path, place) {
         ms = 0;
     }
     if (!(ms > 0))
-        throw new Error(`Image ${String(place)} is a video clip Slopify can't read, so the video can't show it. Replace it with another clip or an image in Edit project → Images, then Retry stage.`);
+        throw new Error(`Image ${String(place)} is a video clip Slopify can't read, so the video can't show it. Replace it with another clip or an image in Edit project → Images, then Try again.`);
     return ms / 1000;
 }
+// Each card in the video's frame, shown where its description is spoken: the description's
+// answer found in the word timing (`video/figure-spans.ts`). A card whose description can't be
+// found in the timing is left out rather than shown at the wrong moment.
+export function figureShots(deps, context, view, format = view.revision.config.format, words = timingWords(deps, context, view)) {
+    const cards = view.outputs
+        .filter((row) => row.selected &&
+        row.available &&
+        row.state === "ready" &&
+        row.output.role === "figure_card" &&
+        row.workKey.startsWith("figure:card:") &&
+        (row.output.meta.format ?? view.revision.config.format) === format)
+        .map((row) => ({
+        index: Number(row.workKey.slice("figure:card:".length)),
+        path: outputPath(deps.paths, context.work.projectId, row.output.path),
+    }))
+        .toSorted((a, b) => a.index - b.index);
+    const passages = cards.map((card) => {
+        const row = view.pieces.find((one) => one.key === `narration:describe:${String(card.index)}` &&
+            one.selected &&
+            one.piece.state === "done");
+        const parsed = z
+            .object({ text: z.string() })
+            .safeParse(JSON.parse(row?.piece.payload ?? "null"));
+        return parsed.success ? parsed.data.text : "";
+    });
+    const spans = passageSpans(words, passages);
+    return cards.flatMap((card, at) => {
+        const span = spans[at];
+        return span === undefined ? [] : [{ path: card.path, start: span.start, end: span.end }];
+    });
+}

package/dist/slices/rebuild/runtime-export-inputs.js

@@ -1,11 +1,14 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
-import { usesNarrationPreparation, usesPronunciationGlossary } from "../admission/rules.js";
+import { narrationAliasesOf, usesNarrationPreparation, usesPronunciationGlossary, } from "../admission/rules.js";
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
+import { usesLoudness } from "../loudness/model.js";
 import { outputPath } from "../storage/layout.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
 import { audioTimeline } from "../video/plan.js";
+import { usesVoices } from "../voices/model.js";
+import { levelKey } from "./recipe-loudness.js";
 import { joinedNarration, narrationTextParts } from "./runtime-narration-text.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 export function exportSnapshot(deps, context, piece) {
@@ -14,19 +17,33 @@ export function exportSnapshot(deps, context, piece) {
         .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
         .get(context.work.workId);
     if (view === undefined || row === undefined)
-        throw new Error("Slopify hit an internal error (the project version being exported is missing). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the project version being exported is missing). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     const plan = executionPlan(deps, view, savedCatalogue(row.recipe_context));
     const recipe = plan.recipes.find((one) => one.key === piece.key && one.fingerprint === piece.fingerprint);
     if (recipe === undefined || recipe.deferred || recipe.unresolved)
-        throw new Error("Slopify hit an internal error (the export no longer matches the project's saved inputs). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (the export no longer matches the project's saved inputs). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     return { view, plan };
 }
-export async function revisionAudio(deps, context, view) {
+export async function revisionAudio(deps, context, view, 
+// Level the volume: what plays the sound (the video, a short, the audio files) asks for the
+// levelled joins (`recipe-loudness.ts`); what only times it (the word timing, the description,
+// the shorts' pick) reads the plain ones, which it waits for. An uploaded narration has no
+// levelled join: only the master reaches it.
+options = {}) {
     const config = view.revision.config;
     if (config.sources.audio === "off")
         return [];
+    const levelled = options.levelled === true && usesLoudness(config) && config.sources.audio === "generate";
     const input = async (role) => {
-        const row = view.outputs.find((one) => one.selected && one.available && one.state === "ready" && one.output.role === role);
+        const segment = role === "audio_body" ? "body" : role === "audio_intro" ? "intro" : "outro";
+        const row = view.outputs.find((one) => one.selected &&
+            one.available &&
+            one.state === "ready" &&
+            (levelled
+                ? one.output.role === "audio_levelled" && one.workKey === levelKey(segment)
+                : one.output.role === role));
+        if (row === undefined && levelled)
+            throw new Error(`The levelled ${segment === "body" ? "narration" : segment} isn't finished yet, so the sound can't be exported at an even volume. Let the Narration stage finish (Resume, or Try again on it), then retry this stage; or turn off Level the volume in Edit project → Pauses and volume.`);
         if (row === undefined)
             return undefined;
         const path = outputPath(deps.paths, context.work.projectId, row.output.path);
@@ -34,12 +51,12 @@ export async function revisionAudio(deps, context, view) {
             (await (deps.measureAudio?.(path, context.signal) ??
                 probeDurationMs(deps.ffmpeg, path, context.signal, deps.log)));
         if (!Number.isFinite(duration) || duration <= 0)
-            throw new Error("Slopify couldn't read the length of the narration audio, so the file may be damaged or empty. Regenerate the narration (or upload your audio file again in Edit project → Narration), then Retry stage.");
+            throw new Error("Slopify couldn't read the length of the narration audio, so the file may be damaged or empty. Regenerate the narration (or upload your audio file again in Edit project → Narration), then Try again.");
         return { path, seconds: duration / 1000 };
     };
     const body = await input("audio_body");
     if (body === undefined)
-        throw new Error("The narration audio isn't finished yet. Let the Narration stage finish (Resume, or Retry stage on it), then retry this stage.");
+        throw new Error("The narration audio isn't finished yet. Let the Narration stage finish (Resume, or Try again on it), then retry this stage.");
     return audioTimeline({
         body,
         intro: config.sources.audio === "generate" && config.intro !== undefined
@@ -55,7 +72,10 @@ export async function revisionAudio(deps, context, view) {
 export function revisionTranscript(deps, snapshot, kind) {
     const { view, plan } = snapshot;
     if (usesNarrationPreparation(view.revision.config) ||
-        usesPronunciationGlossary(view.revision.config))
+        usesPronunciationGlossary(view.revision.config) ||
+        (kind === "body" && usesVoices(view.revision.config)) ||
+        // Aliased requests say something other than the text; the transcript is the text.
+        narrationAliasesOf(view.revision.config).length > 0)
         return joinedNarration(narrationTextParts(view, plan, kind));
     const concat = plan.recipes.find((one) => one.key === (kind === "body" ? "audio:body:concat" : `audio:${kind}`));
     if (concat !== undefined) {
@@ -73,7 +93,7 @@ export function revisionTranscript(deps, snapshot, kind) {
                 Array.isArray(recipe.input.semantic) &&
                 typeof recipe.input.semantic[0] === "string")
                 return recipe.input.semantic[0];
-            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Retry stage on it), or regenerate the missing chunk in Edit project → Narration.");
+            throw new Error("Some narration chunks aren't finished, so the full narration text isn't available. Let the Narration stage finish (Resume, or Try again on it), or regenerate the missing chunk in Edit project → Narration.");
         });
         if (texts.length > 0)
             return texts.join("\n");
@@ -85,7 +105,7 @@ export function revisionTranscript(deps, snapshot, kind) {
         if (view.articleMarkdown !== null)
             return plainText(splitEndMatter(view.articleMarkdown).body);
     }
-    throw new Error(`The saved text of the ${kind === "body" ? "article" : kind} is missing, so it can't be matched to the narration. Use Re-run section on Article, then Retry stage.`);
+    throw new Error(`The saved text of the ${kind === "body" ? "article" : kind} is missing, so it can't be matched to the narration. Use More → Write the article again in the Article section, then Try again.`);
 }
 export function retainedOutput(deps, view, row) {
     const asset = z
@@ -113,3 +133,25 @@ export function retainedOutput(deps, view, row) {
         output: { ...row.output, id: deps.ids.next(), createdAt: deps.clock.now().toISOString() },
     };
 }
+// The body's speaker turns in narration order, as the plan asked for them: a native
+// multi-speaker request lists its own lines, every other part says whose turn it speaks.
+export function revisionTurns(snapshot) {
+    const { view, plan } = snapshot;
+    if (!usesVoices(view.revision.config))
+        return [];
+    const concat = plan.recipes.find((one) => one.key === "audio:body:concat");
+    return (concat?.dependsOn ?? []).flatMap((key) => {
+        const input = plan.recipes.find((one) => one.key === key)?.input;
+        if (input?.kind !== "tts")
+            return [];
+        if (input.dialogue !== undefined)
+            return input.dialogue.map((line) => ({
+                speaker: line.speaker,
+                turn: line.turn,
+                text: line.text,
+            }));
+        return input.speaker === undefined || input.turn === undefined
+            ? []
+            : [{ speaker: input.speaker, turn: input.turn, text: input.spokenText ?? input.text }];
+    });
+}

package/dist/slices/rebuild/runtime-export-short.js

@@ -0,0 +1,85 @@
+import { relative, sep } from "node:path";
+import { resolveBoldFont } from "../fonts/index.js";
+import { masterGoal } from "../loudness/model.js";
+import { renderShort, shortFrame } from "../shorts/render.js";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { projectDir } from "../storage/layout.js";
+import { probeDurationMs } from "../video/ffmpeg.js";
+import { slideshowImages } from "./runtime-export.js";
+import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
+import { timingWords } from "./runtime-shorts.js";
+// A short-mode project's video (`admission/short-mode.ts`): the whole narration timeline as
+// one clip through the Shorts renderer, so it looks like every short Slopify cuts from a long
+// video - the images moving as the project says, the title on top and big word-by-word
+// captions from the word timing.
+export async function executeShortExport(deps, context, piece, snapshot, timeline) {
+    const { view } = snapshot;
+    const config = view.revision.config;
+    const images = slideshowImages(deps, context, view);
+    const words = timingWords(deps, context, view);
+    const seconds = timeline.reduce((sum, segment) => sum + segment.seconds, 0);
+    if (seconds <= 0)
+        throw new Error("The short has no narration to play, so there is nothing to render. Let the Narration stage finish (Resume, or Try again on it), then retry this stage.");
+    const font = await resolveBoldFont(deps.paths, config.subtitles?.fontId ?? "default");
+    if (!context.maySubmit(piece.id))
+        return "held";
+    const pending = allocateAsset(deps, context.work.projectId, "video.mp4");
+    const prepared = [];
+    const directory = projectDir(deps.paths, context.work.projectId);
+    const relativePath = (path) => relative(directory, path).split(sep).join("/");
+    try {
+        const master = await renderShort({
+            bin: deps.ffmpeg,
+            master: masterGoal(config, "video"),
+            timeline,
+            start: 0,
+            end: seconds,
+            images,
+            imageSeconds: config.imageSeconds,
+            motionStyle: config.motionStyle,
+            zoomPercent: config.zoomPercent,
+            words,
+            font,
+            title: config.title,
+            output: pending.absolutePath,
+            scratch: directory,
+            signal: context.signal,
+            log: deps.log,
+            onProgress: (elapsedMs) => context.emit({
+                type: "stage.progress",
+                projectId: context.work.projectId,
+                stage: "video",
+                current: Math.min(100, Math.round(elapsedMs / (seconds * 10))),
+                total: 100,
+            }),
+        });
+        context.signal.throwIfAborted();
+        const durationMs = await probeDurationMs(deps.ffmpeg, pending.absolutePath, context.signal, deps.log);
+        const asset = sealAsset(deps, pending);
+        prepared.push(preparedResult(deps, context, piece, "video", asset, durationMs, {
+            subtitlesMode: "off",
+            ...(master === undefined ? {} : { master }),
+        }));
+        prepared.push(preparedText(deps, context, piece, "render_params", "render.json", JSON.stringify({
+            mode: "short",
+            ...shortFrame,
+            totalSeconds: seconds,
+            imageSeconds: config.imageSeconds,
+            motionStyle: config.motionStyle,
+            zoomPercent: config.zoomPercent,
+            images: images.map(relativePath),
+            audio: timeline.map((segment) => ({
+                ...segment,
+                path: segment.path === null ? null : relativePath(segment.path),
+            })),
+            fontId: config.subtitles?.fontId ?? "default",
+            output: pending.path,
+        })));
+        await publishResult(deps, context, piece, prepared, { totalSeconds: seconds }, asset);
+        deps.count?.("stage.completed", { stage: "video" });
+        return "done";
+    }
+    finally {
+        discardPreparedAssets(deps, [pending, ...prepared.map((one) => one.asset)]);
+    }
+}

package/dist/slices/rebuild/runtime-export.js

@@ -1,5 +1,8 @@
 import { copyFileSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { extname, join, relative, sep } from "node:path";
+import { usesShortMode } from "../admission/short-mode.js";
+import { masterFile, masterReport } from "../loudness/loudnorm.js";
+import { masterGoal } from "../loudness/model.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath, projectDir } from "../storage/layout.js";
 import { audioExportArgs } from "../video/audio-export.js";
@@ -7,8 +10,11 @@ import { withPaths } from "../video/edit-list.js";
 import { runFfmpeg } from "../video/ffmpeg.js";
 import { planRender } from "../video/plan.js";
 import { renderSlideshow } from "../video/slideshow.js";
+import { writePortraits } from "../voices/portraits.js";
+import { exportBed } from "./runtime-export-bed.js";
 import { exportEdit } from "./runtime-export-edit.js";
 import { exportSnapshot, retainedOutput, revisionAudio, } from "./runtime-export-inputs.js";
+import { executeShortExport } from "./runtime-export-short.js";
 import { preparedResult, preparedText, publishResult } from "./runtime-publication.js";
 export async function executeExportRecipe(deps, context, piece) {
     if (deps.db
@@ -20,12 +26,14 @@ export async function executeExportRecipe(deps, context, piece) {
     context.signal.throwIfAborted();
     const snapshot = exportSnapshot(deps, context, piece);
     const { view } = snapshot;
-    const audio = await revisionAudio(deps, context, view);
+    const audio = await revisionAudio(deps, context, view, { levelled: true });
     const wav = piece.key === "export:wav";
     if (!wav && piece.key !== "export:video")
-        throw new Error("Slopify hit an internal error (unknown kind of export). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        throw new Error("Slopify hit an internal error (unknown kind of export). Try again; if it happens again, use Download diagnostics in Settings and report it.");
     if (wav && audio.length === 0)
-        throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Retry stage.");
+        throw new Error("The audio export has nothing to export because narration is turned off for this project. Turn narration on in Edit project, then Try again.");
+    if (!wav && usesShortMode(view.revision.config))
+        return executeShortExport(deps, context, piece, snapshot, audio);
     const filename = wav ? "audio.wav" : "video.mp4";
     const pending = allocateAsset(deps, context.work.projectId, filename);
     const prepared = [];
@@ -35,6 +43,9 @@ export async function executeExportRecipe(deps, context, piece) {
         const burn = !wav && view.revision.config.subtitles?.mode === "burn-in";
         if (burn)
             directory = captionDirectory(deps, context, snapshot);
+        const portraits = directory === undefined
+            ? undefined
+            : writePortraits(deps.db, view.revision.config, directory);
         const mode = burn
             ? "burn-in"
             : captions.some((row) => row.output.role === "subtitles_srt") &&
@@ -48,13 +59,9 @@ export async function executeExportRecipe(deps, context, piece) {
                 ? undefined
                 : { path: row.path, seconds: row.seconds };
         };
-        const images = (wav ? [] : view.revision.content.imageOrder).map((key) => {
-            const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
-            if (row === undefined)
-                throw new Error("The video export can't find one of the slideshow images. Use Re-run section on Images (or regenerate that image in Edit project → Images), then Retry stage.");
-            return outputPath(deps.paths, context.work.projectId, row.output.path);
-        });
+        const images = wav ? [] : slideshowImages(deps, context, view);
         const edited = wav ? undefined : await exportEdit(deps, context, view, images);
+        const bed = wav ? undefined : await exportBed(deps, context, view);
         const plan = wav
             ? undefined
             : planRender({
@@ -70,6 +77,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 images,
                 output: pending.absolutePath,
                 edit: edited?.edit,
+                bed,
             });
         const totalSeconds = plan?.totalSeconds ?? audio.reduce((sum, row) => sum + row.seconds, 0);
         const projectDirectory = projectDir(deps.paths, context.work.projectId);
@@ -93,6 +101,7 @@ export async function executeExportRecipe(deps, context, piece) {
                 output: pending.path,
                 editList: withPaths(plan.editList, relativePath),
                 subtitles: config.subtitles,
+                ...(portraits === undefined ? {} : { speakerPortraits: portraits.recorded }),
                 ...(edited?.settings === undefined ? {} : { videoEdit: edited.settings }),
                 ...(edited === undefined || edited.warnings.length === 0
                     ? {}
@@ -107,25 +116,71 @@ export async function executeExportRecipe(deps, context, piece) {
             current: Math.min(100, Math.round(elapsedMs / (totalSeconds * 10))),
             total: 100,
         });
-        if (plan === undefined)
-            await runFfmpeg({
-                bin: deps.ffmpeg,
-                args: audioExportArgs(audio, pending.absolutePath),
-                signal: context.signal,
-                log: deps.log,
-                onProgress,
-            });
+        // Level the volume: the audio-only file is mastered to the audio files' target, the video to
+        // the video's (`loudness/model.ts`).
+        const goal = masterGoal(config, plan === undefined ? "audioFiles" : "video");
+        let master;
+        if (plan === undefined) {
+            const mixed = goal === undefined ? pending.absolutePath : `${pending.absolutePath}.mix.wav`;
+            try {
+                await runFfmpeg({
+                    bin: deps.ffmpeg,
+                    args: audioExportArgs(audio, mixed),
+                    signal: context.signal,
+                    log: deps.log,
+                    onProgress,
+                });
+                if (goal !== undefined) {
+                    const run = { bin: deps.ffmpeg, log: deps.log, signal: context.signal };
+                    await masterFile(run, mixed, `${pending.absolutePath}.master.wav`, goal, {
+                        sampleRate: 48000,
+                        channels: 2,
+                    });
+                    // The export is 16-bit PCM, as it always was.
+                    await runFfmpeg({
+                        bin: deps.ffmpeg,
+                        args: [
+                            "-hide_banner",
+                            "-nostdin",
+                            "-loglevel",
+                            "error",
+                            "-nostats",
+                            "-y",
+                            "-i",
+                            `${pending.absolutePath}.master.wav`,
+                            "-c:a",
+                            "pcm_s16le",
+                            "-f",
+                            "wav",
+                            pending.absolutePath,
+                        ],
+                        signal: context.signal,
+                        log: deps.log,
+                        onProgress: () => { },
+                    });
+                    master = await masterReport(run, pending.absolutePath, goal);
+                }
+            }
+            finally {
+                if (goal !== undefined) {
+                    rmSync(mixed, { force: true });
+                    rmSync(`${pending.absolutePath}.master.wav`, { force: true });
+                }
+            }
+        }
         else
-            await renderSlideshow({
+            master = await renderSlideshow({
                 bin: deps.ffmpeg,
                 edit: plan.editList,
                 output: plan.output,
                 burnSubtitles: burn,
                 cwd: directory,
+                ...(portraits === undefined ? {} : { portraits: portraits.overlays }),
                 scratch: projectDirectory,
                 signal: context.signal,
                 log: deps.log,
                 onProgress,
+                ...(goal === undefined ? {} : { master: goal }),
             });
         context.signal.throwIfAborted();
         const asset = sealAsset(deps, pending);
@@ -134,6 +189,7 @@ export async function executeExportRecipe(deps, context, piece) {
             ...(edited === undefined || edited.warnings.length === 0
                 ? {}
                 : { warnings: edited.warnings }),
+            ...(master === undefined ? {} : { master }),
         }));
         prepared.push(preparedText(deps, context, piece, "render_params", "render.json", JSON.stringify(record)));
         prepared.push(...captions.map((row) => retainedOutput(deps, view, row)));
@@ -147,12 +203,21 @@ export async function executeExportRecipe(deps, context, piece) {
             rmSync(directory, { recursive: true, force: true });
     }
 }
+// The project's images in slideshow order, as files.
+export function slideshowImages(deps, context, view) {
+    return view.revision.content.imageOrder.map((key) => {
+        const row = view.outputs.find((one) => one.workKey === `image:${key}` && one.selected && one.available && one.state === "ready");
+        if (row === undefined)
+            throw new Error("The video export can't find one of the slideshow images. Use More → make it again in its section on Images (or regenerate that image in Edit project → Images), then Try again.");
+        return outputPath(deps.paths, context.work.projectId, row.output.path);
+    });
+}
 function captionDirectory(deps, context, snapshot) {
     const find = (role) => snapshot.view.outputs.find((row) => row.selected && row.available && row.state === "ready" && row.output.role === role);
     const ass = find("subtitle_ass");
     const font = find("subtitle_font");
     if (ass === undefined || font === undefined)
-        throw new Error("Burned-in captions are missing their caption file or font. Use Re-run section on Video (or choose the caption font again in Edit project → Subtitles), then Retry stage.");
+        throw new Error("Burned-in captions are missing their caption file or font. Use More → Render the video again in the Video section (or choose the caption font again in Edit project → Subtitles), then Try again.");
     const directory = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "render-"));
     try {
         mkdirSync(join(directory, "fonts"), { mode: 0o700 });

package/dist/slices/rebuild/runtime-figure-card.js

@@ -0,0 +1,87 @@
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { captionFont, captionFontDeps } from "../fonts/coverage.js";
+import { describedKinds } from "../narration/blocks.js";
+import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
+import { projectDir } from "../storage/layout.js";
+import { defaultCardStyle, renderCard } from "../video/figure-card.js";
+import { articlePicture } from "./runtime-pictures.js";
+import { executionView } from "./runtime-plan.js";
+import { preparedResult, publishResult } from "./runtime-publication.js";
+// A `figure:card:<n>` step: the block drawn as a card in each frame the project needs (the
+// video's, and upright for the Shorts of a 16:9 video), with the ffmpeg Slopify ships.
+const values = z.object({
+    kind: z.enum(describedKinds),
+    index: z.number().int().positive(),
+    source: z.string(),
+    section: z.string().nullable(),
+    image: z.string().nullable(),
+    formats: z.array(z.enum(["16:9", "9:16"])).min(1),
+    fontId: z.string(),
+    color: z.string().nullable(),
+    language: z.string(),
+});
+const frames = { "16:9": [1920, 1080], "9:16": [1080, 1920] };
+export async function executeFigureCard(deps, context, piece) {
+    if (piece.input.kind !== "local")
+        throw new Error("Slopify hit an internal error (a figure card step was set up wrongly). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+    const card = values.parse(piece.input.values);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    // The article's own picture for a figure, when the project has it as an upload.
+    const picture = card.kind === "figure" && view !== undefined
+        ? articlePicture(deps, view, card.image ?? undefined)
+        : undefined;
+    const font = await captionFont(captionFontDeps(deps.paths), card.fontId, card.language === "en" ? undefined : card.language);
+    const workspace = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "card-"));
+    const pending = card.formats.map(() => allocateAsset(deps, context.work.projectId, `card-${String(card.index)}.png`));
+    const prepared = [];
+    try {
+        mkdirSync(join(workspace, "fonts"), { mode: 0o700 });
+        copyFileSync(font.path, join(workspace, "fonts", `card${font.extension}`));
+        for (const [at, format] of card.formats.entries()) {
+            const target = pending[at];
+            if (target === undefined)
+                continue;
+            const [width, height] = frames[format];
+            await renderCard({
+                bin: deps.ffmpeg,
+                input: {
+                    kind: card.kind,
+                    source: card.source,
+                    section: card.section,
+                    width,
+                    height,
+                    style: {
+                        ...defaultCardStyle,
+                        font: font.assName,
+                        ...(card.color === null ? {} : { accent: card.color }),
+                    },
+                    picture: picture !== undefined,
+                },
+                cwd: workspace,
+                output: target.absolutePath,
+                picture,
+                signal: context.signal,
+                log: deps.log,
+            }, (ass) => writeFileSync(join(workspace, "card.ass"), ass, { mode: 0o600 }));
+            context.signal.throwIfAborted();
+            const asset = sealAsset(deps, target);
+            const output = preparedResult(deps, context, piece, "figure_card", asset, null, {
+                index: card.index,
+                format,
+            });
+            prepared.push({ ...output, slot: `${piece.key}:${format}` });
+        }
+        await publishResult(deps, context, piece, prepared, {
+            index: card.index,
+            kind: card.kind,
+            picture: picture !== undefined,
+        });
+        return "done";
+    }
+    finally {
+        rmSync(workspace, { recursive: true, force: true });
+        discardPreparedAssets(deps, [...pending, ...prepared.map((one) => one.asset)]);
+    }
+}