@gentbajko/slopify 2.3.1 → 2.4.0

package/dist/slices/rebuild/preview-details.js

@@ -3,6 +3,8 @@ import { sourceOf } from "../admission/model.js";
 import { motionStyleLabels } from "../admission/rules.js";
 import { documentThemeLabel } from "../document/model.js";
 import { getRevisionView } from "../revisions/view.js";
+import { musicVolumeOf, shortsSpeedOf } from "../shorts/model.js";
+import { videoEditOf, videoEditRows } from "../video/edit-settings.js";
 export function previewDetails(deps, view, allRecipes, selected) {
     const parent = view.revision.parentId === null
         ? undefined
@@ -62,7 +64,9 @@ export function previewDetails(deps, view, allRecipes, selected) {
                             ? "Article"
                             : row.stage === "research"
                                 ? "Research"
-                                : "Thumbnail prompt";
+                                : row.key.startsWith("shorts:")
+                                    ? "Short image prompts"
+                                    : "Thumbnail prompt";
             return [
                 {
                     key: row.key,
@@ -129,11 +133,35 @@ function inputChanges(parent, view) {
     add("Narration chunking", before.chunking, after.chunking);
     add("YouTube description", before.youtubeDescription === true ? "On" : "Off", after.youtubeDescription === true ? "On" : "Off");
     add("Description prompt", before.descriptionPrompt, after.descriptionPrompt);
+    add("Shorts", before.shorts?.enabled === true ? "On" : "Off", after.shorts?.enabled === true ? "On" : "Off");
+    add("Number of shorts", before.shorts?.count, after.shorts?.count);
+    add("Short length (seconds)", before.shorts === undefined
+        ? undefined
+        : `${String(before.shorts.minSeconds)}-${String(before.shorts.maxSeconds)}`, after.shorts === undefined
+        ? undefined
+        : `${String(after.shorts.minSeconds)}-${String(after.shorts.maxSeconds)}`);
+    add("Shorts prompt", before.shorts?.prompt, after.shorts?.prompt);
+    add("Shorts image prompt", before.shorts?.imagePrompt, after.shorts?.imagePrompt);
+    add("Title on the shorts", before.shorts === undefined ? undefined : before.shorts.titleOnScreen === true ? "On" : "Off", after.shorts === undefined ? undefined : after.shorts.titleOnScreen === true ? "On" : "Off");
+    add("Shorts speed", before.shorts === undefined ? undefined : `${shortsSpeedOf(before.shorts).toFixed(2)}×`, after.shorts === undefined ? undefined : `${shortsSpeedOf(after.shorts).toFixed(2)}×`);
+    add("Shorts music", old.shortsMusic === undefined ? "None" : "Uploaded file", next.shortsMusic === undefined
+        ? "None"
+        : next.shortsMusic === old.shortsMusic
+            ? "Uploaded file"
+            : "New uploaded file");
+    add("Shorts music volume (%)", before.shorts === undefined ? undefined : musicVolumeOf(before.shorts), after.shorts === undefined ? undefined : musicVolumeOf(after.shorts));
+    add("Full video link", before.shorts?.fullVideoLink, after.shorts?.fullVideoLink);
+    add("Short ranges set by hand", old.shortsRanges, next.shortsRanges);
     add("Silence gap (seconds)", before.silenceGapSeconds, after.silenceGapSeconds);
     add("Silence at start and end (seconds)", before.edgeSilenceSeconds, after.edgeSilenceSeconds);
     add("Seconds per image", before.imageSeconds, after.imageSeconds);
     add("Zoom (%)", before.zoomPercent, after.zoomPercent);
     add("Motion", motionStyleLabels[before.motionStyle], motionStyleLabels[after.motionStyle]);
+    // Row by row, so turning on grain says "Film grain: Off → Subtle" and nothing else.
+    const editBefore = videoEditRows(videoEditOf(before));
+    const editAfter = new Map(videoEditRows(videoEditOf(after)));
+    for (const [label, value] of editBefore)
+        add(label, value, editAfter.get(label));
     add("Intro", before.intro, after.intro);
     add("Outro", before.outro, after.outro);
     add("Subtitle settings", before.subtitles, after.subtitles);

package/dist/slices/rebuild/preview-plan.js

@@ -8,7 +8,7 @@ import { hasSubmittedRequest, requiresNewSubmission, retainedPreviewPlan, } from
 import { providedDependencyFingerprint } from "./provided-review.js";
 import { recipeInputSchema } from "./recipe-input-schema.js";
 import { recipeProviderChoice } from "./recipe-provider-choice.js";
-import { priceRecipe } from "./recipe-work.js";
+import { priceRecipes } from "./recipe-work.js";
 import { reservationKey } from "./runtime-admission.js";
 import { narrationOrdinal } from "./runtime-narration-reuse.js";
 import { executionCatalogue } from "./runtime-plan.js";
@@ -166,7 +166,7 @@ export function planPreview(deps, view, catalogue, selection, id) {
             state: row.state,
         })),
         providedReuseRequired: execution.reviews.map((row) => row.key),
-        costs: estimateRequests(work.map((row) => priceRecipe(row.inflight || !requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint)
+        costs: estimateRequests(work.flatMap((row) => priceRecipes(row.inflight || !requiresNewSubmission(deps, view.revision.id, row.key, row.fingerprint)
             ? { ...row, disposition: "reuse" }
             : row, recipes.find((recipe) => recipe.key === row.key))), snapshot),
         wholeRequestNotice: plan.wholeRequestNotice,

package/dist/slices/rebuild/recipe-build.js

@@ -1,6 +1,8 @@
 import { audioRecipes } from "./recipe-audio.js";
 import { documentRecipes } from "./recipe-document.js";
+import { editPlan } from "./recipe-edit.js";
 import { exportRecipes } from "./recipe-exports.js";
+import { shortsRecipes } from "./recipe-shorts.js";
 import { textRecipes } from "./recipe-text.js";
 import { thumbnailRecipes, visualAssets, visualRecipes } from "./recipe-visual.js";
 import { youtubeRecipes } from "./recipe-youtube.js";
@@ -10,13 +12,15 @@ export function buildRecipes(context) {
     const exports = exportRecipes(context, audio);
     const captions = exports.find((value) => value.key === "subtitles:files");
     const thumbnail = thumbnailRecipes(context, text.recipes);
+    const youtube = youtubeRecipes(context, exports);
     return [
         ...text.recipes,
         ...audio.recipes,
         ...exports,
-        ...youtubeRecipes(context, exports),
+        ...youtube,
+        ...shortsRecipes(context, exports),
         ...thumbnail,
         ...documentRecipes(context, text, thumbnail),
-        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null)),
+        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images))),
     ];
 }

