@gentbajko/slopify 2.5.0 → 3.0.0

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

@@ -0,0 +1,93 @@
+import { usesDescribedNarration, usesFigureCards, usesShorts } from "../admission/rules.js";
+import { describedBlocks, narrationBlocks, spokenNarration, } from "../narration/blocks.js";
+import { describeMessages, spokenPassage } from "../narration/describe.js";
+import { recipe } from "./recipe-model.js";
+import { llmInput, matchingText, renderedPrompt } from "./recipe-text.js";
+// "Describe tables and figures in the narration": one text-model step per table, figure,
+// diagram, equation or code block (`narration:describe:<n>`, in reading order), whose answer
+// is said in the block's place. The narration is chunked, prepared and spoken from that
+// spoken text, so the captions and the word timing follow what is said; the article, the
+// PDF and the reading view keep the block itself.
+//
+// Off (or absent) plans nothing here and the narration is the flattened article, so a project
+// saved before the setting keeps every fingerprint.
+export const describeFutureKey = "narration:describe:future";
+export function describing(context) {
+    return usesDescribedNarration(context.config);
+}
+// What a description request is made of before its block is known: the instruction family,
+// the model and the style guidance. The future step's template, so a change to any of them
+// reaches the narration still to be written.
+export function describeTemplate(context) {
+    const input = llmInput(context, describeMessages({ kind: "table", index: 1, source: "", section: null }, renderedPrompt(context, "narration"), context.config.language));
+    return [
+        "narration-description-v1",
+        JSON.parse(JSON.stringify({ ...input, thinkingConfig: null })),
+        context.config.audio?.skipCode === true,
+    ];
+}
+// The step that stands in for the descriptions while the text they describe is unwritten.
+export function describeFuture(context, dependency) {
+    return recipe(context, describeFutureKey, "audio", {
+        kind: "deferred",
+        version: 1,
+        operation: "narration-description",
+        template: [dependency.fingerprint, describeTemplate(context)],
+    }, [dependency.key]);
+}
+// The Markdown's described blocks as steps, numbered from `offset + 1`, and the spoken text
+// once every one of them has answered.
+export function describedText(context, markdown, dependsOn, offset = 0) {
+    const { config } = context;
+    const blocks = narrationBlocks(markdown, {
+        code: config.audio?.skipCode === true ? "skip" : "describe",
+        language: config.language,
+    });
+    const style = renderedPrompt(context, "narration");
+    const passages = new Map();
+    const cards = [];
+    const recipes = describedBlocks(blocks).map((block) => {
+        const index = offset + block.index;
+        const value = recipe(context, `narration:describe:${String(index)}`, "audio", {
+            ...llmInput(context, describeMessages(block, style, config.language)),
+            describe: {
+                kind: block.kind,
+                index,
+                ...(block.image === undefined ? {} : { image: block.image }),
+            },
+        }, dependsOn);
+        const answer = matchingText(context, value, "text");
+        passages.set(block.index, answer === null ? null : spokenPassage(answer));
+        if (usesFigureCards(config))
+            cards.push(cardRecipe(context, block, index, dependsOn));
+        return value;
+    });
+    return {
+        recipes,
+        cards,
+        spoken: spokenNarration(blocks, (block) => passages.get(block.index) ?? null),
+    };
+}
+// The card the video shows while block `index` is described: drawn locally from the block in
+// the brand kit's title font and colour (the 3.0 look otherwise), in the video's format, and
+// upright too when a 16:9 project makes Shorts. Regenerated with its own token.
+function cardRecipe(context, block, index, dependsOn) {
+    const { config } = context;
+    const formats = config.format === "16:9" && usesShorts(config) ? ["16:9", "9:16"] : [config.format];
+    return recipe(context, `figure:card:${String(index)}`, "images", {
+        kind: "local",
+        version: 1,
+        operation: "figure-card-v1",
+        values: {
+            kind: block.kind,
+            index,
+            source: block.source,
+            section: block.section,
+            image: block.image ?? null,
+            formats,
+            fontId: config.titleStyle?.fontId ?? config.subtitles?.fontId ?? "default",
+            color: config.titleStyle?.color ?? null,
+            language: config.language ?? "en",
+        },
+    }, dependsOn);
+}

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

@@ -15,7 +15,7 @@ import { recipe, resourceIdentity, selectedReference, } from "./recipe-model.js"
 // 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) {
