@gentbajko/slopify 2.5.0 → 3.0.0

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)]);
+    }
+}

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

@@ -1,10 +1,12 @@
 import { readFileSync } from "node:fs";
 import { z } from "zod";
+import { imageBlob } from "../channels/repo.js";
 import { outputPath } from "../storage/layout.js";
 // The provider call an image step makes: its request, the effort when one is chosen and, while
 // the project's Establishing image is on, that image's bytes as the visual reference.
 export function imageCall(deps, projectId, input, previewLabel) {
     const reference = referenceImage(deps, projectId, input);
+    const cast = castImages(deps, input);
     return {
         provider: input.provider,
         model: input.model,
@@ -12,6 +14,7 @@ export function imageCall(deps, projectId, input, previewLabel) {
         aspect: input.aspect,
         ...(input.thinking === undefined ? {} : { thinking: input.thinking }),
         ...(reference === undefined ? {} : { reference }),
+        ...(cast === undefined ? {} : { cast }),
         ...(previewLabel === undefined ? {} : { previewLabel }),
     };
 }
@@ -19,7 +22,7 @@ function referenceImage(deps, projectId, input) {
     if (input.reference === undefined)
         return undefined;
     // The step waits for the establishing image, so a missing one went away since.
-    const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Retry stage.";
+    const missing = "The establishing image this image is drawn from is missing. Use Regenerate on the establishing image in the Images section (or upload it again in Edit project → Images), then use Try again.";
     if (input.reference.assetId === null)
         throw new Error(missing);
     const row = z
@@ -39,9 +42,25 @@ function referenceImage(deps, projectId, input) {
     }
     const mime = imageMime(bytes);
     if (mime === undefined)
-        throw new Error("The establishing image is not a PNG or JPEG file, so it can't be sent as a reference. Upload a PNG or JPEG in Edit project → Images → Establishing image, then use Retry stage.");
+        throw new Error("The establishing image is not a PNG or JPEG file, so it can't be sent as a reference. Upload a PNG or JPEG in Edit project → Images → Establishing image, then use Try again.");
     return { bytes, mime };
 }
+// The cast pictures the request names, read by hash from the database. They are never removed
+// while a project may name them, so a missing one came from a backup of another install.
+function castImages(deps, input) {
+    if (input.cast === undefined)
+        return undefined;
+    return input.cast.map((member) => ({
+        name: member.name,
+        description: member.description,
+        images: member.images.map((sha256) => {
+            const blob = imageBlob(deps.db, sha256);
+            if (blob === undefined)
+                throw new Error(`A picture of ${member.name} that this project was started with is not in this Slopify's database, so it can't be sent as a reference. Add the picture again in Channels → Cast, then start the video again from Play.`);
+            return blob;
+        }),
+    }));
+}
 function imageMime(bytes) {
     const png = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
     if (png.every((value, index) => bytes[index] === value))