@gentbajko/slopify 2.5.0 → 3.0.1

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

@@ -1,12 +1,21 @@
+import { thumbnailCountOf, thumbnailKey } from "../admission/model.js";
+import { usesShortMode } from "../admission/short-mode.js";
 import { render } from "../admission/substitute.js";
+import { usesAmbientBed } from "../video/ambient-bed.js";
+import { castFor } from "./recipe-cast.js";
+import { noMaster } from "./recipe-loudness.js";
 import { recipe, resourceIdentity, } from "./recipe-model.js";
-import { imageChoice } from "./recipe-reference.js";
+import { castField, imageChoice } from "./recipe-reference.js";
 import { matchingText, renderedPrompt } from "./recipe-text.js";
 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) {
+reference, 
+// The word timing's identity, which a short's captions are drawn from.
+timing = null, 
+// Level the volume: the levelled narration and the master (`recipe-loudness.ts`).
+master = noMaster) {
     const recipes = [];
     const imageKeys = config.sources.images === "off" ? [] : content.imageOrder;
     for (const key of imageKeys) {
@@ -26,10 +35,19 @@ reference) {
                 aspect: config.format,
                 prompt: prompt ?? "",
                 ...(reference === undefined ? {} : { reference: reference.input }),
+                ...castField(castFor(config, prompt)),
             }, 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 short = usesShortMode(config);
+        // A short is rendered by the Shorts renderer, which has no cuts, transitions or Look.
+        const edited = (short ? undefined : edit?.([...recipes])) ?? {
+            recipes: [],
+            values: [],
+            dependsOn: [],
+        };
+        // A short (rendered by the Shorts renderer) never has the bed.
+        const bed = short ? undefined : ambientBedValues(config, content);
         const audioKeys = config.sources.audio === "off"
             ? []
             : [
@@ -64,18 +82,48 @@ reference) {
                 // 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]]),
+                // Only for a short, so every long video keeps its fingerprint: the word-by-word
+                // captions are drawn from the word timing in the caption font, under the title.
+                ...(short
+                    ? [["short-v1", config.subtitles?.fontId ?? "default", config.title, timing]]
+                    : []),
+                // Only while the video has an ambient bed, so every video without one keeps the
+                // fingerprint it always had.
+                ...(bed === undefined ? [] : [bed]),
+                // Only while the volume is levelled, so every video without it keeps its fingerprint.
+                ...master.values,
             ],
         }, [
             ...recipes.map((value) => value.key),
             ...audioKeys,
+            ...master.keys,
             ...(config.subtitles?.mode === "burn-in" ? ["subtitles:files"] : []),
+            ...(short ? ["subtitles:timing"] : []),
             ...edited.dependsOn,
-        ], { unresolved: imageKeys.length === 0 }));
+        ], {
+            unresolved: imageKeys.length === 0 ||
+                (config.ambientBed?.source === "upload" && content.ambientBed === undefined),
+        }));
         // 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;
 }
