@gentbajko/slopify 3.0.11 → 3.0.12

package/dist/patch-notes/3.0.12.md

@@ -0,0 +1,25 @@
+# Slopify 3.0.12
+
+Released 30 September 2026.
+
+3.0.12 lets image and thumbnail prompts look things up: how the subject and characters look, and which moment a thumbnail shows. It also fixes a finished video that could be refused after a long render.
+
+## Highlights
+
+- **`{{Appearance}}`: looks, looked up.** A figure is drawn the way people know it, and the same way in every picture.
+- **Thumbnails take `{{Scene}}`.** Each thumbnail shows a striking moment from the article, a different one for each of three.
+- **An edit during a render no longer fails the video.**
+
+## Images and thumbnails
+
+- Put `{{Appearance}}` in an image, thumbnail or establishing prompt, for example a line `Looks: {{Appearance}}`. Once the article is written, one call to the project's AI model searches the web for how the video's subject and every named character look, in their most iconic depiction. Each picture gets the looks of the figures its scene names; a thumbnail always gets the subject's. There is no switch: prompts without it are drawn as before. One more AI call per run.
+- A thumbnail prompt with `{{Scene}}` gets a scene from Scenes from the article: the moment that would make someone click, taken from anywhere in the article, and a different one for each of three thumbnails. Before, `{{Scene}}` reached the image model as literal text.
+
+## Fixes
+
+- A video could render for hours and then stop with "Output fingerprint differs from its authorized recipe." when something in the project was changed while it rendered (a thumbnail made again, say). Its captions are now checked against the project as it is now. A video that failed this way renders again with **Try the video again**.
+- Scroll bars are hidden everywhere; every area still scrolls.
+
+## Upgrading from 3.0.11
+
+- **Nothing becomes outdated.** Prompts without `{{Appearance}}` or a thumbnail `{{Scene}}` are drawn as before.

package/dist/patch-notes/index.json

