@gentbajko/slopify 2.4.0 → 3.0.0

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

@@ -1,5 +1,9 @@
-import { narrationPreparationFields, shortsFields, usesNarrationPreparation, usesShorts, usesYoutubeDescription, videoEditFields, 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 { imagesPerVideoMax } from "../images/scale.js";
+import { loudnessFields } from "../loudness/model.js";
+import { pauseFields } from "../narration/pauses-model.js";
+import { reviewFields } from "../reviews/rules.js";
 import { usesAnimation } from "../video/edit-settings.js";
 export function validateRecipeInputs(config, content) {
     const fields = [
@@ -7,6 +11,9 @@ export function validateRecipeInputs(config, content) {
         ...youtubeDescriptionFields(config),
         ...shortsFields(config),
         ...videoEditFields(config),
+        ...reviewFields(config),
+        ...loudnessFields(config.loudness),
+        ...pauseFields(config),
     ];
     const llm = (config.sources.research === "generate" && config.sources.article !== "provide") ||
         (config.sources.article === "generate" && !content.articleEdited) ||
@@ -33,8 +40,13 @@ export function validateRecipeInputs(config, content) {
         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)
-        fields.push({ field: "content.imageOrder", message: "Keep at most 60 images." });
+    // 60, or more for a project that scales its images with the narration (`images/scale.ts`).
+    const imagesMax = imagesPerVideoMax(config);
+    if (content.imageOrder.length > imagesMax)
+        fields.push({
+            field: "content.imageOrder",
+            message: `Keep at most ${String(imagesMax)} images.`,
+        });
     const chunking = config.chunking;
     const size = chunking?.mode === "words"
         ? chunking.words
@@ -93,6 +105,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,9 +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 { 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) {
+edit, 
+// The establishing image the generated images are drawn from, when it is on.
+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) {
@@ -19,14 +31,23 @@ edit) {
             : {
                 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 }),
+                ...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"
             ? []
             : [
@@ -61,19 +82,51 @@ edit) {
                 // 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;
 }
-export function thumbnailRecipes(context, textRecipes) {
+// 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) {
     const { config, content } = context;
     if (config.sources.thumbnail === "off")
         return [];
@@ -90,28 +143,50 @@ export function thumbnailRecipes(context, textRecipes) {
     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,
-                ],
-            }
-            : {
-                kind: "image",
-                version: 1,
-                provider: config.images?.provider ?? "",
-                model: config.images?.model ?? "",
-                aspect: config.format,
-                prompt,
-            }, promptRecipe === undefined ? [] : [promptRecipe.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 → Audio, 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,
+        ]),
+    ];
+}