package/dist/slices/rebuild/recipe-edit.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { usesYoutubeDescription } from "../admission/rules.js";
+import { headingChapters, topHeadings } from "../video/chapters.js";
+import { chapterOpeningShots, sentenceCutPoints } from "../video/cuts.js";
+import { animatedClipSeconds, animatedImageIndexes, animatePrompt, editNeedsTiming, usesAnimation, usesChapterCards, usesNarrationCuts, videoEditOf, } from "../video/edit-settings.js";
+import { fps } from "../video/plan.js";
+import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+// What the Video stage's edit settings add to the plan: the word timing and chapters the
+// render reads, and a paid `animate:<image>` request for each image brought to life. Every
+// setting left at today's behaviour adds nothing, so a project without them, or with them all
+// off, plans the same export fingerprint it always did and no finished video turns outdated.
+//
+// "Chapter openers" can only be told once the word timing (and the YouTube chapters, when
+// that step runs) has landed, so until then one deferred `animate:future` stands in for the
+// requests and carries their cost, the way `shorts:future` does.
+export const animateFutureKey = "animate:future";
+export function editPlan(context, exports, youtube, images) {
+    const { config } = context;
+    const edit = videoEditOf(config);
+    if (config.sources.video !== "generate")
+        return { recipes: [], values: [], dependsOn: [] };
+    const timing = editNeedsTiming(config)
+        ? exports.find((value) => value.key === "subtitles:timing")
+        : undefined;
+    const description = youtube.find((value) => value.key === "youtube:description");
+    const fromDescription = usesYoutubeDescription(config) && description !== undefined;
+    const values = [];
+    const dependsOn = [];
+    if (usesNarrationCuts(config))
+        values.push(["cuts", "narration-v1"]);
+    if (edit.transition !== "cut")
+        values.push(["transition", edit.transition, edit.transitionSeconds]);
+    if (edit.vignette !== "off" ||
+        edit.grain !== "off" ||
+        edit.grade !== "none" ||
+        edit.atmosphere !== "none")
+        values.push(["look-v1", edit.vignette, edit.grain, edit.grade, edit.atmosphere]);
+    if (usesChapterCards(config))
+        values.push(["cards-v1", config.subtitles?.fontId ?? "default"]);
+    if (timing !== undefined) {
+        values.push(["timing", resourceIdentity(context, timing)]);
+        dependsOn.push(timing.key);
+        if (fromDescription && description !== undefined) {
+            values.push(["chapters", resourceIdentity(context, description)]);
+            dependsOn.push(description.key);
+        }
+        else
+            values.push(["chapters", "headings", headingsIdentity(context)]);
+    }
+    const recipes = usesAnimation(config)
+        ? animateRecipes(context, images, timing, fromDescription ? description : undefined)
+        : [];
+    if (recipes.length > 0) {
+        values.push(["animate-v1", recipes.map((value) => value.fingerprint)]);
+        dependsOn.push(...recipes.map((value) => value.key));
+    }
+    return { recipes, values, dependsOn };
+}
+function animateRecipes(context, images, timing, description) {
+    const { config, content } = context;
+    const edit = videoEditOf(config);
+    const provider = config.images?.provider ?? "";
+    // Only images the project draws are animated; an uploaded picture or clip is shown as it
+    // was given.
+    const drawn = (index) => {
+        const key = content.imageOrder[index];
+        return key !== undefined && content.imageDefinitions[key]?.source === "generate";
+    };
+    let indexes;
+    if (edit.animate === "every")
+        indexes = animatedImageIndexes(edit, content.imageOrder.length);
+    else {
+        const opening = openingImages(context, timing, description);
+        if (opening === undefined) {
+            const upper = Math.min(content.imageOrder.filter((_key, index) => drawn(index)).length, chapterEstimate(context));
+            return [
+                recipe(context, animateFutureKey, "video", {
+                    kind: "deferred",
+                    version: 1,
+                    operation: "animate",
+                    template: [
+                        timing?.fingerprint ?? null,
+                        description?.fingerprint ?? null,
+                        provider,
+                        edit.animateModel,
+                        upper,
+                    ],
+                }, [
+                    ...(timing === undefined ? [] : [timing.key]),
+                    ...(description ? [description.key] : []),
+                ]),
+            ];
+        }
+        indexes = opening;
+    }
+    return indexes.filter(drawn).flatMap((index) => {
+        const key = content.imageOrder[index];
+        const still = images.find((value) => value.key === `image:${key ?? ""}`);
+        if (key === undefined || still === undefined)
+            return [];
+        return [
+            recipe(context, `animate:${key}`, "video", {
+                kind: "image",
+                version: 1,
+                provider,
+                model: edit.animateModel,
+                prompt: animatePrompt,
+                aspect: config.format,
+                animate: { image: still.fingerprint, seconds: animatedClipSeconds },
+            }, [still.key], { unresolved: still.unresolved }),
+        ];
+    });
+}
+// The images (0-based, in slideshow order) the video and its chapters open on, once the word
+// timing and chapters are saved; undefined until then.
+function openingImages(context, timing, description) {
+    const count = context.content.imageOrder.length;
+    if (count === 0)
+        return [];
+    const words = timing === undefined ? undefined : savedWords(context, timing);
+    if (words === undefined)
+        return undefined;
+    const chapters = description === undefined
+        ? headingChapters(context.resolved.articleMarkdown ?? "", words)
+        : savedChapters(context, description);
+    if (chapters === undefined)
+        return undefined;
+    const shots = chapterOpeningShots({
+        fps,
+        imageSeconds: context.config.imageSeconds,
+        narration: usesNarrationCuts(context.config),
+        cutPoints: sentenceCutPoints(words),
+        chapterStarts: chapters.map((chapter) => chapter.start),
+    });
+    return [...new Set(shots.map((shot) => shot % count))];
+}
+const wordsPayload = z.object({
+    words: z.array(z.object({ text: z.string(), start: z.number(), end: z.number() })),
+});
+const chaptersPayload = z.object({
+    chapters: z.array(z.object({ start: z.number(), title: z.string() })),
+});
+function savedPayload(context, value) {
+    const piece = context.manifest.pieces.find((row) => row.key === value.key &&
+        selectedReference(row) &&
+        row.piece.state === "done" &&
+        row.fingerprint === value.fingerprint);
+    if (piece?.piece.payload === undefined || piece.piece.payload === null)
+        return undefined;
+    try {
+        return JSON.parse(piece.piece.payload);
+    }
+    catch {
+        return undefined;
+    }
+}
+function savedWords(context, timing) {
+    const parsed = wordsPayload.safeParse(savedPayload(context, timing));
+    return parsed.success ? parsed.data.words : undefined;
+}
+function savedChapters(context, description) {
+    const parsed = chaptersPayload.safeParse(savedPayload(context, description));
+    return parsed.success ? parsed.data.chapters : undefined;
+}
+// The article's chapter headings, which decide where heading chapters fall; null while the
+// article is not written yet.
+function headingsIdentity(context) {
+    const markdown = context.resolved.articleMarkdown;
+    return markdown === null ? null : fingerprint(topHeadings(markdown).map((one) => one.title));
+}
+// ceiling: how many chapters "Chapter openers" is charged for before they are known: the
+// article's headings and the opening, or twelve (the most a YouTube description is asked for)
+// while the article is not written yet.
+function chapterEstimate(context) {
+    const markdown = context.resolved.articleMarkdown;
+    return markdown === null ? 12 : topHeadings(markdown).length + 1;
+}