@@ -1,4 +1,10 @@
 [
+  {
+    "id": "3.0.12",
+    "title": "Slopify 3.0.12",
+    "version": "3.0.12",
+    "date": "2026-09-30"
+  },
   {
     "id": "3.0.11",
     "title": "Slopify 3.0.11",

package/dist/slices/admission/substitute.js

@@ -40,15 +40,20 @@ export function detectSlots(body) {
 // Filled by Slopify, never by the person: each image's own scene, which the project's AI model
 // writes from the article when an image prompt asks for it (`images/scenes.ts`).
 export const sceneKeyword = "Scene";
+// Filled by Slopify too: how the video's subject and the characters in an image look, which the
+// project's AI model looks up on the web when a prompt asks for it (`images/appearance.ts`).
+export const appearanceKeyword = "Appearance";
+// The keywords Slopify fills itself, which are never fields for the person.
+export const filledKeywords = [sceneKeyword, appearanceKeyword];
 // One field per distinct name; Common when a name is used on both sides, otherwise Text or
 // Image. The order is first appearance, which is why both sides arrive as ordered lists of
-// bodies rather than as sets. The scene keyword is not a field: Slopify fills it.
+// bodies rather than as sets. The scene and appearance keywords are not fields: Slopify fills them.
 export function collectFields(textBodies, imageBodies) {
     const text = namesOf(textBodies);
     const image = namesOf(imageBodies);
     const fields = [];
     for (const name of [...text, ...image]) {
-        if (name === sceneKeyword || fields.some((field) => field.name === name)) {
+        if (filledKeywords.includes(name) || fields.some((field) => field.name === name)) {
             continue;
         }
         const onText = text.includes(name);

package/dist/slices/images/appearance.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { appearanceKeyword, detectSlots, render } from "../admission/substitute.js";
+// How things look, looked up rather than guessed: when an image or thumbnail prompt has
+// `{{Appearance}}`, one call to the project's AI model searches the web for how the video's
+// subject and every named character in the article look in their best-known depiction. Each
+// picture then gets the subject's look and the looks of the characters its scene names, so a
+// figure looks the same from image to image and like the one people know.
+export function usesAppearance(body) {
+    return body != null && detectSlots(body).names.includes(appearanceKeyword);
+}
+const figureSchema = z.object({
+    name: z.string(),
+    aliases: z.array(z.string()).default([]),
+    look: z.string(),
+});
+export const appearanceSchema = z.object({
+    subject: figureSchema,
+    characters: z.array(figureSchema).default([]),
+});
+export function appearanceMessages(brief) {
+    return [
+        {
+            role: "system",
+            content: [
+                "You research how things look, for the pictures of a narrated video. Search the web before you answer: official art and its descriptions, the sourcebooks and the wikis that describe them. Do not describe a figure from memory alone.",
+                "Describe the video's subject: the figure, creature, place or object the video is about. Then describe every other named character who could appear in a picture: rivals, servants, gods, companions. Leave out people who only made or published the work, and anyone the article only mentions in passing.",
+                "When depictions disagree (different editions, different artists), describe the most iconic one: the look most people picture, usually the best-known official art.",
+                "Each look is two to four sentences of what can be seen: build and size, face, skin or hide, hair, clothing or armour, colours, and the objects or marks that make the figure recognisable. Nothing about art style or medium, and no story: the style and the scene are set elsewhere.",
+                'Answer with JSON and nothing else: {"subject": {"name": "…", "aliases": ["…"], "look": "…"}, "characters": [{"name": "…", "aliases": ["…"], "look": "…"}]}. Aliases are other names or titles the article uses for the same figure.',
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [
+                `Video: ${brief.title}`,
+                brief.article.trim() === "" ? "" : `Article:\n\n${brief.article}`,
+            ]
+                .filter((part) => part !== "")
+                .join("\n\n"),
+        },
+    ];
+}
+export function checkAppearance(text) {
+    const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
+    const parsed = appearanceSchema.safeParse(jsonObjectOf(text));
+    if (!parsed.success)
+        return { ok: false, reason: `The AI model didn't answer with the looks it looked up. ${fix}` };
+    const tidy = (figure) => ({
+        name: figure.name.trim(),
+        aliases: figure.aliases.map((alias) => alias.trim()).filter((alias) => alias !== ""),
+        look: figure.look.replace(/\s+/g, " ").trim(),
+    });
+    const subject = tidy(parsed.data.subject);
+    if (subject.name === "" || subject.look === "")
+        return { ok: false, reason: `The AI model described no look for the video's subject. ${fix}` };
+    return {
+        ok: true,
+        appearance: {
+            subject,
+            characters: parsed.data.characters
+                .map(tidy)
+                .filter((figure) => figure.name !== "" && figure.look !== ""),
+        },
+    };
+}
+// The most characters besides the subject one picture describes: a crowded prompt is ignored.
+const charactersPerPicture = 3;
+// What `{{Appearance}}` becomes in one picture: the looks of the figures the picture's scene
+// names (by name or alias, as a whole word), the subject first. Without a scene, the subject
+// alone. The subject goes in only when the scene names it, unless it always does (a thumbnail
+// stands for the subject): a scene of a place, or of another figure, is not redrawn with the
+// subject in it. Empty when the scene names no one.
+export function appearanceFor(appearance, scene, options = {}) {
+    const shown = (figure) => scene !== undefined && [figure.name, ...figure.aliases].some((name) => names(scene, name));
+    const subject = scene === undefined || options.subjectAlways === true || shown(appearance.subject)
+        ? [appearance.subject]
+        : [];
+    const named = appearance.characters.filter(shown).slice(0, charactersPerPicture);
+    return [...subject, ...named].map((figure) => `${figure.name}: ${figure.look}`).join("\n");
+}
+// The prompt with its looks; a line asking for looks nobody in the picture has is left out.
+export function withAppearance(body, text) {
+    if (text !== "")
+        return render(body, { [appearanceKeyword]: text });
+    return body
+        .split("\n")
+        .filter((line) => !usesAppearance(line))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function names(text, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[^\\p{L}\\p{N}])${escaped}($|[^\\p{L}\\p{N}])`, "iu").test(text);
+}
+function jsonObjectOf(text) {
+    const start = text.indexOf("{");
+    const end = text.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return undefined;
+    try {
+        return JSON.parse(text.slice(start, end + 1));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/slices/images/scenes.js

@@ -38,8 +38,15 @@ export function pictureKind(body, name) {
 // The count is written on a line of its own so the answer can be checked against it when the
 // call runs (`sceneCountOf`), from the saved request alone.
 const countLine = /^Pictures: (\d+)$/m;
+// The thumbnails' scenes come after the images', one per thumbnail, when the thumbnail
+// prompt asks for one with `{{Scene}}`. They are not tied to a stretch of the article: each is
+// the moment that would make someone click, a different one for each thumbnail.
+const thumbnailLine = /^Thumbnails: (\d+)$/m;
 export function sceneMessages(brief) {
     const count = brief.pictures.length;
+    const thumbnails = brief.thumbnails ?? 0;
+    if (thumbnails > 0)
+        return withThumbnails(brief, count, thumbnails);
     return [
         {
             role: "system",
@@ -63,14 +70,56 @@ export function sceneMessages(brief) {
         },
     ];
 }
+// How many scenes the answer must hold: the images' and then the thumbnails'.
 export function sceneCountOf(messages) {
     for (const message of messages) {
         const found = countLine.exec(message.content);
         if (found?.[1] !== undefined)
-            return Number(found[1]);
+            return Number(found[1]) + Number(thumbnailLine.exec(message.content)?.[1] ?? 0);
     }
     return undefined;
 }
+function withThumbnails(brief, count, thumbnails) {
+    const total = count + thumbnails;
+    const several = thumbnails > 1;
+    return [
+        {
+            role: "system",
+            content: [
+                count === 0
+                    ? `You plan the thumbnail${several ? "s" : ""} for a narrated video. Read the article and write ${several ? `${String(thumbnails)} thumbnail scenes` : "one thumbnail scene"}.`
+                    : "You plan the pictures for a narrated video. Read the article and write one scene for each picture listed, in the listed order, and then the thumbnail scenes.",
+                ...(count === 0
+                    ? []
+                    : [
+                        `The pictures are shown in that order while the article is narrated from start to finish. Divide the article into ${String(count)} consecutive stretches of about equal length: scene 1 comes from the first stretch, scene 2 from the second, and so on, so the last picture's scene comes from the ending. Keep to this order even when a later moment would suit a picture better.`,
+                        "Each picture's scene is one or two sentences saying what the picture shows: the subject, the place, what is happening, and the light and mood. Choose a moment its stretch of the article actually describes, and frame it the way the picture's kind asks (a wide view, a close figure, a moment of action, a mood).",
+                        "Every picture's scene shows something different: never the same subject or moment twice.",
+                    ]),
+                `A thumbnail scene is one or two sentences saying what the thumbnail shows: the video's most recognisable subject in the most striking moment the article describes, the one that would make someone click. It comes from anywhere in the article, not from a stretch.${several ? " Each thumbnail scene shows a different moment or side of the subject, so the thumbnails can be tested against each other." : ""}`,
+                "Describe only what can be seen. No text, lettering, captions, labels or logos in the picture, and nothing about art style or medium: the style is set elsewhere.",
+                count === 0
+                    ? `Answer with a JSON array of exactly ${String(total)} strings, one per thumbnail, and nothing else.`
+                    : `Answer with a JSON array of exactly ${String(total)} strings, one scene per picture in order and then ${several ? `the ${String(thumbnails)} thumbnail scenes` : "the thumbnail scene"}, and nothing else.`,
+                `Pictures: ${String(count)}`,
+                `Thumbnails: ${String(thumbnails)}`,
+            ].join("\n\n"),
+        },
+        {
+            role: "user",
+            content: [
+                `Video: ${brief.title}`,
+                ...(count === 0
+                    ? []
+                    : [
+                        `The ${String(count)} pictures, in order:\n${brief.pictures.map((kind, index) => `${String(index + 1)}. ${kind}`).join("\n")}`,
+                    ]),
+                `Thumbnails: ${String(thumbnails)}`,
+                `Article:\n\n${brief.article}`,
+            ].join("\n\n"),
+        },
+    ];
+}
 export function checkScenes(text, count) {
     const fix = "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.";
     const parsed = z.array(z.string()).safeParse(jsonArrayOf(text));

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

@@ -0,0 +1,82 @@
+import { withLanguage } from "../../kernel/ports/languages.js";
+import { appearanceFor, appearanceMessages, appearanceSchema, usesAppearance, withAppearance, } from "../images/appearance.js";
+import { recipe, selectedReference, } from "./recipe-model.js";
+import { llmInput, llmInputFingerprint } from "./recipe-text.js";
+export const imageAppearanceKey = "images:appearance";
+// The prompt bodies a run draws pictures from: the generated images', the thumbnail's when it
+// is drawn from a Library prompt, and the establishing image's.
+function pictureBodies(context) {
+    const { config, content } = context;
+    const images = config.sources.images === "generate"
+        ? content.imageOrder.flatMap((key) => {
+            const image = content.imageDefinitions[key];
+            if (image?.source !== "generate")
+                return [];
+            return [
+                image.templateKey == null
+                    ? image.prompt
+                    : (content.promptTemplates[image.templateKey] ?? image.prompt),
+            ];
+        })
+        : [];
+    return [
+        ...images,
+        ...(config.sources.thumbnail === "from_prompt"
+            ? [content.promptTemplates.thumbnailPrompt ?? config.rendered.thumbnailPrompt]
+            : []),
+        ...(config.sources.images === "generate" && config.reference?.source === "prompt"
+            ? [content.promptTemplates.referencePrompt ?? config.rendered.referencePrompt]
+            : []),
+    ];
+}
+export function imageAppearance(context, text) {
+    const { config } = context;
+    if (!pictureBodies(context).some(usesAppearance))
+        return undefined;
+    const messages = withLanguage(appearanceMessages({ title: config.title, article: text.articleText ?? "" }), config.language);
+    const value = recipe(context, imageAppearanceKey, config.sources.images === "generate" ? "images" : "thumbnail", text.articleText === null
+        ? {
+            kind: "deferred",
+            version: 1,
+            operation: "image-appearance",
+            template: [llmInputFingerprint(context, messages), text.article.fingerprint],
+        }
+        : llmInput(context, messages, true), [text.article.key]);
+    return {
+        recipe: value,
+        value: text.articleText === null ? undefined : savedAppearance(context, value),
+    };
+}
+// The looks saved for this request, by either fingerprint (see `savedScenes`).
+function savedAppearance(context, value) {
+    const logical = context.catalogue === undefined || value.input.kind !== "llm"
+        ? value.fingerprint
+        : recipe({ content: context.content }, value.key, value.stage, { ...value.input, thinkingConfig: null }, value.dependsOn).fingerprint;
+    const piece = context.manifest.pieces.find((row) => row.key === value.key &&
+        selectedReference(row) &&
+        row.piece.state === "done" &&
+        (row.fingerprint === value.fingerprint || row.fingerprint === logical));
+    if (piece?.piece.payload == null)
+        return undefined;
+    const payload = JSON.parse(piece.piece.payload);
+    const parsed = appearanceSchema.safeParse(payload.appearance);
+    return parsed.success ? parsed.data : undefined;
+}
+// A prompt with its looks filled in: the subject's and those of the characters the scene names.
+// Null while the looks are still being looked up, so the picture waits for them.
+export function withLooks(body, appearance, scene, options) {
+    if (appearance === undefined || !usesAppearance(body))
+        return body;
+    if (appearance.value === undefined)
+        return null;
+    return withAppearance(body, appearanceFor(appearance.value, scene, options));
+}
+// What a picture waiting for the looks adds to its waiting request, and the step it waits on.
+export function lookWait(body, appearance) {
+    return appearance === undefined || !usesAppearance(body)
+        ? { template: [], dependsOn: [] }
+        : {
+            template: [["appearance", appearance.recipe.fingerprint]],
+            dependsOn: [appearance.recipe.key],
+        };
+}

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

@@ -1,4 +1,5 @@
 import { referenceForThumbnail } from "../admission/rules.js";
+import { imageAppearance } from "./recipe-appearance.js";
 import { audioRecipes } from "./recipe-audio.js";
 import { documentRecipes } from "./recipe-document.js";
 import { editPlan } from "./recipe-edit.js";
@@ -25,13 +26,15 @@ export function buildRecipes(context) {
     const exports = exportRecipes(context, audio);
     const captions = exports.find((value) => value.key === "subtitles:files");
     const timing = exports.find((value) => value.key === "subtitles:timing");
+    // How the subject and characters look, looked up when a prompt has `{{Appearance}}`.
+    const appearance = imageAppearance(context, text);
     // The establishing image, when it is on: every other image is drawn from it.
-    const reference = referenceRecipe(context);
+    const reference = referenceRecipe(context, appearance);
     const drawnFrom = imageReference(context, reference);
-    const thumbnail = thumbnailRecipes(context, text.recipes, referenceForThumbnail(context.config) ? drawnFrom : undefined);
-    const youtube = youtubeRecipes(context, exports);
-    // Each image's scene, written from the article, for image prompts that ask for one.
+    // Each image's scene, written from the article, and the thumbnails' when their prompt asks.
     const scenes = imageScenes(context, text);
+    const thumbnail = thumbnailRecipes(context, text.recipes, referenceForThumbnail(context.config) ? drawnFrom : undefined, scenes, appearance);
+    const youtube = youtubeRecipes(context, exports);
     return withReviews(context, [
         ...text.recipes,
         ...audio.recipes,
@@ -41,7 +44,8 @@ export function buildRecipes(context) {
         ...shortsRecipes(context, exports, drawnFrom, audio.cards ?? [], masterPlan(context, audio.levels, "video")),
         ...thumbnail,
         ...documentRecipes(context, text, thumbnail),
-        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images, audio.cards ?? []), drawnFrom, timing === undefined ? null : resourceIdentity(context, timing), withLines(masterPlan(context, audio.levels, "video"), linePlan(context, timing)), scenes)),
+        ...visualAssets(context, visualRecipes(context.config, context.content, audio.mediaFingerprint, captions?.fingerprint ?? null, (images) => editPlan(context, exports, youtube, images, audio.cards ?? []), drawnFrom, timing === undefined ? null : resourceIdentity(context, timing), withLines(masterPlan(context, audio.levels, "video"), linePlan(context, timing)), scenes, appearance)),
         ...(scenes === undefined ? [] : [scenes.recipe]),
+        ...(appearance === undefined ? [] : [appearance.recipe]),
     ]);
 }

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

@@ -47,6 +47,8 @@ export const deferredOperations = [
     // Scenes from the article (`recipe-scenes.ts`): the scenes step and each image waiting on it.
     "image-scenes",
     "image-scene",
+    // How the subject and characters look (`recipe-appearance.ts`), looked up on the web.
+    "image-appearance",
 ];
 export function recipe(context, key, stage, input, dependsOn = [], options = {}) {
     const requestFingerprint = input.kind === "tts" && input.dialogue !== undefined

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

@@ -34,7 +34,8 @@ export function recipeProviderChoice(recipe, config) {
         return undefined;
     const family = input.operation === "narration-preparation" ||
         input.operation === "narration-description" ||
-        input.operation === "image-scenes"
+        input.operation === "image-scenes" ||
+        input.operation === "image-appearance"
         ? "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 { lookWait, withLooks } from "./recipe-appearance.js";
 import { castFor } from "./recipe-cast.js";
 import { recipe, selectedAsset, } from "./recipe-model.js";
 import { renderedPrompt } from "./recipe-text.js";
@@ -16,7 +17,9 @@ export function imageChoice(config) {
         ...(config.images?.thinking === undefined ? {} : { thinking: config.images.thinking }),
     };
 }
-export function referenceRecipe(context) {
+export function referenceRecipe(context, 
+// How the subject looks, for an establishing prompt with `{{Appearance}}`.
+appearance) {
     const { config, content } = context;
     if (!usesReference(config) || config.reference === undefined)
         return undefined;
@@ -27,7 +30,24 @@ export function referenceRecipe(context) {
             assetId: content.provided.reference ?? null,
             semantic: "reference",
         }, [], { unresolved: content.provided.reference === undefined });
-    const prompt = renderedPrompt(context, referencePromptKey);
+    const written = renderedPrompt(context, referencePromptKey);
+    const prompt = withLooks(written, appearance);
+    if (prompt === null) {
+        const wait = lookWait(written, appearance);
+        return recipe(context, referenceKey, "images", {
+            kind: "deferred",
+            version: 1,
+            operation: "image-scene",
+            template: [
+                ...wait.template,
+                written,
+                config.images?.provider ?? null,
+                config.images?.model ?? null,
+                config.format,
+                ...(config.images?.thinking === undefined ? [] : [config.images.thinking]),
+            ],
+        }, wait.dependsOn);
+    }
     return recipe(context, referenceKey, "images", {
         kind: "image",
         version: 1,

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

@@ -1,8 +1,18 @@
 import { z } from "zod";
 import { withLanguage } from "../../kernel/ports/languages.js";
-import { pictureKind, sceneMessages } from "../images/scenes.js";
+import { thumbnailCountOf } from "../admission/model.js";
+import { pictureKind, sceneMessages, usesScene } from "../images/scenes.js";
 import { recipe, selectedReference, } from "./recipe-model.js";
 import { llmInput, llmInputFingerprint } from "./recipe-text.js";
+// A thumbnail drawn from a Library prompt whose text asks for `{{Scene}}` takes one scene per
+// thumbnail; any other thumbnail is drawn as it always was.
+export function thumbnailScenes(context) {
+    const { config, content } = context;
+    if (config.sources.thumbnail !== "from_prompt")
+        return 0;
+    const body = content.promptTemplates.thumbnailPrompt ?? config.rendered.thumbnailPrompt;
+    return usesScene(body) ? thumbnailCountOf(config) : 0;
+}
 export const imageScenesKey = "images:scenes";
 export function imageScenes(context, text) {
     const { config, content } = context;
@@ -24,9 +34,15 @@ export function imageScenes(context, text) {
         keys.push(key);
         pictures.push(pictureKind(body, name));
     }
-    if (keys.length === 0)
+    const thumbnailCount = thumbnailScenes(context);
+    if (keys.length === 0 && thumbnailCount === 0)
         return undefined;
-    const messages = withLanguage(sceneMessages({ title: config.title, article: text.articleText ?? "", pictures }), config.language);
+    const messages = withLanguage(sceneMessages({
+        title: config.title,
+        article: text.articleText ?? "",
+        pictures,
+        ...(thumbnailCount === 0 ? {} : { thumbnails: thumbnailCount }),
+    }), config.language);
     const value = recipe(context, imageScenesKey, "images", text.articleText === null
         ? {
             kind: "deferred",
@@ -35,10 +51,15 @@ export function imageScenes(context, text) {
             template: [llmInputFingerprint(context, messages), text.article.fingerprint],
         }
         : llmInput(context, messages), [text.article.key]);
+    const saved = text.articleText === null
+        ? undefined
+        : savedScenes(context, value, keys.length + thumbnailCount);
     return {
         recipe: value,
         keys,
-        scenes: text.articleText === null ? undefined : savedScenes(context, value, keys.length),
+        scenes: saved?.slice(0, keys.length),
+        thumbnailCount,
+        thumbnails: saved?.slice(keys.length),
     };
 }
 // The scenes saved for this request. The request carries the model's thinking settings from

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

@@ -1,5 +1,5 @@
 import { narrationPreparationFields, shortsFields, usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, videoEditFields, youtubeDescriptionFields, } from "../admission/rules.js";
-import { detectSlots, render, sceneKeyword } from "../admission/substitute.js";
+import { detectSlots, filledKeywords, render } from "../admission/substitute.js";
 import { imagesPerVideoMax } from "../images/scale.js";
 import { loudnessFields } from "../loudness/model.js";
 import { pauseFields } from "../narration/pauses-model.js";
@@ -143,7 +143,7 @@ export function validateRecipeInputs(config, content) {
         if (slots.errors.length > 0)
             fields.push({ field: prompt.field, message: "Fix the keyword placeholders in this prompt." });
         for (const key of slots.names)
-            if (key !== sceneKeyword &&
+            if (!filledKeywords.includes(key) &&
                 (!Object.hasOwn(config.values, key) || !config.values[key]?.trim()))
                 fields.push({ field: `values.${key}`, message: "Enter a value for this keyword." });
     }