@gentbajko/slopify 3.0.11 → 3.0.13

package/dist/edge/events/hub.js

@@ -7,6 +7,12 @@ export function createHub(deps) {
     // changes, so the newest one is kept here and replayed to whoever opens next; a page
     // that loads mid-render would otherwise be told nothing is running.
     let tally = { type: "running.count", count: 0 };
+    const present = (event) => deps.presentEvent !== undefined
+        ? deps.presentEvent(event)
+        : deps.acceptEvent?.(event) === false
+            ? undefined
+            : event;
+    const heartbeatMs = deps.heartbeatMs ?? 20_000;
     const send = (subscriber, event) => {
         // writeSSE rejects on a socket that is already gone, asynchronously and long after
         // emit() returned, so a dead subscriber is dropped here instead of at the call site.
@@ -38,6 +44,15 @@ export function createHub(deps) {
         }
         else {
             signal.addEventListener("abort", subscriber.drop, { once: true });
+            if (heartbeatMs > 0) {
+                const beat = setInterval(() => {
+                    subscriber.stream
+                        .writeSSE({ event: "ping", data: "", id: deps.ids.next() })
+                        .catch(() => subscriber.drop());
+                }, heartbeatMs);
+                beat.unref?.();
+                void done.then(() => clearInterval(beat));
+            }
         }
         return subscriber;
     };
@@ -51,33 +66,38 @@ export function createHub(deps) {
                 }
             });
             if (set.has(subscriber))
-                for (const event of previews.snapshot(projectId))
-                    if (deps.acceptEvent?.(event) !== false)
-                        send(subscriber, event);
+                for (const event of previews.snapshot(projectId)) {
+                    const shown = present(event);
+                    if (shown !== undefined)
+                        send(subscriber, shown);
+                }
             return subscriber.done;
         },
         subscribeGlobal: (stream, signal) => {
             const subscriber = join(globals, stream, signal, () => { });
             if (globals.has(subscriber)) {
                 send(subscriber, tally);
+                // What the AI models are writing right now, so a page opened mid-call shows it.
+                for (const event of previews.snapshotAll()) {
+                    const shown = present(event);
+                    if (shown !== undefined)
+                        send(subscriber, shown);
+                }
             }
             return subscriber.done;
         },
         emit: (projectId, event) => {
-            const accepted = deps.acceptEvent?.(event) !== false;
-            if (accepted || event.type === "stage.state")
+            const shown = present(event);
+            if (shown !== undefined)
+                previews.observe(shown);
+            else if (event.type === "stage.state")
                 previews.observe(event);
-            if (!accepted)
+            if (shown === undefined)
                 return;
-            for (const subscriber of projects.get(projectId) ?? []) {
-                send(subscriber, event);
-            }
-            if (event.type === "project.state" ||
-                event.type === "project.updated" ||
-                event.type === "review.flagged") {
-                for (const subscriber of globals)
-                    send(subscriber, event);
-            }
+            for (const subscriber of projects.get(projectId) ?? [])
+                send(subscriber, shown);
+            for (const subscriber of globals)
+                send(subscriber, shown);
         },
         emitGlobal: (event) => {
             if (event.type === "running.count") {

package/dist/edge/events/preview-cache.js

@@ -39,5 +39,6 @@ export function createPreviewCache() {
             }
         },
         snapshot: (projectId) => [...(projects.get(projectId)?.values() ?? [])],
+        snapshotAll: () => [...projects.values()].flatMap((calls) => [...calls.values()]),
     };
 }

package/dist/edge/events/visibility.js

@@ -1,4 +1,7 @@
 import { currentRevisionId } from "../../slices/revisions/repo.js";