package/dist/slices/rebuild/recipe-exports.js

@@ -1,5 +1,6 @@
-import { usesYoutubeDescription } from "../admission/rules.js";
+import { usesShorts, usesYoutubeDescription } from "../admission/rules.js";
 import { audioExportArgs } from "../video/audio-export-args.js";
+import { editNeedsTiming } from "../video/edit-settings.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 export function exportRecipes(context, audio) {
     const { config, content } = context;
@@ -17,9 +18,13 @@ export function exportRecipes(context, audio) {
             ],
         }, audio.keys));
     const captions = config.subtitles !== undefined && config.subtitles.mode !== "off";
-    // The YouTube description's chapters use the same word timing, so it runs for them even
-    // with captions off; only the caption files below wait for captions.
-    if (!captions && !usesYoutubeDescription(config))
+    // The YouTube description's chapters, the shorts' clips and captions, and the video's cuts,
+    // chapter cards and chapter openers use the same word timing, so it runs for them even with
+    // captions off; only the caption files below wait for captions.
+    if (!captions &&
+        !usesYoutubeDescription(config) &&
+        !usesShorts(config) &&
+        !editNeedsTiming(config))
         return recipes;
     const timing = recipe(context, "subtitles:timing", "video", {
         kind: "local",

package/dist/slices/rebuild/recipe-input-schema.js

@@ -66,6 +66,7 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
         model: z.string(),
         prompt: z.string(),
         aspect: z.enum(["16:9", "9:16"]),
+        animate: z.object({ image: z.string(), seconds: z.number() }).strict().optional(),
     })
         .strict(),
     z