+// What the ambient bed adds to the render's fingerprint: its settings and, for the user's own
+// file, the project asset it plays. Undefined without a bed.
+export function ambientBedValues(config, content) {
+    const bed = config.ambientBed;
+    if (bed === undefined || !usesAmbientBed(config))
+        return undefined;
+    return [
+        "ambient-bed-v1",
+        bed.source,
+        bed.levelDb,
+        bed.fadeInSeconds,
+        bed.tailSeconds,
+        bed.source === "upload" ? (content.ambientBed ?? null) : null,
+    ];
+}
 export function thumbnailRecipes(context, textRecipes, 
 // The establishing image, when it is on and the thumbnail is drawn from it too.
 reference) {
@@ -95,35 +143,50 @@ reference) {
     const prompt = config.sources.thumbnail === "prompt_by_llm" && promptRecipe !== undefined
         ? matchingText(context, promptRecipe, "prompt")
         : renderedPrompt(context, "thumbnailPrompt");
-    return [
-        recipe(context, "thumbnail:image", "thumbnail", prompt === null
-            ? {
-                kind: "deferred",
-                version: 1,
-                operation: "thumbnail-image",
-                template: [
-                    promptRecipe?.fingerprint ?? null,
-                    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,
-                ...imageChoice(config),
-                aspect: config.format,
-                prompt,
-                ...(reference === undefined ? {} : { reference: reference.input }),
-            }, [
-            ...(promptRecipe === undefined ? [] : [promptRecipe.key]),
-            ...(reference === undefined ? [] : [reference.key]),
-        ]),
-    ];
+    const variants = Array.from({ length: thumbnailCountOf(config) }, (_, index) => index + 1);
+    return variants.map((variant) => recipe(context, thumbnailKey(variant), "thumbnail", prompt === null
+        ? {
+            kind: "deferred",
+            version: 1,
+            operation: "thumbnail-image",
+            template: [
+                promptRecipe?.fingerprint ?? null,
+                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]),
+                ...(variant === 1 ? [] : [["thumbnail-variant", variant]]),
+            ],
+        }
+        : {
+            kind: "image",
+            version: 1,
+            ...imageChoice(config),
+            aspect: config.format,
+            prompt: thumbnailVariantPrompt(prompt, variant),
+            ...(reference === undefined ? {} : { reference: reference.input }),
+            // The thumbnail stands for the whole video, like the establishing image.
+            ...castField(castFor(config, config.title, prompt)),
+        }, [
+        ...(promptRecipe === undefined ? [] : [promptRecipe.key]),
+        ...(reference === undefined ? [] : [reference.key]),
+    ]));
+}
+// The second and third thumbnails are the same prompt asked for another composition, so the
+// three test one idea against itself rather than three ideas. The first is the prompt as it
+// is, which keeps the thumbnail every project already has.
+const variantFraming = {
+    2: "a tight close-up where the main subject fills most of the frame, seen from a different angle",
+    3: "a wider shot that shows the main subject in its setting, placed off-centre with room around it",
+};
+export function thumbnailVariantPrompt(prompt, variant) {
+    const framing = variantFraming[variant];
+    if (framing === undefined)
+        return prompt;
+    return `${prompt}\n\nThis is thumbnail ${String(variant)} of 3 for a YouTube thumbnail test. Keep the subject, style, colours and any text asked for above, but use a clearly different composition: ${framing}.`;
 }
 export function visualAssets(context, recipes) {
     const images = recipes.filter((value) => value.stage === "images");

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

@@ -0,0 +1,286 @@
+import { aliasMatches, applyAliases } from "../../kernel/ports/narration-aliases.js";
+import { splitText } from "../../kernel/ports/text.js";
+import { narrationAliasesOf, usesNarrationPreparation } from "../admission/rules.js";
+import { aliasSpans, withAliasSpans } from "../narration/aliases.js";
+import { normalizeNarrationText } from "../narration/plan.js";
+import { parsePronunciationGlossary, pronunciationSpans, } from "../narration/pronunciation.js";
+import { withSharedGlossary } from "../narration/shared-glossary.js";
+import { prepareRequests } from "../narration/steering.js";
+import { groupTurns } from "../voices/grouping.js";
+import { speakerPace } from "../voices/model.js";
+import { parseScript } from "../voices/script.js";
+import { describedText, describeFuture, describing } from "./recipe-describe.js";
+import { recipe, resourceIdentity, } from "./recipe-model.js";
+import { pauseValues } from "./recipe-pauses.js";
+import { preparationForGroup, preparationFuture, preparationTemplate, } from "./recipe-preparation.js";
+export function voiceBodyRecipes(context, voices, script, glossary) {
+    const parts = [];
+    const preparations = [];
+    const layout = [];
+    // Which parts end a turn, for the pauses between sentences (a turn gap of 0 is still a turn).
+    const turnEnds = new Set();
+    let transcript = script.fingerprint ?? script.text ?? null;
+    const describe = describing(context);
+    const parsed = script.text === null ? undefined : parseScript(script.text, voices.speakers, describe);
+    const prepare = voices.speakers.some((speaker) => preparesTurns(context.config, speaker));
+    // The narration still to be worked out: the whole script's while it is being written, or
+    // every turn's while a turn's delivery cues are (as a single voice waits for all of its own).
+    const future = () => recipe(context, "audio:body:future", "audio", {
+        kind: "deferred",
+        version: 1,
+        operation: "body-narration",
+        template: [
+            script.fingerprint ?? script.text ?? null,
+            speakerValues(voices),
+            ...(prepare ? [preparationTemplate(context)] : []),
+            ...(described.length === 0
+                ? []
+                : [["described-v1", described.map((row) => row.fingerprint)]]),
+        ],
+    }, [
+        ...new Set([
+            ...script.dependsOn,
+            ...described.map((row) => row.key),
+            ...preparations.map((row) => row.key),
+        ]),
+    ]);
+    let pending = false;
+    // A table, figure, equation or code block inside a turn is described within that turn: the
+    // turn says the description where the block was, in the same voice.
+    const described = [];
+    const cards = [];
+    let turns = parsed?.ok === true ? parsed.script.turns : [];
+    if (describe && script.text === null) {
+        const from = script.dependsOn[0];
+        if (from !== undefined)
+            described.push(describeFuture(context, { key: from, fingerprint: script.fingerprint ?? from }));
+    }
+    else if (describe && parsed?.ok === true) {
+        let offset = 0;
+        turns = turns.map((turn) => {
+            if (turn.markdown === undefined)
+                return turn;
+            const said = describedText(context, turn.markdown, script.dependsOn, offset);
+            if (said.recipes.length === 0)
+                return turn;
+            offset += said.recipes.length;
+            described.push(...said.recipes);
+            cards.push(...said.cards);
+            if (said.spoken === null) {
+                pending = true;
+                return turn;
+            }
+            return { ...turn, text: said.spoken.trim().replace(/\s*\n\s*/g, " ") };
+        });
+    }
+    preparations.push(...described);
+    if (script.text === null) {
+        // Turns not yet known are prepared behind one future step, as a single voice's text is.
+        const from = script.dependsOn[0];
+        if (prepare && from !== undefined)
+            preparations.push(preparationFuture(context, "body", { key: from, fingerprint: script.fingerprint ?? from }));
+        parts.push(future());
+    }
+    else if (parsed !== undefined && !parsed.ok) {
+        parts.push(refused(context, "audio:body:turn:1", script.dependsOn, `The script can't be narrated: ${parsed.reason} Fix it in Edit project → Article, then Try again.`));
+    }
+    else if (pending) {
+        parts.push(future());
+    }
+    else if (parsed !== undefined) {
+        transcript = ["voices-transcript-v1", turns.map((turn) => [turn.speaker, turn.text])];
+        const aliases = narrationAliasesOf(context.config);
+        for (const group of groupTurns(turns, voices.speakers, voices.nativeDialogue, (text) => applyAliases(text, aliases).length)) {
+            const first = group.turns[0];
+            const speaker = voices.speakers.find((one) => one.id === first?.speaker);
+            if (first === undefined || speaker === undefined)
+                continue;
+            const made = groupParts(context, voices, group.native, group.turns, speaker, glossary, script, preparations);
+            if (made.length === 0)
+                pending = true;
+            made.forEach((part, index) => {
+                parts.push(part);
+                if (index === made.length - 1)
+                    turnEnds.add(layout.length);
+                layout.push([speakerPace(speaker), index === made.length - 1 ? voices.turnGapSeconds : 0]);
+            });
+        }
+        // No gap after the last turn: the timeline's own gap follows it.
+        const last = layout.at(-1);
+        if (last !== undefined)
+            last[1] = 0;
+        if (pending) {
+            parts.length = 0;
+            layout.length = 0;
+            turnEnds.clear();
+            parts.push(future());
+        }
+    }
+    const body = recipe(context, "audio:body:concat", "audio", {
+        kind: "local",
+        version: 1,
+        operation: "concat-turns-v1",
+        values: [
+            parts.map((part) => resourceIdentity(context, part)),
+            layout,
+            // Pauses between sentences inside a turn; the turn gap stays the layout's.
+            ...pauseValues(context.config, layout.map(([, gap], at) => at === layout.length - 1 ? "end" : gap > 0 || turnEnds.has(at) ? "turn" : "sentence")),
+        ],
+    }, parts.map((part) => part.key), { unresolved: parsed?.ok !== true || pending });
+    return {
+        preparations,
+        cards,
+        parts,
+        body,
+        transcript,
+        ...(parsed?.ok === true ? { sections: parsed.script.sections } : {}),
+    };
+}
+function groupParts(context, voices, native, turns, speaker, glossary, script, preparations) {
+    const first = turns[0];
+    if (first === undefined)
+        return [];
+    const logicalKey = `audio:body:turn:${String(first.index)}`;
+    const override = context.content.narrationOverrides[logicalKey];
+    if (override?.kind === "asset")
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "provided",
+                version: 1,
+                assetId: override.assetId,
+                semantic: [turns.map((turn) => turn.text).join("\n"), speaker.id],
+            }, script.dependsOn, { tokenKey: logicalKey }),
+        ];
+    if (native) {
+        const byId = new Map(voices.speakers.map((one) => [one.id, one]));
+        // Narration aliases reach every line of the one request, each turn on its own so an alias
+        // never joins the end of one turn to the start of the next. The clean turns stay the
+        // transcript, as they do for a voice that gets one request per turn.
+        const aliases = narrationAliasesOf(context.config);
+        const spoken = turns.map((turn) => applyAliases(turn.text, aliases));
+        const logicalText = turns.map((turn) => turn.text).join("\n");
+        const text = spoken.join("\n");
+        return [
+            recipe(context, `${logicalKey}:1`, "audio", {
+                kind: "tts",
+                version: 1,
+                provider: speaker.voice.provider,
+                model: speaker.voice.model,
+                voice: speaker.voice.voice,
+                text,
+                ...(text === logicalText ? {} : { spokenText: logicalText }),
+                logicalKey,
+                logicalText,
+                segment: "body",
+                pronunciation: null,
+                dialogue: turns.map((turn, index) => ({
+                    speaker: turn.speaker,
+                    turn: turn.index,
+                    voice: byId.get(turn.speaker)?.voice.voice ?? "",
+                    text: spoken[index] ?? turn.text,
+                })),
+            }, script.dependsOn, { tokenKey: logicalKey }),
+        ];
+    }
+    const logicalText = normalizeNarrationText(override?.kind === "text" ? override.text : first.text);
+    const entries = speakerGlossary(context, speaker, glossary);
+    if (!entries.ok)
+        return [refused(context, logicalKey, script.dependsOn, entries.reason)];
+    const maxCharacters = context.catalogue?.tts.find((row) => row.provider === speaker.voice.provider &&
+        row.id === speaker.voice.model &&
+        row.enabled &&
+        !row.deprecated)?.tts.maxCharacters ?? Math.max(2, logicalText.length * 4);
+    // Narration aliases apply to every voice, the speaker's pronunciations to IPA voices only.
+    const spans = withAliasSpans(pronunciationSpans(logicalText, entries.entries), aliasSpans(logicalText, narrationAliasesOf(context.config)));
+    if (preparesTurns(context.config, speaker)) {
+        const prepared = preparationForGroup(context, logicalKey, logicalText, "body", script.dependsOn, maxCharacters, spans, aliasMatches(logicalText, narrationAliasesOf(context.config)), { name: speaker.name.trim(), role: speaker.role });
+        preparations.push(prepared.preparation);
+        if (prepared.refusal !== null)
+            return [refused(context, logicalKey, [prepared.preparation.key], prepared.refusal)];
+        return (prepared.requests ?? []).map((request, index) => recipe(context, `${logicalKey}:${String(index + 1)}`, "audio", {
+            kind: "tts",
+            version: 1,
+            provider: speaker.voice.provider,
+            model: speaker.voice.model,
+            voice: speaker.voice.voice,
+            text: request.text,
+            spokenText: request.spokenText,
+            logicalKey,
+            logicalText,
+            segment: "body",
+            pronunciation: null,
+            speaker: speaker.id,
+            turn: first.index,
+        }, [prepared.preparation.key], { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+    }
+    let requests;
+    if (spans.length > 0) {
+        const prepared = prepareRequests(logicalText, [], maxCharacters, spans);
+        if (!prepared.ok)
+            return [refused(context, logicalKey, script.dependsOn, prepared.reason)];
+        requests = prepared.requests;
+    }
+    else
+        requests = splitText(logicalText, maxCharacters).map((text) => ({ text }));
+    return requests.map((request, index) => recipe(context, `${logicalKey}:${String(index + 1)}`, "audio", {
+        kind: "tts",
+        version: 1,
+        provider: speaker.voice.provider,
+        model: speaker.voice.model,
+        voice: speaker.voice.voice,
+        text: request.text,
+        ...(request.spokenText === undefined ? {} : { spokenText: request.spokenText }),
+        logicalKey,
+        logicalText,
+        segment: "body",
+        pronunciation: null,
+        speaker: speaker.id,
+        turn: first.index,
+    }, script.dependsOn, { tokenKey: logicalKey, unresolved: logicalText.length === 0 }));
+}
+// IPA pronunciations reach only the voices that read IPA: the speaker's own first, then the
+// run's glossary where Use Pronunciation Glossary is on.
+function speakerGlossary(context, speaker, glossary) {
+    if (!readsIpa(speaker))
+        return { ok: true, entries: [] };
+    const own = speaker.pronunciations?.trim()
+        ? parsePronunciationGlossary(speaker.pronunciations, context.config.language)
+        : { ok: true, entries: [] };
+    if (!own.ok)
+        return {
+            ok: false,
+            reason: `${speaker.name.trim()}'s pronunciations can't be used: ${own.reason.replace("Edit the glossary or turn off Use Pronunciation Glossary.", "Fix them under Speakers (Play → Narration, or Edit project → Providers).")}`,
+        };
+    const run = context.config.audio?.usePronunciationGlossary === true && glossary?.ok === true
+        ? glossary.entries
+        : [];
+    return { ok: true, entries: withSharedGlossary(own.entries, run) };
+}
+// A turn is prepared when the run has a Narration Preparation prompt and its speaker's voice
+// takes Inworld TTS-2's delivery tags; every other speaker's turns are spoken as written.
+export function preparesTurns(config, speaker) {
+    return (usesNarrationPreparation(config) &&
+        speaker.voice.provider === "inworld" &&
+        speaker.voice.model === "inworld-tts-2");
+}
+export function readsIpa(speaker) {
+    return (speaker.voice.provider === "inworld" &&
+        (speaker.voice.model === "inworld-tts-2" || speaker.voice.model === "inworld-tts-2-flash"));
+}
+function refused(context, logicalKey, dependsOn, reason) {
+    return recipe(context, `${logicalKey}:1`, "audio", { kind: "deferred", version: 1, operation: "resolve-revision-recipe", template: reason }, dependsOn, { unresolved: true, refusal: reason });
+}
+// What a pending script will be spoken with, so a voice change before the script lands is
+// still a change.
+export function speakerValues(voices) {
+    return [
+        voices.nativeDialogue,
+        voices.speakers.map((speaker) => [
+            speaker.id,
+            speaker.voice.provider,
+            speaker.voice.model,
+            speaker.voice.voice,
+            speaker.pronunciations ?? null,
+        ]),
+    ];
+}

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

@@ -1,11 +1,17 @@
 import { z } from "zod";
 import { estimateRequests } from "../estimate/index.js";
+import { skippedGlossaryNotice, skippedSpeakerPronunciations, skippedSpeakerPronunciationsNotice, } from "../narration/pronunciation.js";
+import { isLocalCliProvider } from "../settings/model.js";
 import { defaultShortsPrompt, shortsImageUpperBound } from "../shorts/model.js";
+import { usesVoices } from "../voices/model.js";
 import { planDependencies } from "./dependencies.js";
 import { matchingNarrationPiece } from "./narration-reuse.js";
 import { buildRecipes } from "./recipe-build.js";
 import { manualCuesNeedReview } from "./recipe-exports.js";
 import { selectedReference, } from "./recipe-model.js";
+import { recipeProviderChoice } from "./recipe-provider-choice.js";
+import { narrationGlossary } from "./recipe-text.js";
+import { readsIpa } from "./recipe-voices.js";
 export function planRevisionWork(revision, manifest, catalogue, availableAssetIds, resolved, retainedNarration = []) {
     const selected = {
         outputs: manifest.outputs.filter(selectedReference),
@@ -27,6 +33,7 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
         resolved: { ...resolved, articleMarkdown: usableArticle ? resolved.articleMarkdown : null },
     };
     const logical = buildRecipes(logicalContext);
+    const glossary = narrationGlossary(logicalContext);
     const context = { ...logicalContext, catalogue };
     const recipes = buildRecipes(context).map((row) => ({
         ...row,
@@ -64,7 +71,7 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             null,
         after: row.fingerprint,
     }));
-    const priced = work.flatMap((row) => priceRecipes(row, recipes.find((one) => one.key === row.key)));
+    const priced = work.flatMap((row) => priceRecipes(row, recipes.find((one) => one.key === row.key), revision.config));
     return {
         recipes,
         work,
@@ -74,6 +81,13 @@ export function planRevisionWork(revision, manifest, catalogue, availableAssetId
             (revision.config.chunking?.mode ?? "whole") === "whole"
             ? "Whole-text narration is one logical request. Editing its text rebuilds every provider part of that request."
             : null,
+        glossaryNotice: glossary?.ok === true && glossary.skipped !== undefined
+            ? skippedGlossaryNotice(glossary.skipped)
+            : null,
+        // Only speakers whose voice reads IPA use their pronunciations at all.
+        speakerPronunciationNotice: usesVoices(revision.config) && revision.config.voices !== undefined
+            ? skippedSpeakerPronunciationsNotice(skippedSpeakerPronunciations(revision.config.voices.speakers.filter(readsIpa), revision.config.language))
+            : null,
         costs: estimateRequests(priced, catalogue),
     };
 }
@@ -187,14 +201,16 @@ 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) {
+export function priceRecipes(work, value, 
+// The revision's settings, which name the provider of a request built only when it runs.
+config) {
     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),
+            priceRecipe(work, value, config),
             ...Array.from({ length: unfolds.count }, () => ({
                 kind: "image",
                 stage: work.key,
@@ -223,7 +239,7 @@ export function priceRecipes(work, value) {
         input?.kind !== "deferred" ||
         input.operation !== "shorts" ||
         !Array.isArray(input.template))
-        return [priceRecipe(work, value)];
+        return [priceRecipe(work, value, config)];
     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"
@@ -249,7 +265,7 @@ export function priceRecipes(work, value) {
         })),
     ];
 }
-export function priceRecipe(work, value) {
+export function priceRecipe(work, value, config) {
     if (value === undefined || work.disposition !== "generate")
         return {
             kind: "local",
@@ -259,12 +275,21 @@ export function priceRecipe(work, value) {
                 : "Local, provided, or blocked work; no admitted generation charge.",
         };
     const input = value.input;
+    const onPlan = config === undefined ? undefined : cliRequest(work, value, config);
+    if (onPlan !== undefined)
+        return onPlan;
     if (input.kind === "deferred" && input.operation === "narration-preparation")
         return {
             kind: "unknown",
             stage: work.key,
             detail: "Narration Preparation: one LLM call per future logical chunk or entry; source length is not yet known.",
         };
+    if (input.kind === "deferred" && input.operation === "narration-description")
+        return {
+            kind: "unknown",
+            stage: work.key,
+            detail: "Narration descriptions: one LLM call per table, figure, equation or code block in the article; how many is known once the article is written.",
+        };
     if (input.kind === "llm")
         return {
             kind: "llm",
@@ -273,7 +298,7 @@ export function priceRecipe(work, value) {
             model: input.model,
             inputCharacters: input.messages.reduce((sum, message) => sum + message.content.length, 0) +
                 (input.documents ?? []).reduce((sum, document) => sum + document.content.length, 0),
-            outputCharacters: work.key === "article:body" ? 9000 : 2400,
+            outputCharacters: work.key === "article:body" ? 9000 : input.describe !== undefined ? 600 : 2400,
             detail: "Actual saved request input; output length is estimated. Retries and tools are excluded.",
         };
     if (input.kind === "tts")
@@ -299,6 +324,21 @@ export function priceRecipe(work, value) {
             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.",
         };
     }
+    // A review: the stage's prompt and the item (the article's text, or a short brief beside an
+    // image, which the provider prices as it does).
+    if (input.kind === "local" && input.operation === "review-v1") {
+        const [stage, , , provider, model, , prompt] = 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 : 600) +
+                (stage === "article" || stage === "narration" ? 20000 : 1500),
+            outputCharacters: 400,
+            detail: "The item is read when the step runs; its length is estimated. A failed item made again is reviewed again, which is not in this estimate.",
+        };
+    }
     if (input.kind === "local" && input.operation === "youtube-description-v1") {
         const [, provider, model, , prompt] = Array.isArray(input.values) ? input.values : [];
         return {
@@ -320,3 +360,34 @@ export function priceRecipe(work, value) {
         detail: "Future generated input is unknown. This group materializes under the same admitted revision; its final request count and charge are unknown.",
     };
 }
+// A request built only when its step runs, on a command-line provider: it runs on the user's
+// plan, so it is known at $0, as Play's review prices the same step. Its size is estimated
+// for the API figure beside it; Narration Preparation's number of calls is not known yet, so
+// it has none.
+function cliRequest(work, value, config) {
+    if (value.input.kind !== "deferred")
+        return undefined;
+    const choice = recipeProviderChoice(value, config);
+    if (choice === undefined || !isLocalCliProvider(choice.provider))
+        return undefined;
+    if (choice.family === "image")
+        return { kind: "image", stage: work.key, provider: choice.provider, model: choice.model };
+    if (choice.family !== "llm")
+        return undefined;
+    const preparation = value.input.operation === "narration-preparation" ||
+        value.input.operation === "narration-description";
+    return {
+        kind: "llm",
+        stage: work.key,
+        provider: choice.provider,
+        model: choice.model,
+        inputCharacters: 6000,
+        outputCharacters: work.key === "article:body" ? 9000 : 2400,
+        ...(preparation ? { apiUnknown: true } : {}),
+        detail: preparation
+            ? value.input.operation === "narration-description"
+                ? "Runs on your CLI plan, so it adds no charge. Narration descriptions make one call per table, figure, equation or code block; how many is known once the article is written, so no API figure is given."
+                : "Runs on your CLI plan, so it adds no charge. Narration Preparation makes one call per logical chunk or entry; how many is known when the step runs, so no API figure is given."
+            : "Runs on your CLI plan, so it adds no charge. The request is built when the step runs, so its API figure uses an estimated length.",
+    };
+}

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

@@ -25,6 +25,8 @@ export function youtubeRecipes(context, exports) {
                 // ships as a new operation version rather than a silent change here.
                 config.descriptionPrompt?.trim() ? renderedPrompt(context, "description") : "",
                 config.title,
+                // The project language, only when it is not English, so English keeps its fingerprint.
+                ...(config.language === undefined || config.language === "en" ? [] : [config.language]),
             ],
         }, [timing.key], 
         // A paid LLM call: readiness, the charge warning and the estimate treat it like one.