@gentbajko/slopify 2.3.1 → 2.5.0

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,186 @@
+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 { imageChoice } from "./recipe-reference.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, 
+// The establishing image the shorts' images are drawn from, when it is on.
+reference) {
+    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 ?? "",
+                    // Only what is in use, so shorts planned before these existed keep their
+                    // fingerprint; the estimate reads the fields above by position.
+                    ...(config.images?.thinking === undefined ? [] : [config.images.thinking]),
+                    ...(reference === undefined ? [] : [reference.input.fingerprint]),
+                ],
+            }, [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,
+            ...imageChoice(config),
+            prompt,
+            aspect: "9:16",
+            ...(reference === undefined ? {} : { reference: reference.input }),
+        }, [prompts.key, ...(reference === undefined ? [] : [reference.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;
+}

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

@@ -1,15 +1,19 @@
-import { narrationPreparationFields, usesNarrationPreparation, usesYoutubeDescription, youtubeDescriptionFields, } from "../admission/rules.js";
+import { narrationPreparationFields, shortsFields, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, videoEditFields, youtubeDescriptionFields, } from "../admission/rules.js";
 import { detectSlots, render } from "../admission/substitute.js";
+import { usesAnimation } from "../video/edit-settings.js";
 export function validateRecipeInputs(config, content) {
     const fields = [
         ...narrationPreparationFields(config),
         ...youtubeDescriptionFields(config),
+        ...shortsFields(config),
+        ...videoEditFields(config),
     ];
     const llm = (config.sources.research === "generate" && config.sources.article !== "provide") ||
         (config.sources.article === "generate" && !content.articleEdited) ||
         config.sources.thumbnail === "prompt_by_llm" ||
         usesNarrationPreparation(config) ||
         usesYoutubeDescription(config) ||
+        usesShorts(config) ||
         (config.sources.audio === "generate" &&
             (config.intro?.mode === "llm" || config.outro?.mode === "llm"));
     if (llm && (!config.llm?.provider.trim() || !config.llm.model.trim()))
@@ -24,7 +28,9 @@ export function validateRecipeInputs(config, content) {
         content.imageOrder.some((key) => content.imageDefinitions[key]?.source === "generate");
     if ((generatedImages ||
         config.sources.thumbnail === "from_prompt" ||
-        config.sources.thumbnail === "prompt_by_llm") &&
+        config.sources.thumbnail === "prompt_by_llm" ||
+        usesShorts(config) ||
+        usesAnimation(config)) &&
         (!config.images?.provider.trim() || !config.images.model.trim()))
         fields.push({ field: "images", message: "Pick an image provider and model." });
     if (content.imageOrder.length > 60)
@@ -56,6 +62,17 @@ export function validateRecipeInputs(config, content) {
             raw: content.promptTemplates.description,
             literal: config.rendered.description,
         });
+    // Likewise the Shorts step's two prompts, each only when one is picked.
+    for (const [key, name] of [
+        ["shorts", config.shorts?.prompt],
+        ["shortsImage", config.shorts?.imagePrompt],
+    ])
+        if (usesShorts(config) && name?.trim() && content.promptTemplates[key] != null)
+            prompts.push({
+                field: `rendered.${key}`,
+                raw: content.promptTemplates[key] ?? null,
+                literal: config.rendered[key],
+            });
     if ((config.sources.article === "generate" && !content.articleEdited) ||
         (config.sources.research === "generate" && config.sources.article !== "provide"))
         prompts.push({
@@ -76,6 +93,20 @@ export function validateRecipeInputs(config, content) {
             raw: content.promptTemplates.thumbnailPrompt ?? null,
             literal: config.rendered.thumbnailPrompt,
         });
+    // The establishing image: its prompt is checked like the thumbnail's, an upload must be there.
+    if (usesReference(config) && config.reference?.source === "prompt")
+        prompts.push({
+            field: "rendered.referencePrompt",
+            raw: content.promptTemplates.referencePrompt ?? null,
+            literal: config.rendered.referencePrompt,
+        });
+    if (usesReference(config) &&
+        config.reference?.source === "provide" &&
+        content.provided.reference === undefined)
+        fields.push({
+            field: "content.provided.reference",
+            message: "Upload the establishing image, choose From a prompt instead, or set Establishing image to Off.",
+        });
     if (config.sources.images !== "off")
         for (const key of content.imageOrder) {
             const image = content.imageDefinitions[key];

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

@@ -1,7 +1,12 @@
 import { render } from "../admission/substitute.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { imageChoice } from "./recipe-reference.js";
 import { matchingText, renderedPrompt } from "./recipe-text.js";
-export function visualRecipes(config, content, audioFingerprint, captionFingerprint) {
+export function visualRecipes(config, content, audioFingerprint, captionFingerprint, 
+// What the Video stage's edit settings add (`recipe-edit.ts`), from the images planned here.
+edit, 
+// The establishing image the generated images are drawn from, when it is on.
+reference) {
     const recipes = [];
     const imageKeys = config.sources.images === "off" ? [] : content.imageOrder;
     for (const key of imageKeys) {
@@ -17,13 +22,14 @@ export function visualRecipes(config, content, audioFingerprint, captionFingerpr
             : {
                 kind: "image",
                 version: 1,
-                provider: config.images?.provider ?? "",
-                model: config.images?.model ?? "",
+                ...imageChoice(config),
                 aspect: config.format,
                 prompt: prompt ?? "",
-            }, [], { unresolved: image.source === "provide" ? image.assetId === null : !prompt?.trim() }));
+                ...(reference === undefined ? {} : { reference: reference.input }),
+            }, image.source === "provide" || reference === undefined ? [] : [reference.key], { unresolved: image.source === "provide" ? image.assetId === null : !prompt?.trim() }));
     }
     if (config.sources.video !== "off") {
+        const edited = edit?.([...recipes]) ?? { recipes: [], values: [], dependsOn: [] };
         const audioKeys = config.sources.audio === "off"
             ? []
             : [
@@ -55,16 +61,24 @@ export function visualRecipes(config, content, audioFingerprint, captionFingerpr
                 ...(config.motionStyle === "zoom" ? [] : [config.motionStyle]),
                 // v1 split the timeline evenly across the images; v2 cycles them.
                 "slideshow-zoom-v2",
+                // Only what the edit settings change; nothing at all for today's slideshow, so
+                // its fingerprint is the one it always had.
+                ...(edited.values.length === 0 ? [] : [["video-edit", ...edited.values]]),
             ],
         }, [
             ...recipes.map((value) => value.key),
             ...audioKeys,
             ...(config.subtitles?.mode === "burn-in" ? ["subtitles:files"] : []),
+            ...edited.dependsOn,
         ], { unresolved: imageKeys.length === 0 }));
+        // After the export, so the images' recipes above stay the only ones its first values list.
+        recipes.splice(recipes.length - 1, 0, ...edited.recipes);
     }
     return recipes;
 }