+export function editPlan(context, exports, youtube, images, cards = []) {
     const { config } = context;
     const edit = videoEditOf(config);
     if (config.sources.video !== "generate")
@@ -38,6 +38,13 @@ export function editPlan(context, exports, youtube, images) {
         values.push(["look-v1", edit.vignette, edit.grain, edit.grade, edit.atmosphere]);
     if (usesChapterCards(config))
         values.push(["cards-v1", config.subtitles?.fontId ?? "default"]);
+    // The brand kit's end screen and title style; nothing when unset, so a project without them
+    // keeps its export fingerprint.
+    const endScreen = config.endScreen?.text.trim() ?? "";
+    if (endScreen !== "")
+        values.push(["end-screen-v1", endScreen]);
+    if (config.titleStyle !== undefined && (usesChapterCards(config) || endScreen !== ""))
+        values.push(["title-style", config.titleStyle.fontId ?? null, config.titleStyle.color ?? null]);
     if (timing !== undefined) {
         values.push(["timing", resourceIdentity(context, timing)]);
         dependsOn.push(timing.key);
@@ -48,6 +55,11 @@ export function editPlan(context, exports, youtube, images) {
         else
             values.push(["chapters", "headings", headingsIdentity(context)]);
     }
+    // "Show tables and figures on screen": each card, placed where its description is spoken.
+    if (cards.length > 0) {
+        values.push(["figure-cards-v1", cards.map((value) => resourceIdentity(context, value))]);
+        dependsOn.push(...cards.map((value) => value.key));
+    }
     const recipes = usesAnimation(config)
         ? animateRecipes(context, images, timing, fromDescription ? description : undefined)
         : [];

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

@@ -1,12 +1,21 @@
+import { projectLanguage } from "../../kernel/ports/languages.js";
 import { usesShorts, usesYoutubeDescription } from "../admission/rules.js";
+import { usesShortMode } from "../admission/short-mode.js";
+import { reviewsNarration } from "../reviews/rules.js";
+import { timingOperation } from "../subtitles/model.js";
 import { audioExportArgs } from "../video/audio-export-args.js";
 import { editNeedsTiming } from "../video/edit-settings.js";
+import { usesVoices } from "../voices/model.js";
+import { portraitValues } from "../voices/portraits.js";
+import { masterPlan } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
 export function exportRecipes(context, audio) {
     const { config, content } = context;
     if (audio.mediaFingerprint === null)
         return [];
     const recipes = [];
+    // Level the volume: the listening files are mastered to the audio files' target.
+    const master = masterPlan(context, audio.levels, "audioFiles");
     if (config.sources.video === "off")
         recipes.push(recipe(context, "export:wav", "video", {
             kind: "local",
@@ -15,30 +24,51 @@ export function exportRecipes(context, audio) {
             values: [
                 audio.mediaFingerprint,
                 audioExportArgs([{ kind: "body", path: "$body", seconds: 0 }], "$output"),
+                ...master.values,
             ],
-        }, audio.keys));
+        }, [...audio.keys, ...master.keys]));
     const captions = config.subtitles !== undefined && config.subtitles.mode !== "off";
-    // 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.
+    // The YouTube description's chapters, the shorts' clips and captions, a short's own
+    // 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.
+    const voices = usesVoices(config) ? config.voices : undefined;
     if (!captions &&
         !usesYoutubeDescription(config) &&
         !usesShorts(config) &&
-        !editNeedsTiming(config))
+        !usesShortMode(config) &&
+        !editNeedsTiming(config) &&
+        !reviewsNarration(config) &&
+        voices?.audioFiles !== true)
         return recipes;
     const timing = recipe(context, "subtitles:timing", "video", {
         kind: "local",
         version: 1,
-        operation: "wav2vec2-en-a19f851-v2-omissions",
+        operation: timingOperation(projectLanguage(config)),
         // The lead-in moves every word, so the edge silence is part of the timing.
         values: [
             audio.timeline,
             config.silenceGapSeconds,
-            config.subtitles?.language ?? "en",
+            // The project language; an English project reads "en" here as it always did.
+            config.language ?? config.subtitles?.language ?? "en",
             config.edgeSilenceSeconds,
+            // Each word learns its speaker and turn on a multi-voice run.
+            ...(voices === undefined ? [] : ["voice-words-v1"]),
         ],
     }, audio.keys);
     recipes.push(timing);
+    if (voices?.audioFiles === true)
+        recipes.push(recipe(context, "voices:files", "video", {
+            kind: "local",
+            version: 1,
+            operation: "audio-files-v1",
+            values: [
+                audio.mediaFingerprint,
+                resourceIdentity(context, timing),
+                (audio.sections ?? []).map((section) => [section.title, section.firstTurn]),
+                config.title,
+                ...master.values,
+            ],
+        }, [...audio.keys, timing.key, ...master.keys], { unresolved: audio.sections === undefined }));
     if (config.subtitles === undefined || config.subtitles.mode === "off")
         return recipes;
     const cues = content.subtitleCues;
@@ -53,7 +83,12 @@ export function exportRecipes(context, audio) {
             kind: "local",
             version: 1,
             operation: "manual-cues-v1",
-            values: [cues.audioFingerprint, cues.cues.map((cue) => ({ ...cue }))],
+            // A cue's speaker only when it has one, so captions edited before speakers were
+            // kept (and every one-voice run's) keep their fingerprint.
+            values: [
+                cues.audioFingerprint,
+                cues.cues.map(({ speaker, ...cue }) => speaker === undefined ? { ...cue } : { ...cue, speaker }),
+            ],
         }, audio.keys);
     recipes.push(cueRecipe);
     recipes.push(recipe(context, "subtitles:files", "video", {
@@ -66,6 +101,11 @@ export function exportRecipes(context, audio) {
             config.subtitles.fontId,
             config.subtitles.fontSize,
             config.subtitles.position,
+            // Only when the brand kit set them, so captions made before keep their fingerprint.
+            ...(config.subtitles.color === undefined && config.subtitles.outlineColor === undefined
+                ? []
+                : [["colours", config.subtitles.color ?? null, config.subtitles.outlineColor ?? null]]),
+            ...(voices === undefined ? [] : [captionSpeakerValues(voices, audio.mediaFingerprint)]),
         ],
     }, [cueRecipe.key]));
     return recipes;