package/dist/slices/rebuild/recipe-legacy.js

@@ -59,6 +59,15 @@ export function legacyOutputWorkKey(output, config) {
         case "youtube_description":
         case "youtube_tags":
             return "youtube:description";
+        case "shorts":
+            return "shorts:pick";
+        case "short_image":
+            return `shorts:${String(output.meta.short ?? 1)}:image:${String(output.meta.index ?? 1)}`;
+        case "short_video":
+            return `shorts:${String(output.meta.short ?? 1)}:render`;
+        // Only ever made by a revision, never by the legacy stages.
+        case "animated_image":
+            return `animate:${String(output.meta.index ?? 1)}`;
         case "subtitles_srt":
         case "subtitles_vtt":
         case "subtitle_ass":

package/dist/slices/rebuild/recipe-model.js

@@ -17,6 +17,8 @@ export const localOperations = [
     "narration-files-v1",
     "render-document",
     "youtube-description-v1",
+    "shorts-pick-v1",
+    "short-render-v1",
 ];
 export const deferredOperations = [
     "narration-preparation",
@@ -30,6 +32,8 @@ export const deferredOperations = [
     "intro-narration",
     "outro-narration",
     "resolve-revision-recipe",
+    "shorts",
+    "animate",
 ];
 export function recipe(context, key, stage, input, dependsOn = [], options = {}) {
     const requestFingerprint = input.kind === "tts"
@@ -40,7 +44,9 @@ export function recipe(context, key, stage, input, dependsOn = [], options = {})
         : fingerprint(JSON.parse(JSON.stringify(input, (_key, value) => typeof value === "number" ? z.number().finite().parse(value) : value)));
     const token = input.kind === "tts"
         ? narrationRegenerationToken(context.content.regenerationTokens, input.logicalKey, input.segment)
-        : (context.content.regenerationTokens[options.tokenKey ?? key] ?? null);
+        : options.token !== undefined
+            ? options.token
+            : (context.content.regenerationTokens[options.tokenKey ?? key] ?? null);
     const researchToken = stage === "research" ? context.content.regenerationTokens["research:all"] : undefined;
     const workFingerprint = fingerprint([
         requestFingerprint,

package/dist/slices/rebuild/recipe-provider-choice.js

@@ -5,6 +5,21 @@ export function recipeProviderChoice(recipe, config) {
     // The YouTube description's request is built when it runs, from the project's LLM row.
     if (input.kind === "local" && input.operation === "youtube-description-v1")
         return config.llm === undefined ? undefined : { ...config.llm, family: "llm" };
+    // So is the shorts' pick; what stands in for the rest of the step until it lands is
+    // mostly images, which are its cost.
+    if (input.kind === "local" && input.operation === "shorts-pick-v1")
+        return config.llm === undefined ? undefined : { ...config.llm, family: "llm" };
+    if (input.kind === "deferred" && input.operation === "shorts")
+        return config.images === undefined ? undefined : { ...config.images, family: "image" };
+    // The chapter openers' clips are asked of the image provider's image-to-video model.
+    if (input.kind === "deferred" && input.operation === "animate")
+        return config.images === undefined
+            ? undefined
+            : {
+                provider: config.images.provider,
+                model: config.videoEdit?.animateModel ?? "",
+                family: "image",
+            };
     if (input.kind !== "deferred")
         return undefined;
     const family = input.operation === "narration-preparation"

package/dist/slices/rebuild/recipe-save.js

@@ -2,9 +2,28 @@ import { stageKinds } from "../../kernel/pipeline.js";
 import { sourceOf } from "../admission/model.js";
 import { allowedSources, edgeSilenceSecondsProblem, imageSecondsProblem, normaliseDraft, silenceGapSecondsMax, zoomPercentProblem, } from "../admission/rules.js";
 import { render } from "../admission/substitute.js";
+import { effectiveClips, pickedShortsOf, rangeProblem } from "../shorts/clips.js";
 import { buildRecipes } from "./recipe-build.js";
 import { selectedReference } from "./recipe-model.js";
 import { validateRecipeInputs } from "./recipe-validation.js";
+// A range set by hand for a short is checked against the pick it was set on, while that is
+// still the project's pick; one left from an earlier pick no longer applies and is ignored.
+function shortRangeFields(base, config, content) {
+    const ranges = content.shortsRanges;
+    const shorts = config.shorts;
+    if (ranges === undefined || shorts?.enabled !== true)
+        return [];
+    const row = base.pieces.find((one) => one.key === "shorts:pick" && one.selected && one.piece.state === "done");
+    const picked = pickedShortsOf(row?.piece.payload);
+    if (row === undefined || picked === undefined)
+        return [];
+    const current = Object.fromEntries(Object.entries(ranges).filter(([, range]) => range.pick === row.fingerprint));
+    const clips = effectiveClips(picked, current, row.fingerprint, shorts);
+    return Object.entries(current).flatMap(([number, range]) => {
+        const message = rangeProblem(picked, Number(number), range.first, range.last, shorts, clips);
+        return message === undefined ? [] : [{ field: `content.shortsRanges.${number}`, message }];
+    });
+}
 export function normalizeArticleIntent(base, edit) {
     const restart = edit.regenerate?.includes("article:body") === true ||
         (base.revision.config.sources.article === "provide" &&
@@ -27,6 +46,7 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
         ...validateRevisionEdit(edit.config, content),
         ...validateCues(content),
         ...validateRecipeInputs(edit.config, content),
+        ...shortRangeFields(base, edit.config, content),
     ];
     if (fields.length > 0)
         return { ok: false, fields };
@@ -122,7 +142,11 @@ export function planRevision(base, edit, prepared = { outputs: [], pieces: [] },
             : prepared.outputs.includes(row) || (unchanged && row.state === "ready")
                 ? "ready"
                 : row.fingerprint === next.fingerprint
-                    ? row.state
+                    ? // An outdated result made for exactly this step is current again: an undo
+                        // or a second edit that lands back on it must not ask for it to be redone.
+                        row.state === "outdated"
+                            ? "ready"
+                            : row.state
                     : next.kind === "provided"
                         ? "review"
                         : "outdated";

package/dist/slices/rebuild/recipe-shorts.js

@@ -0,0 +1,179 @@
+import { z } from "zod";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { usesShorts } from "../admission/rules.js";
+import { effectiveClips, pickedShortsOf } from "../shorts/clips.js";
+import { defaultShortsImagePrompt, musicVolumeOf, shortImageCount, shortsSpeedOf, } from "../shorts/model.js";
+import { imagePromptMessages } from "../shorts/prompts.js";
+import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js";
+import { llmInput, renderedPrompt } from "./recipe-text.js";
+// The Shorts step unfolds as its answers land, the way research's chapters unfold from the
+// plan. `shorts:pick` reads the word timing, so it waits for `subtitles:timing` and runs
+// beside the render; until its saved answer matches, one deferred `shorts:future` stands in
+// for everything after it (and carries the images' cost). Each picked clip then gets
+// `shorts:N:prompts`, one LLM call writing its image prompts; once those match, its
+// `shorts:N:image:M` images and its `shorts:N:render`.
+//
+// A clip's work carries the clip's own token (`clipToken`): the pick's token from when the
+// clip was first picked, plus the one "Make this short again" renews under `shorts:N`. So
+// picking the moments again redoes only the clips whose sentences changed, and one short
+// can be made again alone.
+export const shortsPickKey = "shorts:pick";
+export const shortsFutureKey = "shorts:future";
+export function shortsRecipes(context, exports) {
+    const { config } = context;
+    const shorts = config.shorts;
+    const timing = exports.find((value) => value.key === "subtitles:timing");
+    if (!usesShorts(config) || shorts === undefined || timing === undefined)
+        return [];
+    const pick = recipe(context, shortsPickKey, "video", {
+        kind: "local",
+        version: 1,
+        operation: "shorts-pick-v1",
+        values: [
+            resourceIdentity(context, timing),
+            config.llm?.provider ?? "",
+            config.llm?.model ?? "",
+            config.llm?.thinking ?? null,
+            // Blank means the built-in prompt; the step fills it in, so a new built-in wording
+            // ships as a new operation version rather than a silent change here.
+            shorts.prompt?.trim() ? renderedPrompt(context, "shorts") : "",
+            shorts.count,
+            shorts.minSeconds,
+            shorts.maxSeconds,
+            config.title,
+        ],
+    }, [timing.key], 
+    // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
+    { kind: "provider" });
+    const picked = savedPicked(context, pick);
+    const images = config.images ?? { provider: "", model: "" };
+    const style = shorts.imagePrompt?.trim()
+        ? renderedPrompt(context, "shortsImage")
+        : defaultShortsImagePrompt;
+    if (picked === undefined)
+        return [
+            pick,
+            recipe(context, shortsFutureKey, "video", {
+                kind: "deferred",
+                version: 1,
+                operation: "shorts",
+                template: [
+                    pick.fingerprint,
+                    style,
+                    images.provider,
+                    images.model,
+                    config.imageSeconds,
+                    shorts.count,
+                    shorts.maxSeconds,
+                    config.llm?.provider ?? "",
+                    config.llm?.model ?? "",
+                ],
+            }, [pick.key], { tokenKey: shortsPickKey }),
+        ];
+    const recipes = [pick];
+    const clips = effectiveClips(picked, context.content.shortsRanges, pick.fingerprint, shorts);
+    for (const clip of clips) {
+        const prefix = `shorts:${String(clip.number)}`;
+        const token = clipToken(context, clip);
+        const count = shortImageCount(clip.end - clip.start, config.imageSeconds);
+        const prompts = {
+            ...recipe(context, `${prefix}:prompts`, "video", llmInput(context, imagePromptMessages({
+                style,
+                videoTitle: config.title,
+                shortTitle: clip.title,
+                text: clip.text,
+                count,
+                imageSeconds: config.imageSeconds,
+            })), [pick.key], { token }),
+            unfoldsImages: { count, provider: images.provider, model: images.model },
+        };
+        recipes.push(prompts);
+        const written = savedPrompts(context, prompts, token);
+        if (written === undefined || written.length !== count)
+            continue;
+        const stills = written.map((prompt, index) => recipe(context, `${prefix}:image:${String(index + 1)}`, "video", {
+            kind: "image",
+            version: 1,
+            provider: images.provider,
+            model: images.model,
+            prompt,
+            aspect: "9:16",
+        }, [prompts.key], { token }));
+        recipes.push(...stills);
+        const extras = renderExtras(context, clip);
+        recipes.push(recipe(context, `${prefix}:render`, "video", {
+            kind: "local",
+            version: 1,
+            operation: "short-render-v1",
+            values: [
+                resourceIdentity(context, timing),
+                clip.number,
+                clip.start,
+                clip.end,
+                stills.map((still) => resourceIdentity(context, still)),
+                config.imageSeconds,
+                config.zoomPercent,
+                config.motionStyle,
+                config.subtitles?.fontId ?? "default",
+                // Only when one of the later settings is in use, so a short rendered before
+                // they existed keeps its fingerprint.
+                ...(extras === undefined ? [] : [extras]),
+            ],
+        }, [pick.key, ...stills.map((still) => still.key)], { token }));
+    }
+    return recipes;
+}
+// What the render draws and plays beyond the clip itself: the title headline, a faster
+// speed and the background music at its level. Undefined when none is in use.
+export function renderExtras(context, clip) {
+    const shorts = context.config.shorts;
+    if (shorts === undefined)
+        return undefined;
+    const speed = shortsSpeedOf(shorts);
+    const music = context.content.shortsMusic;
+    const extras = {
+        ...(shorts.titleOnScreen === true ? { title: clip.title } : {}),
+        ...(speed === 1 ? {} : { speed }),
+        ...(music === undefined ? {} : { music: [music, musicVolumeOf(shorts)] }),
+    };
+    return Object.keys(extras).length === 0 ? undefined : extras;
+}
+// The token a clip's prompts, images and render carry: the pick's token from when the clip
+// was first picked (the current one for a pick saved before clips kept theirs), with the
+// clip's own "Make this short again" token when it has one.
+export function clipToken(context, clip) {
+    const tokens = context.content.regenerationTokens;
+    const base = clip.seed !== undefined ? clip.seed : (tokens[shortsPickKey] ?? null);
+    const own = tokens[shortRemakeKey(clip.number)];
+    return own === undefined ? base : fingerprint([base, own]);
+}
+// The regeneration key "Make this short again" renews for short N.
+export function shortRemakeKey(number) {
+    return `shorts:${String(number)}`;
+}
+// What the pick saved, when its saved answer is the one this plan asks for.
+export function savedPicked(context, pick) {
+    const piece = context.manifest.pieces.find((row) => row.key === pick.key &&
+        selectedReference(row) &&
+        row.piece.state === "done" &&
+        row.fingerprint === pick.fingerprint);
+    return pickedShortsOf(piece?.piece.payload);
+}
+// A clip's saved image prompts, when they answer this plan's request. The request carries
+// the model's thinking settings from the catalogue, which the plan without a catalogue has
+// not got, so either fingerprint matches (like `matchingText`).
+function savedPrompts(context, prompts, token) {
+    const logical = context.catalogue === undefined || prompts.input.kind !== "llm"
+        ? prompts.fingerprint
+        : recipe({ content: context.content }, prompts.key, prompts.stage, { ...prompts.input, thinkingConfig: null }, prompts.dependsOn, { token }).fingerprint;
+    const piece = context.manifest.pieces.find((row) => row.key === prompts.key &&
+        selectedReference(row) &&
+        row.piece.state === "done" &&
+        (row.fingerprint === prompts.fingerprint || row.fingerprint === logical));
+    if (piece?.piece.payload === undefined || piece.piece.payload === null)
+        return undefined;
+    const parsed = z
+        .object({ prompts: z.array(z.string()) })
+        .safeParse(JSON.parse(piece.piece.payload));
+    return parsed.success ? parsed.data.prompts : undefined;
+}