-export function thumbnailRecipes(context, textRecipes) {
+export function thumbnailRecipes(context, textRecipes, 
+// The establishing image, when it is on and the thumbnail is drawn from it too.
+reference) {
     const { config, content } = context;
     if (config.sources.thumbnail === "off")
         return [];
@@ -92,16 +106,23 @@ export function thumbnailRecipes(context, textRecipes) {
                     config.images?.provider ?? null,
                     config.images?.model ?? null,
                     config.format,
+                    // Only what is in use, so a thumbnail made before these existed keeps its
+                    // fingerprint.
+                    ...(config.images?.thinking === undefined ? [] : [config.images.thinking]),
+                    ...(reference === undefined ? [] : [reference.input.fingerprint]),
                 ],
             }
             : {
                 kind: "image",
                 version: 1,
-                provider: config.images?.provider ?? "",
-                model: config.images?.model ?? "",
+                ...imageChoice(config),
                 aspect: config.format,
                 prompt,
-            }, promptRecipe === undefined ? [] : [promptRecipe.key]),
+                ...(reference === undefined ? {} : { reference: reference.input }),
+            }, [
+            ...(promptRecipe === undefined ? [] : [promptRecipe.key]),
+            ...(reference === undefined ? [] : [reference.key]),
+        ]),
     ];
 }
 export function visualAssets(context, recipes) {

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { estimateRequests } from "../estimate/index.js";
+import { defaultShortsPrompt, shortsImageUpperBound } from "../shorts/model.js";
 import { planDependencies } from "./dependencies.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 import { buildRecipes } from "./recipe-build.js";
@@ -63,7 +64,7 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             null,
         after: row.fingerprint,
     }));