@@ -80,3 +120,17 @@ export function manualCuesNeedReview(context, recipes) {
         cues.audioFingerprint !==
             context.manifest.outputs.find((value) => value.workKey === timing.key && value.state === "ready")?.fingerprint);
 }
+// How the captions show the speakers: names, colours by place, name tags and, for a podcast or
+// interview, the speaker panel, which runs to the end of the narration. The panel's portraits
+// only when a speaker has one; the render reads the caption file's fingerprint, so it follows.
+function captionSpeakerValues(voices, media) {
+    const portraits = portraitValues(voices);
+    return [
+        "voice-captions-v1",
+        voices.format,
+        voices.nameTags,
+        voices.speakers.map((speaker) => [speaker.id, speaker.name.trim()]),
+        media,
+        ...(portraits === undefined ? [] : [["portraits", [...portraits]]]),
+    ];
+}

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { messageRoles, thinkingModes } from "../../kernel/ports/llm.js";
 import { llmDocumentsSchema } from "../../kernel/ports/llm-documents.js";
+import { describedKinds } from "../narration/blocks.js";
 import { deferredOperations, localOperations } from "./recipe-model.js";
 const value = z.lazy(() => z.union([
     z.null(),
@@ -42,6 +43,22 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
         })
             .strict()
             .optional(),
+        // A multi-voice run's script or speaker split: the answer is checked as a script.
+        script: z
+            .object({
+            speakers: z.array(z.object({ id: z.string(), name: z.string() }).strict()),
+            attribute: z.boolean(),
+        })
+            .strict()
+            .optional(),
+        describe: z
+            .object({
+            kind: z.enum(describedKinds),
+            index: z.number().int().positive(),
+            image: z.string().optional(),
+        })
+            .strict()
+            .optional(),
     })
         .strict(),
     z
@@ -58,6 +75,19 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
         segment: z.enum(["body", "intro", "outro"]),
         pronunciation: z.null(),
         wholeRequest: z.boolean().optional(),
+        // A multi-voice run's turn requests; without them every such piece failed to store.
+        speaker: z.string().optional(),
+        turn: z.number().int().optional(),
+        dialogue: z
+            .array(z
+            .object({
+            speaker: z.string(),
+            turn: z.number().int(),
+            voice: z.string(),
+            text: z.string(),
+        })
+            .strict())
+            .optional(),
     })
         .strict(),
     z
@@ -74,6 +104,11 @@ export const recipeInputSchema = z.discriminatedUnion("kind", [
             .object({ fingerprint: z.string(), assetId: z.string().nullable() })
             .strict()
             .optional(),
+        cast: z
+            .array(z
+            .object({ name: z.string(), description: z.string(), images: z.array(z.string()) })
+            .strict())
+            .optional(),
     })
         .strict(),
     z

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