+// Whether the work an event came from is the current revision's: made for it, or carried to it
+// from an older revision by an edit that left it unchanged (a video still rendering after a
+// thumbnail redo is still the project's video).
 export function currentWorkOrigin(db, projectId, origin) {
     if (currentRevisionId(db, projectId) === undefined)
         return origin.revisionId === undefined && origin.workId === undefined;
@@ -13,21 +16,52 @@ export function currentWorkOrigin(db, projectId, origin) {
     JOIN json_each(v.fingerprints) f ON f.key=COALESCE(r.logical_key,r.work_key)
       AND f.value=COALESCE(r.desired_fingerprint,r.fingerprint)
     LEFT JOIN revision_work_pieces p ON p.id=r.piece_id AND p.work_id=w.id
-    WHERE w.project_id=? AND w.revision_id=? AND w.id=?
+    WHERE w.project_id=? AND w.id=?
       AND (? IS NULL OR r.piece_id=?)
       AND (r.piece_id IS NULL OR (p.work_key=r.work_key AND p.fingerprint=r.fingerprint))
   `)
-        .get(projectId, origin.revisionId, origin.workId, origin.workPieceId ?? null, origin.workPieceId ?? null) !== undefined);
+        .get(projectId, origin.workId, origin.workPieceId ?? null, origin.workPieceId ?? null) !==
+        undefined);
 }
-export function currentProjectEvent(db, event) {
+// The event as the project's pages should see it, or undefined for one they must not: work the
+// current revision no longer wants. Carried work is told under the current revision, since
+// that is the revision the pages show.
+export function currentEvent(db, event) {
     if (event.type === "project.updated")
-        return true;
+        return event;
     if (event.type === "project.state" &&
         event.revisionId === undefined &&
         event.workId === undefined)
-        return true;
+        return event;
     const head = currentRevisionId(db, event.projectId);
-    if (head !== event.revisionId)
-        return false;
-    return currentWorkOrigin(db, event.projectId, event);
+    if (head === undefined)
+        return currentWorkOrigin(db, event.projectId, event) ? event : undefined;
+    if (!currentWorkOrigin(db, event.projectId, event))
+        return undefined;
+    return event.revisionId === head ? event : { ...event, revisionId: head };
+}
+export function currentProjectEvent(db, event) {
+    return currentEvent(db, event) !== undefined;
+}
+// `currentEvent` for the hub. The streamed text (a token at a time) asks the same question many
+// times a second, so its answer is kept for a second per piece of work.
+export function eventPresenter(db, now = Date.now) {
+    const seen = new Map();
+    return (event) => {
+        if (event.type !== "llm.preview" && event.type !== "article.delta")
+            return currentEvent(db, event);
+        const key = [event.projectId, event.revisionId, event.workId, event.workPieceId].join("|");
+        const hit = seen.get(key);
+        if (hit !== undefined && now() - hit.at < 1000)
+            return !hit.shown
+                ? undefined
+                : hit.revisionId === undefined || hit.revisionId === event.revisionId
+                    ? event
+                    : { ...event, revisionId: hit.revisionId };
+        const shown = currentEvent(db, event);
+        if (seen.size > 512)
+            seen.clear();
+        seen.set(key, { at: now(), shown: shown !== undefined, revisionId: shown?.revisionId });
+        return shown;
+    };
 }

package/dist/main.js

@@ -14,7 +14,7 @@ import { createCatalogueStore } from "./catalog/store.js";
 import { createAutostart } from "./edge/autostart/index.js";
 import { dockerActivationCommitted, dockerFilesLayout, dockerFolderConfiguration, } from "./edge/docker-install/activation.js";
 import { createHub, observedHub } from "./edge/events/hub.js";
-import { currentProjectEvent } from "./edge/events/visibility.js";
+import { eventPresenter } from "./edge/events/visibility.js";
 import { createApp } from "./edge/http/app.js";
 import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
 import { limitRequestTimes } from "./edge/http/timeouts.js";
@@ -219,7 +219,7 @@ export async function boot(config, options = {}) {
         const hub = observedHub(createHub({
             ids,
             log,
-            acceptEvent: (event) => currentProjectEvent(eventDb, event),
+            presentEvent: eventPresenter(eventDb),
         }), (event) => {
             notifier.observe(event);
             episodes?.observe(event);

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/3.0.13.md

@@ -0,0 +1,43 @@
+# Slopify 3.0.13
+
+Released 30 September 2026.
+
+3.0.13 makes every page update live again, tightens the project page, adds run sounds, and fixes Restore and a thumbnail change that remade every image.
+
+## Highlights
+
+- **Pages update live again.** Steps, images, progress and finished runs show up without refreshing, on every page and in every tab.
+- **Run sounds.** A chime when a run starts and a different one when it ends.
+- **History → Restore works again** on projects with scenes, looks, shorts or a YouTube description.
+
+## Live updates
+
+- Each page now keeps one live connection instead of one per project it shows. With a few tabs open, the connections ran out and the page's own requests waited forever: updates arrived but nothing could reload.
+- A run that goes on after an edit (a video still rendering after a thumbnail redo) shows its progress again.
+- The projects list, home and calendar move when steps start and finish, not only when a project changes.
+- The video render's progress moves in tenths of a percent, so a two-hour render moves every few seconds.
+- Pages showing a running project also look again every 15 seconds, in case an update was missed.
+
+## Project page
+
+- The header is one row: the way back, the title, the meta line and the buttons. Each stage's summary sits beside its title, and the run clock sits in the meta line instead of a row of its own, so the content starts much higher.
+- The article shows its word and character count beside its title (the narrated text, without its sources and glossary).
+- **Live** plays the finished narration, with its waveform, and plays the parts so far while it is spoken. Its length reads in hours and minutes.
+
+## Run clock and cost
+
+- The run clock keeps counting through work carried over from before an edit, instead of freezing.
+- **Cost so far** shows the run's working time once it stops, for example "2 h 14 min of work".
+
+## Notifications
+
+- **Run sounds** (Settings → Notifications, on by default): two rising notes when a run starts, three brighter ones when it finishes, fails or waits for you. **Play start** and **Play end** let you hear them. With browser notifications on, a start also shows "Started: *title*".
+
+## Fixes
+
+- **History → Restore this revision** stopped with "unknown kind of step" on projects with Scenes from the article, `{{Appearance}}`, shorts, a YouTube description, levelled narration or animated images.
+- Changing a project's thumbnail settings marked every image outdated. The thumbnails' scenes are now written by a step of their own in the Thumbnail stage.
+
+## Upgrading from 3.0.12
+
+- **Nothing becomes outdated.** A project whose thumbnail prompt uses `{{Scene}}` writes its thumbnail scenes in the new step the next time the thumbnail is made.

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.0.13",
+    "title": "Slopify 3.0.13",
+    "version": "3.0.13",
+    "date": "2026-09-30"
+  },
+  {
+    "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";
@@ -8,7 +9,7 @@ import { masterPlan } from "./recipe-loudness.js";
 import { resourceIdentity } from "./recipe-model.js";
 import { imageReference, referenceRecipe } from "./recipe-reference.js";
 import { withReviews } from "./recipe-reviews.js";
-import { imageScenes } from "./recipe-scenes.js";
+import { imageScenes, thumbnailScenes } from "./recipe-scenes.js";
 import { shortsRecipes } from "./recipe-shorts.js";
 import { textRecipes } from "./recipe-text.js";
 import { thumbnailRecipes, visualAssets, visualRecipes } from "./recipe-visual.js";
@@ -25,13 +26,17 @@ 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' in a step of their own
+    // when their prompt asks.
     const scenes = imageScenes(context, text);
+    const thumbnailScened = thumbnailScenes(context, text);
+    const thumbnail = thumbnailRecipes(context, text.recipes, referenceForThumbnail(context.config) ? drawnFrom : undefined, thumbnailScened, appearance);
+    const youtube = youtubeRecipes(context, exports);
     return withReviews(context, [
         ...text.recipes,
         ...audio.recipes,
@@ -41,7 +46,9 @@ 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]),
+        ...(thumbnailScened === undefined ? [] : [thumbnailScened.recipe]),
+        ...(appearance === undefined ? [] : [appearance.recipe]),
     ]);
 }

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

@@ -47,6 +47,9 @@ export const deferredOperations = [
     // Scenes from the article (`recipe-scenes.ts`): the scenes step and each image waiting on it.
     "image-scenes",
     "image-scene",
+    "thumbnail-scenes",
+    // 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,9 @@ 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 === "thumbnail-scenes" ||
+        input.operation === "image-appearance"
         ? "llm"
         : recipe.stage === "audio"
             ? "tts"