-    const priced = work.map((row) => priceRecipe(row, recipes.find((one) => one.key === row.key)));
+    const priced = work.flatMap((row) => priceRecipes(row, recipes.find((one) => one.key === row.key)));
     return {
         recipes,
         work,
@@ -180,6 +181,74 @@ function retainedFor(row, logical, manifest, available) {
 // ceiling: the timed transcript of a 20-minute narration, about 3,000 words. The real one
 // is only built once the word timing lands.
 const youtubeTranscriptEstimate = 20000;
+// The numbered transcript the shorts are picked from is the same text with a number and a
+// span before every sentence rather than a time before every passage.
+const shortsTranscriptEstimate = 24000;
+// What a step is charged as. Most steps are one request; what stands in for the shorts
+// until they are picked is every clip's image prompts and, at the longest length allowed,
+// every image, which is the most the step can cost.
+export function priceRecipes(work, value) {
+    const input = value?.input;
+    const unfolds = value?.unfoldsImages;
+    // A short's image prompts once the clips are picked: the call, and the images it leads to,
+    // as many as the clip's length asks for.
+    if (work.disposition === "generate" && unfolds !== undefined)
+        return [
+            priceRecipe(work, value),
+            ...Array.from({ length: unfolds.count }, () => ({
+                kind: "image",
+                stage: work.key,
+                provider: unfolds.provider,
+                model: unfolds.model,
+                detail: `${String(unfolds.count)} vertical ${unfolds.count === 1 ? "image" : "images"} for this short, one per stretch of the seconds each image is held.`,
+            })),
+        ];
+    // What stands in for the chapter openers' clips until the chapters are known: one clip for
+    // the opening and for each chapter the article's headings promise, the most it can cost.
+    if (work.disposition === "generate" &&
+        input?.kind === "deferred" &&
+        input.operation === "animate" &&
+        Array.isArray(input.template)) {
+        const [, , provider, model, upper] = input.template;
+        const clips = typeof upper === "number" ? upper : 0;
+        return Array.from({ length: clips }, () => ({
+            kind: "image",
+            stage: work.key,
+            provider: typeof provider === "string" ? provider : "",
+            model: typeof model === "string" ? model : "",
+            detail: `Up to ${String(clips)} animated clips, one per chapter opening; the chapters are found when the word timing lands, so fewer may be made.`,
+        }));
+    }
+    if (work.disposition !== "generate" ||
+        input?.kind !== "deferred" ||
+        input.operation !== "shorts" ||
+        !Array.isArray(input.template))
+        return [priceRecipe(work, value)];
+    const [, style, provider, model, imageSeconds, count, maxSeconds, llmProvider, llmModel] = input.template;
+    const clips = typeof count === "number" ? count : 0;
+    const images = typeof imageSeconds === "number" && typeof maxSeconds === "number"
+        ? shortsImageUpperBound({ count: clips, maxSeconds }, imageSeconds)
+        : 0;
+    const detail = `Up to ${String(images)} vertical images: ${String(clips)} shorts at the longest length allowed. The clips are picked when the step runs, so shorter ones use fewer.`;
+    return [
+        ...Array.from({ length: clips }, () => ({
+            kind: "llm",
+            stage: work.key,
+            provider: typeof llmProvider === "string" ? llmProvider : "",
+            model: typeof llmModel === "string" ? llmModel : "",
+            inputCharacters: (typeof style === "string" ? style.length : 0) + 3000,
+            outputCharacters: 2400,
+            detail: "One LLM call per short writes its image prompts; its length is estimated.",
+        })),
+        ...Array.from({ length: images }, () => ({
+            kind: "image",
+            stage: work.key,
+            provider: typeof provider === "string" ? provider : "",
+            model: typeof model === "string" ? model : "",
+            detail,
+        })),
+    ];
+}
 export function priceRecipe(work, value) {
     if (value === undefined || work.disposition !== "generate")
         return {
@@ -217,6 +286,19 @@ export function priceRecipe(work, value) {
         };
     if (input.kind === "image")
         return { kind: "image", stage: work.key, provider: input.provider, model: input.model };
+    if (input.kind === "local" && input.operation === "shorts-pick-v1") {
+        const [, provider, model, , prompt, count] = Array.isArray(input.values) ? input.values : [];
+        return {
+            kind: "llm",
+            stage: work.key,
+            provider: typeof provider === "string" ? provider : "",
+            model: typeof model === "string" ? model : "",
+            inputCharacters: (typeof prompt === "string" && prompt !== "" ? prompt.length : defaultShortsPrompt.length) +
+                shortsTranscriptEstimate,
+            outputCharacters: 400 * (typeof count === "number" ? count : 1),
+            detail: "The numbered transcript is built when the step runs; its length is estimated. One more call is made when the first answer breaks the rules. Retries are excluded.",
+        };
+    }
     if (input.kind === "local" && input.operation === "youtube-description-v1") {
         const [, provider, model, , prompt] = Array.isArray(input.values) ? input.values : [];
         return {

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

@@ -12,7 +12,14 @@ export async function revisionAction(deps, projectId, action) {
     const config = view.revision.config;
     const content = view.revision.content;
     const image = action.kind === "delete-image" || action.kind === "regenerate-image"
-        ? view.outputs.find((row) => row.selected && row.output.id === action.outputId && row.output.role === "image")
+        ? view.outputs.find((row) => row.selected &&
+            row.output.id === action.outputId &&
+            (row.output.role === "image" ||
+                // A generated establishing image is made again like any image; it is never deleted
+                // on its own (Edit project sets it Off), and an uploaded one has nothing to redo.
+                (action.kind === "regenerate-image" &&
+                    row.output.role === "reference" &&
+                    config.reference?.source === "prompt")))
         : undefined;
     if ((action.kind === "delete-image" || action.kind === "regenerate-image") && image === undefined)
         return { ok: false, reason: "unknown-image" };
@@ -64,7 +71,7 @@ function keyStage(key) {
     const prefix = key.split(":")[0];
     if (prefix === "entry" || prefix === "article")
         return "article";
-    if (prefix === "image")
+    if (prefix === "image" || prefix === "reference")
         return "images";
     if (prefix === "audio")
         return "audio";

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

@@ -0,0 +1,110 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
+import { outputPath, projectDir } from "../storage/layout.js";
+import { runFfmpeg } from "../video/ffmpeg.js";
+import { executionView } from "./runtime-plan.js";
+import { preparedResult, publishResult } from "./runtime-publication.js";
+// Animate images: one still of the slideshow sent to the image provider's image-to-video
+// model, and the clip it makes saved beside the image. The still goes up as a small JPEG, so
+// the request stays well under what either provider takes inline.
+//
+// A clip that cannot be made is not worth failing the video for: after the provider's own
+// retries the step finishes without a clip, saying why, and the render shows the still in
+// its place and puts that sentence on the video (`runtime-export.ts`).
+// ceiling: 1280 px on the long side is more than the 720p the catalogue's models are asked
+// for, and keeps a JPEG to a few hundred KB.
+const sentWidth = 1280;
+export async function executeAnimateRecipe(deps, context, providers, piece) {
+    if (deps.db
+        .prepare("SELECT state FROM revision_work_pieces WHERE id=? AND work_id=?")
+        .get(piece.id, context.work.workId)?.state === "done")
+        return "done";
+    const input = piece.input;
+    if (input.kind !== "image" || input.animate === undefined)
+        throw new Error("Slopify hit an internal error (an animated image was set up wrongly). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+    const imageKey = piece.key.slice("animate:".length);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const index = (view?.revision.content.imageOrder.indexOf(imageKey) ?? -1) + 1;
+    const still = view?.outputs.find((row) => row.workKey === `image:${imageKey}` && row.selected && row.available && row.state === "ready");
+    const fallback = async (reason) => {
+        deps.log.write("warn", "video.animate.fallback", { detail: reason });
+        await publishResult(deps, context, piece, [], {
+            fallback: `Image ${String(index)} is shown as a still: ${reason}`,
+        });
+        return "done";
+    };
+    if (still === undefined)
+        return fallback("its image wasn't ready to animate. Use Re-run section on Video after the image is made.");
+    const animate = providers.forPiece(piece.id).animate;
+    if (animate === undefined)
+        throw new Error("Slopify hit an internal error (animating images isn't wired up in this build). Use Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+    if (!context.maySubmit(piece.id))
+        return "held";
+    let made;
+    try {
+        made = await animate({
+            provider: input.provider,
+            model: input.model,
+            prompt: input.prompt,
+            image: await sendable(deps, context, outputPath(deps.paths, context.work.projectId, still.output.path)),
+            aspect: input.aspect,
+            seconds: input.animate.seconds,
+        });
+    }
+    catch (error) {
+        if (context.signal.aborted)
+            throw error;
+        return fallback(`${error instanceof Error ? error.message : String(error)} To try again, use Re-run section on Video.`);
+    }
+    if (!made.ok)
+        return "held";
+    const asset = writeAsset(deps, context.work.projectId, "animated.mp4", made.value.bytes);
+    try {
+        await publishResult(deps, context, piece, [
+            preparedResult(deps, context, piece, "animated_image", asset, null, {
+                index,
+                prompt: input.prompt,
+                provider: input.provider,
+                model: input.model,
+            }),
+        ], { prompt: input.prompt }, asset);
+        deps.count?.("stage.completed", {
+            stage: context.work.kind,
+            provider: input.provider,
+            model: input.model,
+        });
+    }
+    finally {
+        discardPreparedAssets(deps, [asset]);
+    }
+    return "done";
+}
+// The still as a JPEG no wider than 1280 px, or as it is when there is no ffmpeg to shrink it.
+async function sendable(deps, context, path) {
+    const original = () => {
+        const bytes = new Uint8Array(readFileSync(path));
+        return { bytes, mime: bytes[0] === 0xff ? "image/jpeg" : "image/png" };
+    };
+    if (deps.ffmpeg === undefined)
+        return original();
+    const scratch = mkdtempSync(join(projectDir(deps.paths, context.work.projectId), "animate-"));
+    try {
+        const output = join(scratch, "still.jpg");
+        await runFfmpeg({
+            bin: deps.ffmpeg,
+            args: [
+                ...["-hide_banner", "-nostdin", "-loglevel", "error", "-y", "-i", path],
+                ...["-vf", `scale='min(${String(sentWidth)},iw)':-2`, "-frames:v", "1", "-q:v", "3"],
+                output,
+            ],
+            signal: context.signal,
+            log: deps.log,
+            onProgress: () => undefined,
+        });
+        return { bytes: new Uint8Array(readFileSync(output)), mime: "image/jpeg" };
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}