@@ -35,6 +35,13 @@ export function legacyOutputWorkKey(output, config) {
             return `image:${output.id}`;
         case "thumbnail":
             return "thumbnail:image";
+        case "script_md":
+            return "script:attribute";
+        case "audio_mp3":
+        case "audio_m4b":
+            return "voices:files";
+        case "audio_levelled":
+            return `level:${output.meta.segment ?? "body"}`;
         case "reference":
             return referenceKey;
         case "notes":
@@ -71,6 +78,8 @@ export function legacyOutputWorkKey(output, config) {
         // Only ever made by a revision, never by the legacy stages.
         case "animated_image":
             return `animate:${String(output.meta.index ?? 1)}`;
+        case "figure_card":
+            return `figure:card:${String(output.meta.index ?? 1)}`;
         case "subtitles_srt":
         case "subtitles_vtt":
         case "subtitle_ass":

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

@@ -0,0 +1,45 @@
+import { pieceLufs, pieceTruePeak, truePeakOf, usesLoudness, } from "../loudness/model.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+// Level the volume (`loudness/model.ts`): beside each narration join, a step that joins the
+// same pieces again, each brought to one loudness first. The plain join stays what it was, and
+// the word timing keeps reading it, so turning the setting on never makes the timing, or the
+// description, shorts and reviews written from it, again: only these steps and the exports that
+// play their files. The keys are outside `audio:` on purpose, where the narration's own pieces
+// and joins are recognised by their keys.
+export const levelOperation = "level-narration-v1";
+export function levelKey(segment) {
+    return `level:${segment}`;
+}
+export function levelRecipe(context, join, segment) {
+    if (!usesLoudness(context.config) || join.input.kind !== "local")
+        return undefined;
+    return recipe(context, levelKey(segment), "audio", {
+        kind: "local",
+        version: 1,
+        operation: levelOperation,
+        // The join it repeats, as that join's own recipe has it: the pieces and their layout.
+        values: [
+            join.input.operation,
+            join.input.values,
+            ["piece-level-v1", pieceLufs, pieceTruePeak],
+        ],
+    }, join.dependsOn, { unresolved: join.unresolved });
+}
+export const noMaster = { values: [], keys: [] };
+export function masterPlan(context, levels, target) {
+    const settings = context.config.loudness;
+    if (!usesLoudness(context.config) || settings === undefined)
+        return noMaster;
+    const lufs = target === "video" ? settings.videoLufs : settings.audioFilesLufs;
+    return {
+        values: [
+            [
+                "loudness-v1",
+                levels.map((level) => resourceIdentity(context, level)),
+                lufs,
+                truePeakOf(target),
+            ],
+        ],
+        keys: levels.map((level) => level.key),
+    };
+}

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

@@ -4,6 +4,8 @@ import { narrationRegenerationToken, narrationRequestFingerprint } from "../narr
 export const localOperations = [
     "export-wav",
     "wav2vec2-en-a19f851-v2-omissions",
+    "wav2vec2-xlsr56-2d48b01-v1",
+    "sentence-timing-v1",
     "automatic-cues-v1",
     "manual-cues-v1",
     "subtitle-files-v1",
@@ -19,9 +21,16 @@ export const localOperations = [
     "youtube-description-v1",
     "shorts-pick-v1",
     "short-render-v1",
+    "review-v1",
+    "concat-turns-v1",
+    "voice-captions-v1",
+    "audio-files-v1",
+    "level-narration-v1",
+    "figure-card-v1",
 ];
 export const deferredOperations = [
     "narration-preparation",
+    "narration-description",
     "research-synthesis",
     "article",
     "entry:intro:text",
@@ -34,14 +43,24 @@ export const deferredOperations = [
     "resolve-revision-recipe",
     "shorts",
     "animate",
+    "script-attribution",
 ];
 export function recipe(context, key, stage, input, dependsOn = [], options = {}) {
-    const requestFingerprint = input.kind === "tts"
-        ? narrationRequestFingerprint({
-            ...input,
-            wholeText: input.wholeRequest === true ? input.logicalText : null,
-        })
-        : fingerprint(JSON.parse(JSON.stringify(input, (_key, value) => typeof value === "number" ? z.number().finite().parse(value) : value)));
+    const requestFingerprint = input.kind === "tts" && input.dialogue !== undefined
+        ? // One request, several voices: every line's voice and words are what was sent.
+            fingerprint([
+                "narration-dialogue-v1",
+                input.provider,
+                input.model,
+                input.dialogue.map((line) => [line.voice, line.text]),
+                input.segment,
+            ])
+        : input.kind === "tts"
+            ? narrationRequestFingerprint({
+                ...input,
+                wholeText: input.wholeRequest === true ? input.logicalText : null,
+            })
+            : 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)
         : options.token !== undefined

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

@@ -0,0 +1,7 @@
+import { pausesOf } from "../narration/pauses-model.js";
+export function pauseValues(config, next) {
+    const pauses = pausesOf(config);
+    if (pauses === undefined)
+        return [];
+    return [["pauses-v1", pauses.sentenceSeconds, pauses.paragraphSeconds, [...next]]];
+}

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

@@ -4,7 +4,7 @@ import { prepareRequests } from "../narration/steering.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, renderedPrompt } from "./recipe-text.js";
 export function preparationTemplate(context) {
-    const input = llmInput(context, preparationMessages(renderedPrompt(context, "narration"), ""));
+    const input = llmInput(context, preparationMessages(renderedPrompt(context, "narration"), "", [], context.config.language));
     return [
         "inworld-tts-2",
         1,
@@ -25,9 +25,9 @@ export function preparationFuture(context, segment, dependency, additionalDepend
         ],
     }, [...new Set([dependency.key, ...additionalDependencies.map((row) => row.key)])]);
 }
-export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = []) {
+export function preparationForGroup(context, logicalKey, source, segment, dependsOn, maxCharacters, spans = [], aliases = [], speaker) {
     const preparation = recipe(context, `narration:prepare:${segment}:${logicalKey}`, "audio", {
-        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source)),
+        ...llmInput(context, preparationMessages(renderedPrompt(context, "narration"), source, aliases, context.config.language, speaker)),
         preparation: { format: "inworld-tts-2", version: 1, source, logicalKey, segment },
     }, dependsOn, { unresolved: source.trim() === "" });
     if (source.trim() === "")

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

@@ -5,6 +5,16 @@ 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" };
+    // A review's request is built when it runs, from the reviewer the project chose.
+    if (input.kind === "local" && input.operation === "review-v1")
+        return config.reviews === undefined
+            ? undefined
+            : {
+                provider: config.reviews.provider,
+                model: config.reviews.model,
+                ...(config.reviews.thinking === undefined ? {} : { thinking: config.reviews.thinking }),
+                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")
@@ -22,7 +32,7 @@ export function recipeProviderChoice(recipe, config) {
             };
     if (input.kind !== "deferred")
         return undefined;
-    const family = input.operation === "narration-preparation"
+    const family = input.operation === "narration-preparation" || input.operation === "narration-description"
         ? "llm"
         : recipe.stage === "audio"
             ? "tts"

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

@@ -1,5 +1,6 @@
 import { referenceKey } from "../admission/model.js";
 import { usesReference } from "../admission/rules.js";
+import { castFor } from "./recipe-cast.js";
 import { recipe, selectedAsset, } from "./recipe-model.js";
 import { renderedPrompt } from "./recipe-text.js";
 // The establishing image (`RunDraft.reference`): one step of the Images stage, made before
@@ -27,7 +28,16 @@ export function referenceRecipe(context) {
             semantic: "reference",
         }, [], { unresolved: content.provided.reference === undefined });
     const prompt = renderedPrompt(context, referencePromptKey);
-    return recipe(context, referenceKey, "images", { kind: "image", version: 1, ...imageChoice(config), aspect: config.format, prompt }, [], { unresolved: prompt.trim() === "" });
+    return recipe(context, referenceKey, "images", {
+        kind: "image",
+        version: 1,
+        ...imageChoice(config),
+        aspect: config.format,
+        prompt,
+        // The establishing image sets the look for the whole video, so it is drawn with every
+        // member the title mentions as well as the ones its own brief does.
+        ...castField(castFor(config, config.title, prompt)),
+    }, [], { unresolved: prompt.trim() === "" });
 }
 // Which image the others are drawn from: the step's fingerprint, so making it again or
 // changing it marks every image drawn from it outdated, and the asset it made.
@@ -42,3 +52,7 @@ export function imageReference(context, reference) {
             },
         };
 }
+// The request's `cast`, only when some member is mentioned.
+export function castField(cast) {
+    return cast === undefined ? {} : { cast };
+}

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

@@ -0,0 +1,117 @@
+import { narrationItemKey, reviewKey, reviewModeOf, reviewPromptKey, reviewRetriesOf, } from "../reviews/model.js";
+import { activeReviewStages } from "../reviews/rules.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { renderedPrompt } from "./recipe-text.js";
+// A review is a step of its own, `review:<item>`, planned like any other: it waits for the
+// item, its fingerprint follows the item's output, the reviewer and the prompt, and it is
+// kept and reused while those stay the same. What depends on a reviewed item waits for its
+// review too, so the run moves on only once the reviewer has answered - the automatic twin
+// of a review checkpoint. With every review Off nothing here is added and no step changes.
+export function withReviews(context, recipes) {
+    const settings = context.config.reviews;
+    const stages = activeReviewStages(context.config);
+    if (settings === undefined || stages.length === 0)
+        return recipes;
+    const byKey = new Map(recipes.map((row) => [row.key, row]));
+    const items = stages.flatMap((stage) => reviewedItems(stage, recipes, byKey));
+    const reviews = items.map((item) => recipe(context, reviewKey(item.itemKey), stageOf(item.stage), {
+        kind: "local",
+        version: 1,
+        operation: "review-v1",
+        values: [
+            item.stage,
+            item.itemKey,
+            item.inputs.map((input) => [input.key, resourceIdentity(context, input)]),
+            settings.provider,
+            settings.model,
+            settings.thinking ?? null,
+            // Blank means the stage's 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.
+            settings.stages[item.stage]?.prompt?.trim()
+                ? renderedPrompt(context, reviewPromptKey(item.stage))
+                : "",
+            reviewModeOf(settings, item.stage),
+            reviewRetriesOf(settings),
+        ],
+    }, item.inputs.map((input) => input.key), 
+    // A paid LLM call: readiness, the charge warning and the estimate treat it like one.
+    { kind: "provider" }));
+    const gated = recipes.map((row) => {
+        const waits = items.flatMap((item, index) => {
+            const review = reviews[index];
+            if (review === undefined || !row.dependsOn.some((key) => item.gates.includes(key)))
+                return [];
+            // A step the review itself reads (the word timing the narration review hears) must not
+            // wait for it.
+            return upstream(review, byKey).has(row.key) ? [] : [review.key];
+        });
+        return waits.length === 0 ? row : { ...row, dependsOn: [...row.dependsOn, ...waits] };
+    });
+    return [...gated, ...reviews];
+}
+function reviewedItems(stage, recipes, byKey) {
+    const one = (itemKey, inputs, gates) => ({ stage, itemKey, inputs, gates });
+    switch (stage) {
+        case "article": {
+            const article = byKey.get("article:body");
+            return article === undefined || article.kind !== "provider"
+                ? []
+                : [one(article.key, [article], [article.key])];
+        }
+        case "images": {
+            const reference = byKey.get("reference:image");
+            return recipes
+                .filter((row) => row.key.startsWith("image:") && row.input.kind === "image")
+                .map((row) => one(row.key, reference === undefined ? [row] : [row, reference], [row.key]));
+        }
+        // One thumbnail, or each of three when the project makes three to compare.
+        case "thumbnail":
+            return recipes
+                .filter((row) => /^thumbnail:image(?::\d+)?$/.test(row.key) && row.kind === "provider")
+                .map((row) => one(row.key, [row], [row.key]));
+        case "narration": {
+            const timing = byKey.get("subtitles:timing");
+            if (timing === undefined)
+                return [];
+            const article = byKey.get("article:body");
+            return [
+                one(narrationItemKey, article === undefined ? [timing] : [timing, article], [
+                    timing.key,
+                    ...timing.dependsOn,
+                ]),
+            ];
+        }
+        case "shorts":
+            return recipes.flatMap((row) => {
+                const match = /^(shorts:\d+):render$/.exec(row.key);
+                return match?.[1] === undefined ? [] : [one(match[1], [row], [row.key])];
+            });
+    }
+}
+// The Images stage runs the image reviews and the Video stage the shorts'; the others run in
+// the stage that made the item.
+function stageOf(stage) {
+    switch (stage) {
+        case "article":
+            return "article";
+        case "images":
+            return "images";
+        case "narration":
+            return "audio";
+        case "thumbnail":
+            return "thumbnail";
+        case "shorts":
+            return "video";
+    }
+}
+function upstream(review, byKey) {
+    const seen = new Set();
+    const queue = [...review.dependsOn];
+    for (let key = queue.pop(); key !== undefined; key = queue.pop()) {
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        queue.push(...(byKey.get(key)?.dependsOn ?? []));
+    }
+    return seen;
+}